dali-csharp-binder/dali-core/actor-wrap.cpp

   1 /*
   2  * Copyright (c) 2023 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 <dali/devel-api/actors/actor-devel.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali-csharp-binder/common/common.h>
  23
  24 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  25
  26 // SWIGINTERN - the relevant parts of the generated code can be seen the below.
  27
  28 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)> const* self)
  29 {
  30   return self->Empty();
  31 }
  32 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)> const* self)
  33 {
  34   return self->GetConnectionCount();
  35 }
  36 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&))
  37 {
  38   self->Connect(func);
  39 }
  40 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&))
  41 {
  42   self->Disconnect(func);
  43 }
  44 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* self, Dali::Actor arg1, Dali::TouchEvent const& arg2)
  45 {
  46   return self->Emit(arg1, arg2);
  47 }
  48 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)> const* self)
  49 {
  50   return self->Empty();
  51 }
  52 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)> const* self)
  53 {
  54   return self->GetConnectionCount();
  55 }
  56 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* self, bool (*func)(Dali::Actor, Dali::HoverEvent const&))
  57 {
  58   self->Connect(func);
  59 }
  60 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* self, bool (*func)(Dali::Actor, Dali::HoverEvent const&))
  61 {
  62   self->Disconnect(func);
  63 }
  64 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* self, Dali::Actor arg1, Dali::HoverEvent const& arg2)
  65 {
  66   return self->Emit(arg1, arg2);
  67 }
  68 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)> const* self)
  69 {
  70   return self->Empty();
  71 }
  72 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)> const* self)
  73 {
  74   return self->GetConnectionCount();
  75 }
  76 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* self, bool (*func)(Dali::Actor, Dali::WheelEvent const&))
  77 {
  78   self->Connect(func);
  79 }
  80 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* self, bool (*func)(Dali::Actor, Dali::WheelEvent const&))
  81 {
  82   self->Disconnect(func);
  83 }
  84 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* self, Dali::Actor arg1, Dali::WheelEvent const& arg2)
  85 {
  86   return self->Emit(arg1, arg2);
  87 }
  88 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal<void(Dali::Actor)> const* self)
  89 {
  90   return self->Empty();
  91 }
  92 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::Actor)> const* self)
  93 {
  94   return self->GetConnectionCount();
  95 }
  96 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal<void(Dali::Actor)>* self, void (*func)(Dali::Actor))
  97 {
  98   self->Connect(func);
  99 }
 100 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal<void(Dali::Actor)>* self, void (*func)(Dali::Actor))
 101 {
 102   self->Disconnect(func);
 103 }
 104 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal<void(Dali::Actor)>* self, Dali::Actor arg)
 105 {
 106   /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 107   /*@SWIG@*/ self->Emit(arg);
 108 }
 109
 110 using namespace Dali;
 111
 112 #ifdef __cplusplus
 113 extern "C" {
 114 #endif
 115
 116 // Property
 117
 118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get()
 119 {
 120   int jresult;
 121   int result;
 122
 123   result  = (int)Dali::Actor::Property::PARENT_ORIGIN;
 124   jresult = (int)result;
 125   return jresult;
 126 }
 127
 128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get()
 129 {
 130   int jresult;
 131   int result;
 132
 133   result  = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
 134   jresult = (int)result;
 135   return jresult;
 136 }
 137
 138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get()
 139 {
 140   int jresult;
 141   int result;
 142
 143   result  = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
 144   jresult = (int)result;
 145   return jresult;
 146 }
 147
 148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get()
 149 {
 150   int jresult;
 151   int result;
 152
 153   result  = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
 154   jresult = (int)result;
 155   return jresult;
 156 }
 157
 158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get()
 159 {
 160   int jresult;
 161   int result;
 162
 163   result  = (int)Dali::Actor::Property::ANCHOR_POINT;
 164   jresult = (int)result;
 165   return jresult;
 166 }
 167
 168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get()
 169 {
 170   int jresult;
 171   int result;
 172
 173   result  = (int)Dali::Actor::Property::ANCHOR_POINT_X;
 174   jresult = (int)result;
 175   return jresult;
 176 }
 177
 178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get()
 179 {
 180   int jresult;
 181   int result;
 182
 183   result  = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
 184   jresult = (int)result;
 185   return jresult;
 186 }
 187
 188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get()
 189 {
 190   int jresult;
 191   int result;
 192
 193   result  = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
 194   jresult = (int)result;
 195   return jresult;
 196 }
 197
 198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get()
 199 {
 200   int jresult;
 201   int result;
 202
 203   result  = (int)Dali::Actor::Property::SIZE;
 204   jresult = (int)result;
 205   return jresult;
 206 }
 207
 208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get()
 209 {
 210   int jresult;
 211   int result;
 212
 213   result  = (int)Dali::Actor::Property::SIZE_WIDTH;
 214   jresult = (int)result;
 215   return jresult;
 216 }
 217
 218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get()
 219 {
 220   int jresult;
 221   int result;
 222
 223   result  = (int)Dali::Actor::Property::SIZE_HEIGHT;
 224   jresult = (int)result;
 225   return jresult;
 226 }
 227
 228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get()
 229 {
 230   int jresult;
 231   int result;
 232
 233   result  = (int)Dali::Actor::Property::SIZE_DEPTH;
 234   jresult = (int)result;
 235   return jresult;
 236 }
 237
 238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get()
 239 {
 240   int jresult;
 241   int result;
 242
 243   result  = (int)Dali::Actor::Property::POSITION;
 244   jresult = (int)result;
 245   return jresult;
 246 }
 247
 248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get()
 249 {
 250   int jresult;
 251   int result;
 252
 253   result  = (int)Dali::Actor::Property::POSITION_X;
 254   jresult = (int)result;
 255   return jresult;
 256 }
 257
 258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get()
 259 {
 260   int jresult;
 261   int result;
 262
 263   result  = (int)Dali::Actor::Property::POSITION_Y;
 264   jresult = (int)result;
 265   return jresult;
 266 }
 267
 268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get()
 269 {
 270   int jresult;
 271   int result;
 272
 273   result  = (int)Dali::Actor::Property::POSITION_Z;
 274   jresult = (int)result;
 275   return jresult;
 276 }
 277
 278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get()
 279 {
 280   int jresult;
 281   int result;
 282
 283   result  = (int)Dali::Actor::Property::WORLD_POSITION;
 284   jresult = (int)result;
 285   return jresult;
 286 }
 287
 288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get()
 289 {
 290   int jresult;
 291   int result;
 292
 293   result  = (int)Dali::Actor::Property::WORLD_POSITION_X;
 294   jresult = (int)result;
 295   return jresult;
 296 }
 297
 298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get()
 299 {
 300   int jresult;
 301   int result;
 302
 303   result  = (int)Dali::Actor::Property::WORLD_POSITION_Y;
 304   jresult = (int)result;
 305   return jresult;
 306 }
 307
 308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get()
 309 {
 310   int jresult;
 311   int result;
 312
 313   result  = (int)Dali::Actor::Property::WORLD_POSITION_Z;
 314   jresult = (int)result;
 315   return jresult;
 316 }
 317
 318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get()
 319 {
 320   int jresult;
 321   int result;
 322
 323   result  = (int)Dali::Actor::Property::ORIENTATION;
 324   jresult = (int)result;
 325   return jresult;
 326 }
 327
 328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get()
 329 {
 330   int jresult;
 331   int result;
 332
 333   result  = (int)Dali::Actor::Property::WORLD_ORIENTATION;
 334   jresult = (int)result;
 335   return jresult;
 336 }
 337
 338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get()
 339 {
 340   int jresult;
 341   int result;
 342
 343   result  = (int)Dali::Actor::Property::SCALE;
 344   jresult = (int)result;
 345   return jresult;
 346 }
 347
 348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get()
 349 {
 350   int jresult;
 351   int result;
 352
 353   result  = (int)Dali::Actor::Property::SCALE_X;
 354   jresult = (int)result;
 355   return jresult;
 356 }
 357
 358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get()
 359 {
 360   int jresult;
 361   int result;
 362
 363   result  = (int)Dali::Actor::Property::SCALE_Y;
 364   jresult = (int)result;
 365   return jresult;
 366 }
 367
 368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get()
 369 {
 370   int jresult;
 371   int result;
 372
 373   result  = (int)Dali::Actor::Property::SCALE_Z;
 374   jresult = (int)result;
 375   return jresult;
 376 }
 377
 378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get()
 379 {
 380   int jresult;
 381   int result;
 382
 383   result  = (int)Dali::Actor::Property::WORLD_SCALE;
 384   jresult = (int)result;
 385   return jresult;
 386 }
 387
 388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get()
 389 {
 390   int jresult;
 391   int result;
 392
 393   result  = (int)Dali::Actor::Property::VISIBLE;
 394   jresult = (int)result;
 395   return jresult;
 396 }
 397
 398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get()
 399 {
 400   int jresult;
 401   int result;
 402
 403   result  = (int)Dali::Actor::Property::COLOR;
 404   jresult = (int)result;
 405   return jresult;
 406 }
 407
 408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get()
 409 {
 410   int jresult;
 411   int result;
 412
 413   result  = (int)Dali::Actor::Property::COLOR_RED;
 414   jresult = (int)result;
 415   return jresult;
 416 }
 417
 418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get()
 419 {
 420   int jresult;
 421   int result;
 422
 423   result  = (int)Dali::Actor::Property::COLOR_GREEN;
 424   jresult = (int)result;
 425   return jresult;
 426 }
 427
 428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get()
 429 {
 430   int jresult;
 431   int result;
 432
 433   result  = (int)Dali::Actor::Property::COLOR_BLUE;
 434   jresult = (int)result;
 435   return jresult;
 436 }
 437
 438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get()
 439 {
 440   int jresult;
 441   int result;
 442
 443   result  = (int)Dali::Actor::Property::COLOR_ALPHA;
 444   jresult = (int)result;
 445   return jresult;
 446 }
 447
 448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get()
 449 {
 450   int jresult;
 451   int result;
 452
 453   result  = (int)Dali::Actor::Property::WORLD_COLOR;
 454   jresult = (int)result;
 455   return jresult;
 456 }
 457
 458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get()
 459 {
 460   int jresult;
 461   int result;
 462
 463   result  = (int)Dali::Actor::Property::WORLD_MATRIX;
 464   jresult = (int)result;
 465   return jresult;
 466 }
 467
 468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get()
 469 {
 470   int jresult;
 471   int result;
 472
 473   result  = (int)Dali::Actor::Property::NAME;
 474   jresult = (int)result;
 475   return jresult;
 476 }
 477
 478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get()
 479 {
 480   int jresult;
 481   int result;
 482
 483   result  = (int)Dali::Actor::Property::SENSITIVE;
 484   jresult = (int)result;
 485   return jresult;
 486 }
 487
 488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get()
 489 {
 490   int jresult;
 491   int result;
 492
 493   result  = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED;
 494   jresult = (int)result;
 495   return jresult;
 496 }
 497
 498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get()
 499 {
 500   int jresult;
 501   int result;
 502
 503   result  = (int)Dali::Actor::Property::LEAVE_REQUIRED;
 504   jresult = (int)result;
 505   return jresult;
 506 }
 507
 508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get()
 509 {
 510   int jresult;
 511   int result;
 512
 513   result  = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
 514   jresult = (int)result;
 515   return jresult;
 516 }
 517
 518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get()
 519 {
 520   int jresult;
 521   int result;
 522
 523   result  = (int)Dali::Actor::Property::INHERIT_SCALE;
 524   jresult = (int)result;
 525   return jresult;
 526 }
 527
 528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get()
 529 {
 530   int jresult;
 531   int result;
 532
 533   result  = (int)Dali::Actor::Property::COLOR_MODE;
 534   jresult = (int)result;
 535   return jresult;
 536 }
 537
 538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get()
 539 {
 540   int jresult;
 541   int result;
 542
 543   result  = (int)Dali::Actor::Property::DRAW_MODE;
 544   jresult = (int)result;
 545   return jresult;
 546 }
 547
 548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get()
 549 {
 550   int jresult;
 551   int result;
 552
 553   result  = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
 554   jresult = (int)result;
 555   return jresult;
 556 }
 557
 558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get()
 559 {
 560   int jresult;
 561   int result;
 562
 563   result  = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
 564   jresult = (int)result;
 565   return jresult;
 566 }
 567
 568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get()
 569 {
 570   int jresult;
 571   int result;
 572
 573   result  = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
 574   jresult = (int)result;
 575   return jresult;
 576 }
 577
 578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get()
 579 {
 580   int jresult;
 581   int result;
 582
 583   result  = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
 584   jresult = (int)result;
 585   return jresult;
 586 }
 587
 588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get()
 589 {
 590   int jresult;
 591   int result;
 592
 593   result  = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
 594   jresult = (int)result;
 595   return jresult;
 596 }
 597
 598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get()
 599 {
 600   int jresult;
 601   int result;
 602
 603   result  = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
 604   jresult = (int)result;
 605   return jresult;
 606 }
 607
 608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get()
 609 {
 610   int jresult;
 611   int result;
 612
 613   result  = (int)Dali::Actor::Property::PADDING;
 614   jresult = (int)result;
 615   return jresult;
 616 }
 617
 618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get()
 619 {
 620   int jresult;
 621   int result;
 622
 623   result  = (int)Dali::Actor::Property::MINIMUM_SIZE;
 624   jresult = (int)result;
 625   return jresult;
 626 }
 627
 628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get()
 629 {
 630   int jresult;
 631   int result;
 632
 633   result  = (int)Dali::Actor::Property::MAXIMUM_SIZE;
 634   jresult = (int)result;
 635   return jresult;
 636 }
 637
 638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get()
 639 {
 640   int jresult;
 641   int result;
 642
 643   result  = (int)Dali::Actor::Property::INHERIT_POSITION;
 644   jresult = (int)result;
 645   return jresult;
 646 }
 647
 648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get()
 649 {
 650   int jresult;
 651   int result;
 652
 653   result  = (int)Dali::Actor::Property::CLIPPING_MODE;
 654   jresult = (int)result;
 655   return jresult;
 656 }
 657
 658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get()
 659 {
 660   int jresult;
 661   int result;
 662
 663   result  = (int)Dali::Actor::Property::UPDATE_AREA_HINT;
 664   jresult = (int)result;
 665   return jresult;
 666 }
 667
 668 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get()
 669 {
 670   return Dali::Actor::Property::OPACITY;
 671 }
 672
 673 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get()
 674 {
 675   return Dali::Actor::Property::SCREEN_POSITION;
 676 }
 677
 678 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get()
 679 {
 680   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
 681 }
 682
 683 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get()
 684 {
 685   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
 686 }
 687
 688 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get()
 689 {
 690   return Dali::Actor::Property::LAYOUT_DIRECTION;
 691 }
 692
 693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get()
 694 {
 695   return Dali::Actor::Property::CULLED;
 696 }
 697
 698 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SIBLING_ORDER_get()
 699 {
 700   return Dali::DevelActor::Property::SIBLING_ORDER;
 701 }
 702
 703 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_CAPTURE_ALL_TOUCH_AFTER_START_get()
 704 {
 705   return Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START;
 706 }
 707
 708 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_ALLOW_ONLY_OWN_TOUCH_get()
 709 {
 710   return Dali::DevelActor::Property::ALLOW_ONLY_OWN_TOUCH;
 711 }
 712
 713 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_BLEND_EQUATION_get()
 714 {
 715   return Dali::DevelActor::Property::BLEND_EQUATION;
 716 }
 717
 718 // Creation
 719
 720 SWIGEXPORT Dali::Handle* SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor* jarg1)
 721 {
 722   return (Dali::Handle*)jarg1;
 723 }
 724
 725 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor_Property()
 726 {
 727   void*                  jresult;
 728   Dali::Actor::Property* result = 0;
 729
 730   {
 731     try
 732     {
 733       result = (Dali::Actor::Property*)new Dali::Actor::Property();
 734     }
 735     CALL_CATCH_EXCEPTION(0);
 736   }
 737
 738   jresult = (void*)result;
 739   return jresult;
 740 }
 741
 742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void* jarg1)
 743 {
 744   Dali::Actor::Property* arg1 = (Dali::Actor::Property*)0;
 745
 746   arg1 = (Dali::Actor::Property*)jarg1;
 747   {
 748     try
 749     {
 750       delete arg1;
 751     }
 752     CALL_CATCH_EXCEPTION();
 753   }
 754 }
 755
 756 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0()
 757 {
 758   void*        jresult;
 759   Dali::Actor* result = 0;
 760
 761   {
 762     try
 763     {
 764       result = (Dali::Actor*)new Dali::Actor();
 765     }
 766     CALL_CATCH_EXCEPTION(0);
 767   }
 768
 769   jresult = (void*)result;
 770   return jresult;
 771 }
 772
 773 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_New()
 774 {
 775   void*       jresult;
 776   Dali::Actor result;
 777
 778   {
 779     try
 780     {
 781       result = Dali::Actor::New();
 782     }
 783     CALL_CATCH_EXCEPTION(0);
 784   }
 785
 786   jresult = new Dali::Actor((const Dali::Actor&)result);
 787   return jresult;
 788 }
 789
 790 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_DownCast(void* jarg1)
 791 {
 792   void*             jresult;
 793   Dali::BaseHandle  arg1;
 794   Dali::BaseHandle* argp1;
 795   Dali::Actor       result;
 796
 797   argp1 = (Dali::BaseHandle*)jarg1;
 798   if(!argp1)
 799   {
 800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 801     return 0;
 802   }
 803   arg1 = *argp1;
 804   {
 805     try
 806     {
 807       result = Dali::Actor::DownCast(arg1);
 808     }
 809     CALL_CATCH_EXCEPTION(0);
 810   }
 811
 812   jresult = new Dali::Actor((const Dali::Actor&)result);
 813   return jresult;
 814 }
 815
 816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void* jarg1)
 817 {
 818   Dali::Actor* arg1 = (Dali::Actor*)0;
 819
 820   arg1 = (Dali::Actor*)jarg1;
 821   {
 822     try
 823     {
 824       delete arg1;
 825     }
 826     CALL_CATCH_EXCEPTION();
 827   }
 828 }
 829
 830 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void* jarg1)
 831 {
 832   void*        jresult;
 833   Dali::Actor* arg1   = 0;
 834   Dali::Actor* result = 0;
 835
 836   arg1 = (Dali::Actor*)jarg1;
 837   if(!arg1)
 838   {
 839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
 840     return 0;
 841   }
 842   {
 843     try
 844     {
 845       result = (Dali::Actor*)new Dali::Actor((Dali::Actor const&)*arg1);
 846     }
 847     CALL_CATCH_EXCEPTION(0);
 848   }
 849
 850   jresult = (void*)result;
 851   return jresult;
 852 }
 853
 854 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_Assign(void* jarg1, void* jarg2)
 855 {
 856   void*        jresult;
 857   Dali::Actor* arg1   = (Dali::Actor*)0;
 858   Dali::Actor* arg2   = 0;
 859   Dali::Actor* result = 0;
 860
 861   if(!jarg1)
 862   {
 863     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 864     return 0;
 865   }
 866
 867   if(!jarg2)
 868   {
 869     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
 870     return 0;
 871   }
 872
 873   arg1 = (Dali::Actor*)jarg1;
 874   arg2 = (Dali::Actor*)jarg2;
 875   {
 876     try
 877     {
 878       result = (Dali::Actor*)&(arg1)->operator=((Dali::Actor const&)*arg2);
 879     }
 880     CALL_CATCH_EXCEPTION(0);
 881   }
 882
 883   jresult = (void*)result;
 884   return jresult;
 885 }
 886
 887 // Method
 888
 889 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Actor_GetName(void* jarg1)
 890 {
 891   char*        jresult;
 892   Dali::Actor* arg1   = (Dali::Actor*)0;
 893   std::string* result = 0;
 894   std::string  name   = "";
 895
 896   if(!jarg1)
 897   {
 898     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 899     return 0;
 900   }
 901
 902   arg1 = (Dali::Actor*)jarg1;
 903   {
 904     try
 905     {
 906       name    = ((Dali::Actor const*)arg1)->GetProperty<std::string>(Dali::Actor::Property::NAME);
 907       result  = (std::string*)&name;
 908       jresult = SWIG_csharp_string_callback(result->c_str());
 909     }
 910     CALL_CATCH_EXCEPTION(0);
 911   }
 912   return jresult;
 913 }
 914
 915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void* jarg1, char* jarg2)
 916 {
 917   Dali::Actor* arg1 = (Dali::Actor*)0;
 918   std::string* arg2 = 0;
 919
 920   if(!jarg1)
 921   {
 922     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 923     return;
 924   }
 925
 926   arg1 = (Dali::Actor*)jarg1;
 927   if(!jarg2)
 928   {
 929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 930     return;
 931   }
 932   std::string arg2_str(jarg2);
 933   arg2 = &arg2_str;
 934   {
 935     try
 936     {
 937       (arg1)->SetProperty(Dali::Actor::Property::NAME, (std::string const&)*arg2);
 938     }
 939     CALL_CATCH_EXCEPTION();
 940   }
 941
 942   //argout typemap for const std::string&
 943 }
 944
 945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void* jarg1)
 946 {
 947   unsigned int jresult;
 948   Dali::Actor* arg1 = (Dali::Actor*)0;
 949   unsigned int result;
 950
 951   arg1 = (Dali::Actor*)jarg1;
 952
 953   if(!arg1)
 954   {
 955     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
 956     return -1;
 957   }
 958
 959   {
 960     try
 961     {
 962       result = (unsigned int)((Dali::Actor const*)arg1)->GetProperty<int>(Actor::Property::ID);
 963     }
 964     CALL_CATCH_EXCEPTION(0);
 965   }
 966
 967   jresult = result;
 968   return jresult;
 969 }
 970
 971 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void* jarg1)
 972 {
 973   bool         jresult;
 974   Dali::Actor* arg1 = (Dali::Actor*)0;
 975   bool         result;
 976
 977   if(!jarg1)
 978   {
 979     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 980     return 0;
 981   }
 982
 983   arg1 = (Dali::Actor*)jarg1;
 984   {
 985     try
 986     {
 987       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::IS_ROOT);
 988     }
 989     CALL_CATCH_EXCEPTION(0);
 990   }
 991
 992   jresult = result;
 993   return jresult;
 994 }
 995
 996 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void* jarg1)
 997 {
 998   bool         jresult;
 999   Dali::Actor* arg1 = (Dali::Actor*)0;
1000   bool         result;
1001
1002   if(!jarg1)
1003   {
1004     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1005     return 0;
1006   }
1007
1008   arg1 = (Dali::Actor*)jarg1;
1009   {
1010     try
1011     {
1012       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE);
1013     }
1014     CALL_CATCH_EXCEPTION(0);
1015   }
1016
1017   jresult = result;
1018   return jresult;
1019 }
1020
1021 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void* jarg1)
1022 {
1023   bool         jresult;
1024   Dali::Actor* arg1 = (Dali::Actor*)0;
1025   bool         result;
1026
1027   if(!jarg1)
1028   {
1029     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1030     return 0;
1031   }
1032
1033   arg1 = (Dali::Actor*)jarg1;
1034   {
1035     try
1036     {
1037       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::IS_LAYER);
1038     }
1039     CALL_CATCH_EXCEPTION(0);
1040   }
1041
1042   jresult = result;
1043   return jresult;
1044 }
1045
1046 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void* jarg1)
1047 {
1048   void*        jresult;
1049   Dali::Actor* arg1 = (Dali::Actor*)0;
1050   Dali::Layer  result;
1051
1052   if(!jarg1)
1053   {
1054     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1055     return 0;
1056   }
1057
1058   arg1 = (Dali::Actor*)jarg1;
1059   {
1060     try
1061     {
1062       result = (arg1)->GetLayer();
1063     }
1064     CALL_CATCH_EXCEPTION(0);
1065   }
1066
1067   jresult = new Dali::Layer((const Dali::Layer&)result);
1068   return jresult;
1069 }
1070
1071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void* jarg1, void* jarg2)
1072 {
1073   Dali::Actor* arg1 = (Dali::Actor*)0;
1074   Dali::Actor  arg2;
1075
1076   if(!jarg1)
1077   {
1078     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1079     return;
1080   }
1081   if(!jarg2)
1082   {
1083     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
1084     return;
1085   }
1086
1087   arg1 = (Dali::Actor*)jarg1;
1088   arg2 = *((Dali::Actor*)jarg2);
1089   {
1090     try
1091     {
1092       (arg1)->Add(arg2);
1093     }
1094     CALL_CATCH_EXCEPTION();
1095   }
1096 }
1097
1098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void* jarg1, void* jarg2)
1099 {
1100   Dali::Actor* arg1 = (Dali::Actor*)0;
1101   Dali::Actor  arg2;
1102
1103   if(!jarg1)
1104   {
1105     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1106     return;
1107   }
1108   if(!jarg2)
1109   {
1110     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
1111     return;
1112   }
1113
1114   arg1 = (Dali::Actor*)jarg1;
1115   arg2 = *((Dali::Actor*)jarg2);
1116   {
1117     try
1118     {
1119       (arg1)->Remove(arg2);
1120     }
1121     CALL_CATCH_EXCEPTION();
1122   }
1123 }
1124
1125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void* jarg1)
1126 {
1127   Dali::Actor* arg1 = (Dali::Actor*)0;
1128
1129   if(!jarg1)
1130   {
1131     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1132     return;
1133   }
1134
1135   arg1 = (Dali::Actor*)jarg1;
1136   {
1137     try
1138     {
1139       (arg1)->Unparent();
1140     }
1141     CALL_CATCH_EXCEPTION();
1142   }
1143 }
1144
1145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void* jarg1)
1146 {
1147   unsigned int jresult;
1148   Dali::Actor* arg1 = (Dali::Actor*)0;
1149   unsigned int result;
1150
1151   if(!jarg1)
1152   {
1153     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1154     return 0;
1155   }
1156
1157   arg1 = (Dali::Actor*)jarg1;
1158   {
1159     try
1160     {
1161       result = (unsigned int)((Dali::Actor const*)arg1)->GetChildCount();
1162     }
1163     CALL_CATCH_EXCEPTION(0);
1164   }
1165
1166   jresult = result;
1167   return jresult;
1168 }
1169
1170 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void* jarg1, unsigned int jarg2)
1171 {
1172   void*        jresult;
1173   Dali::Actor* arg1 = (Dali::Actor*)0;
1174   unsigned int arg2;
1175   Dali::Actor  result;
1176
1177   if(!jarg1)
1178   {
1179     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1180     return 0;
1181   }
1182
1183   arg1 = (Dali::Actor*)jarg1;
1184   arg2 = (unsigned int)jarg2;
1185   {
1186     try
1187     {
1188       result = ((Dali::Actor const*)arg1)->GetChildAt(arg2);
1189     }
1190     CALL_CATCH_EXCEPTION(0);
1191   }
1192
1193   jresult = new Dali::Actor((const Dali::Actor&)result);
1194   return jresult;
1195 }
1196
1197 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void* jarg1, char* jarg2)
1198 {
1199   void*        jresult;
1200   Dali::Actor* arg1 = (Dali::Actor*)0;
1201   std::string* arg2 = 0;
1202   Dali::Actor  result;
1203
1204   if(!jarg1)
1205   {
1206     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1207     return 0;
1208   }
1209
1210   arg1 = (Dali::Actor*)jarg1;
1211   if(!jarg2)
1212   {
1213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1214     return 0;
1215   }
1216   std::string arg2_str(jarg2);
1217   arg2 = &arg2_str;
1218   {
1219     try
1220     {
1221       result = (arg1)->FindChildByName((std::string const&)*arg2);
1222     }
1223     CALL_CATCH_EXCEPTION(0);
1224   }
1225
1226   jresult = new Dali::Actor((const Dali::Actor&)result);
1227
1228   //argout typemap for const std::string&
1229
1230   return jresult;
1231 }
1232
1233 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void* jarg1, unsigned int jarg2)
1234 {
1235   void*        jresult;
1236   Dali::Actor* arg1 = (Dali::Actor*)0;
1237   unsigned int arg2;
1238   Dali::Actor  result;
1239
1240   if(!jarg1)
1241   {
1242     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1243     return 0;
1244   }
1245
1246   arg1 = (Dali::Actor*)jarg1;
1247   arg2 = (unsigned int)jarg2;
1248   {
1249     try
1250     {
1251       result = (arg1)->FindChildById(arg2);
1252     }
1253     CALL_CATCH_EXCEPTION(0);
1254   }
1255
1256   jresult = new Dali::Actor((const Dali::Actor&)result);
1257   return jresult;
1258 }
1259
1260 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetParent(void* jarg1)
1261 {
1262   void*        jresult;
1263   Dali::Actor* arg1 = (Dali::Actor*)0;
1264   Dali::Actor  result;
1265
1266   if(!jarg1)
1267   {
1268     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1269     return 0;
1270   }
1271
1272   arg1 = (Dali::Actor*)jarg1;
1273   {
1274     try
1275     {
1276       result = ((Dali::Actor const*)arg1)->GetParent();
1277     }
1278     CALL_CATCH_EXCEPTION(0);
1279   }
1280
1281   jresult = new Dali::Actor((const Dali::Actor&)result);
1282   return jresult;
1283 }
1284
1285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void* jarg1, void* jarg2)
1286 {
1287   Dali::Actor*   arg1 = (Dali::Actor*)0;
1288   Dali::Vector3* arg2 = 0;
1289
1290   if(!jarg1)
1291   {
1292     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1293     return;
1294   }
1295
1296   arg1 = (Dali::Actor*)jarg1;
1297   arg2 = (Dali::Vector3*)jarg2;
1298   if(!arg2)
1299   {
1300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1301     return;
1302   }
1303   {
1304     try
1305     {
1306       (arg1)->SetProperty(Actor::Property::PARENT_ORIGIN, (Dali::Vector3 const&)*arg2);
1307     }
1308     CALL_CATCH_EXCEPTION();
1309   }
1310 }
1311
1312 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void* jarg1)
1313 {
1314   void*         jresult;
1315   Dali::Actor*  arg1 = (Dali::Actor*)0;
1316   Dali::Vector3 result;
1317
1318   if(!jarg1)
1319   {
1320     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1321     return 0;
1322   }
1323
1324   arg1 = (Dali::Actor*)jarg1;
1325   {
1326     try
1327     {
1328       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN);
1329     }
1330     CALL_CATCH_EXCEPTION(0);
1331   }
1332
1333   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1334   return jresult;
1335 }
1336
1337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void* jarg1, void* jarg2)
1338 {
1339   Dali::Actor*   arg1 = (Dali::Actor*)0;
1340   Dali::Vector3* arg2 = 0;
1341
1342   if(!jarg1)
1343   {
1344     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1345     return;
1346   }
1347
1348   arg1 = (Dali::Actor*)jarg1;
1349   arg2 = (Dali::Vector3*)jarg2;
1350   if(!arg2)
1351   {
1352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1353     return;
1354   }
1355   {
1356     try
1357     {
1358       (arg1)->SetProperty(Actor::Property::ANCHOR_POINT, (Dali::Vector3 const&)*arg2);
1359     }
1360     CALL_CATCH_EXCEPTION();
1361   }
1362 }
1363
1364 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void* jarg1)
1365 {
1366   void*         jresult;
1367   Dali::Actor*  arg1 = (Dali::Actor*)0;
1368   Dali::Vector3 result;
1369
1370   if(!jarg1)
1371   {
1372     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1373     return 0;
1374   }
1375
1376   arg1 = (Dali::Actor*)jarg1;
1377   {
1378     try
1379     {
1380       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT);
1381     }
1382     CALL_CATCH_EXCEPTION(0);
1383   }
1384
1385   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1386   return jresult;
1387 }
1388
1389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void* jarg1, float jarg2, float jarg3)
1390 {
1391   Dali::Actor* arg1 = (Dali::Actor*)0;
1392   float        arg2;
1393   float        arg3;
1394
1395   if(!jarg1)
1396   {
1397     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1398     return;
1399   }
1400
1401   arg1 = (Dali::Actor*)jarg1;
1402   arg2 = (float)jarg2;
1403   arg3 = (float)jarg3;
1404   {
1405     try
1406     {
1407       (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector2(arg2, arg3));
1408     }
1409     CALL_CATCH_EXCEPTION();
1410   }
1411 }
1412
1413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
1414 {
1415   Dali::Actor* arg1 = (Dali::Actor*)0;
1416   float        arg2;
1417   float        arg3;
1418   float        arg4;
1419
1420   if(!jarg1)
1421   {
1422     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1423     return;
1424   }
1425
1426   arg1 = (Dali::Actor*)jarg1;
1427   arg2 = (float)jarg2;
1428   arg3 = (float)jarg3;
1429   arg4 = (float)jarg4;
1430   {
1431     try
1432     {
1433       (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector3(arg2, arg3, arg4));
1434     }
1435     CALL_CATCH_EXCEPTION();
1436   }
1437 }
1438
1439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void* jarg1, void* jarg2)
1440 {
1441   Dali::Actor*   arg1 = (Dali::Actor*)0;
1442   Dali::Vector2* arg2 = 0;
1443
1444   if(!jarg1)
1445   {
1446     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1447     return;
1448   }
1449
1450   arg1 = (Dali::Actor*)jarg1;
1451   arg2 = (Dali::Vector2*)jarg2;
1452   if(!arg2)
1453   {
1454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
1455     return;
1456   }
1457   {
1458     try
1459     {
1460       (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector2 const&)*arg2);
1461     }
1462     CALL_CATCH_EXCEPTION();
1463   }
1464 }
1465
1466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void* jarg1, void* jarg2)
1467 {
1468   Dali::Actor*   arg1 = (Dali::Actor*)0;
1469   Dali::Vector3* arg2 = 0;
1470
1471   if(!jarg1)
1472   {
1473     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1474     return;
1475   }
1476
1477   arg1 = (Dali::Actor*)jarg1;
1478   arg2 = (Dali::Vector3*)jarg2;
1479   if(!arg2)
1480   {
1481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1482     return;
1483   }
1484   {
1485     try
1486     {
1487       (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector3 const&)*arg2);
1488     }
1489     CALL_CATCH_EXCEPTION();
1490   }
1491 }
1492
1493 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void* jarg1)
1494 {
1495   void*         jresult;
1496   Dali::Actor*  arg1 = (Dali::Actor*)0;
1497   Dali::Vector3 result;
1498
1499   if(!jarg1)
1500   {
1501     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1502     return 0;
1503   }
1504
1505   arg1 = (Dali::Actor*)jarg1;
1506   {
1507     try
1508     {
1509       result = ((Dali::Actor const*)arg1)->GetTargetSize();
1510     }
1511     CALL_CATCH_EXCEPTION(0);
1512   }
1513
1514   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1515   return jresult;
1516 }
1517
1518 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void* jarg1)
1519 {
1520   void*         jresult;
1521   Dali::Actor*  arg1 = (Dali::Actor*)0;
1522   Dali::Vector3 result;
1523
1524   if(!jarg1)
1525   {
1526     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1527     return 0;
1528   }
1529
1530   arg1 = (Dali::Actor*)jarg1;
1531   {
1532     try
1533     {
1534       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::SIZE);
1535     }
1536     CALL_CATCH_EXCEPTION(0);
1537   }
1538
1539   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1540   return jresult;
1541 }
1542
1543 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void* jarg1)
1544 {
1545   void*         jresult;
1546   Dali::Actor*  arg1 = (Dali::Actor*)0;
1547   Dali::Vector3 result;
1548
1549   if(!jarg1)
1550   {
1551     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1552     return 0;
1553   }
1554
1555   arg1 = (Dali::Actor*)jarg1;
1556   {
1557     try
1558     {
1559       result = ((Dali::Actor const*)arg1)->GetNaturalSize();
1560     }
1561     CALL_CATCH_EXCEPTION(0);
1562   }
1563
1564   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1565   return jresult;
1566 }
1567
1568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void* jarg1, float jarg2, float jarg3)
1569 {
1570   Dali::Actor* arg1 = (Dali::Actor*)0;
1571   float        arg2;
1572   float        arg3;
1573
1574   if(!jarg1)
1575   {
1576     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1577     return;
1578   }
1579
1580   arg1 = (Dali::Actor*)jarg1;
1581   arg2 = (float)jarg2;
1582   arg3 = (float)jarg3;
1583   {
1584     try
1585     {
1586       (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector2(arg2, arg3));
1587     }
1588     CALL_CATCH_EXCEPTION();
1589   }
1590 }
1591
1592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
1593 {
1594   Dali::Actor* arg1 = (Dali::Actor*)0;
1595   float        arg2;
1596   float        arg3;
1597   float        arg4;
1598
1599   if(!jarg1)
1600   {
1601     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1602     return;
1603   }
1604
1605   arg1 = (Dali::Actor*)jarg1;
1606   arg2 = (float)jarg2;
1607   arg3 = (float)jarg3;
1608   arg4 = (float)jarg4;
1609   {
1610     try
1611     {
1612       (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector3(arg2, arg3, arg4));
1613     }
1614     CALL_CATCH_EXCEPTION();
1615   }
1616 }
1617
1618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void* jarg1, void* jarg2)
1619 {
1620   Dali::Actor*   arg1 = (Dali::Actor*)0;
1621   Dali::Vector3* arg2 = 0;
1622
1623   if(!jarg1)
1624   {
1625     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1626     return;
1627   }
1628
1629   arg1 = (Dali::Actor*)jarg1;
1630   arg2 = (Dali::Vector3*)jarg2;
1631   if(!arg2)
1632   {
1633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1634     return;
1635   }
1636   {
1637     try
1638     {
1639       (arg1)->SetProperty(Actor::Property::POSITION, (Dali::Vector3 const&)*arg2);
1640     }
1641     CALL_CATCH_EXCEPTION();
1642   }
1643 }
1644
1645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void* jarg1, float jarg2)
1646 {
1647   Dali::Actor* arg1 = (Dali::Actor*)0;
1648   float        arg2;
1649
1650   if(!jarg1)
1651   {
1652     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1653     return;
1654   }
1655
1656   arg1 = (Dali::Actor*)jarg1;
1657   arg2 = (float)jarg2;
1658   {
1659     try
1660     {
1661       (arg1)->SetProperty(Actor::Property::POSITION_X, (arg2));
1662     }
1663     CALL_CATCH_EXCEPTION();
1664   }
1665 }
1666
1667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void* jarg1, float jarg2)
1668 {
1669   Dali::Actor* arg1 = (Dali::Actor*)0;
1670   float        arg2;
1671
1672   if(!jarg1)
1673   {
1674     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1675     return;
1676   }
1677
1678   arg1 = (Dali::Actor*)jarg1;
1679   arg2 = (float)jarg2;
1680   {
1681     try
1682     {
1683       (arg1)->SetProperty(Actor::Property::POSITION_Y, arg2);
1684     }
1685     CALL_CATCH_EXCEPTION();
1686   }
1687 }
1688
1689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void* jarg1, float jarg2)
1690 {
1691   Dali::Actor* arg1 = (Dali::Actor*)0;
1692   float        arg2;
1693
1694   if(!jarg1)
1695   {
1696     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1697     return;
1698   }
1699
1700   arg1 = (Dali::Actor*)jarg1;
1701   arg2 = (float)jarg2;
1702   {
1703     try
1704     {
1705       (arg1)->SetProperty(Actor::Property::POSITION_Z, arg2);
1706     }
1707     CALL_CATCH_EXCEPTION();
1708   }
1709 }
1710
1711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void* jarg1, void* jarg2)
1712 {
1713   Dali::Actor*   arg1 = (Dali::Actor*)0;
1714   Dali::Vector3* arg2 = 0;
1715
1716   if(!jarg1)
1717   {
1718     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1719     return;
1720   }
1721
1722   arg1 = (Dali::Actor*)jarg1;
1723   arg2 = (Dali::Vector3*)jarg2;
1724   if(!arg2)
1725   {
1726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1727     return;
1728   }
1729   {
1730     try
1731     {
1732       (arg1)->TranslateBy((Dali::Vector3 const&)*arg2);
1733     }
1734     CALL_CATCH_EXCEPTION();
1735   }
1736 }
1737
1738 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void* jarg1)
1739 {
1740   void*         jresult;
1741   Dali::Actor*  arg1 = (Dali::Actor*)0;
1742   Dali::Vector3 result;
1743
1744   if(!jarg1)
1745   {
1746     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1747     return 0;
1748   }
1749
1750   arg1 = (Dali::Actor*)jarg1;
1751   {
1752     try
1753     {
1754       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::POSITION);
1755     }
1756     CALL_CATCH_EXCEPTION(0);
1757   }
1758
1759   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1760   return jresult;
1761 }
1762
1763 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void* jarg1)
1764 {
1765   void*         jresult;
1766   Dali::Actor*  arg1 = (Dali::Actor*)0;
1767   Dali::Vector3 result;
1768
1769   if(!jarg1)
1770   {
1771     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1772     return 0;
1773   }
1774
1775   arg1 = (Dali::Actor*)jarg1;
1776   {
1777     try
1778     {
1779       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION);
1780     }
1781     CALL_CATCH_EXCEPTION(0);
1782   }
1783
1784   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1785   return jresult;
1786 }
1787
1788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void* jarg1, bool jarg2)
1789 {
1790   Dali::Actor* arg1 = (Dali::Actor*)0;
1791   bool         arg2;
1792
1793   if(!jarg1)
1794   {
1795     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1796     return;
1797   }
1798
1799   arg1 = (Dali::Actor*)jarg1;
1800   arg2 = jarg2 ? true : false;
1801   {
1802     try
1803     {
1804       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
1805     }
1806     CALL_CATCH_EXCEPTION();
1807   }
1808 }
1809
1810 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void* jarg1)
1811 {
1812   bool         jresult;
1813   Dali::Actor* arg1 = (Dali::Actor*)0;
1814   bool         result;
1815
1816   if(!jarg1)
1817   {
1818     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1819     return 0;
1820   }
1821
1822   arg1 = (Dali::Actor*)jarg1;
1823   {
1824     try
1825     {
1826       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
1827     }
1828     CALL_CATCH_EXCEPTION(0);
1829   }
1830
1831   jresult = result;
1832   return jresult;
1833 }
1834
1835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void* jarg1, void* jarg2, void* jarg3)
1836 {
1837   Dali::Actor*   arg1 = (Dali::Actor*)0;
1838   Dali::Degree*  arg2 = 0;
1839   Dali::Vector3* arg3 = 0;
1840
1841   if(!jarg1)
1842   {
1843     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1844     return;
1845   }
1846
1847   arg1 = (Dali::Actor*)jarg1;
1848   arg2 = (Dali::Degree*)jarg2;
1849   if(!arg2)
1850   {
1851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
1852     return;
1853   }
1854   arg3 = (Dali::Vector3*)jarg3;
1855   if(!arg3)
1856   {
1857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1858     return;
1859   }
1860   {
1861     try
1862     {
1863       (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3));
1864     }
1865     CALL_CATCH_EXCEPTION();
1866   }
1867 }
1868
1869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void* jarg1, void* jarg2, void* jarg3)
1870 {
1871   Dali::Actor*   arg1 = (Dali::Actor*)0;
1872   Dali::Radian*  arg2 = 0;
1873   Dali::Vector3* arg3 = 0;
1874
1875   if(!jarg1)
1876   {
1877     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1878     return;
1879   }
1880
1881   arg1 = (Dali::Actor*)jarg1;
1882   arg2 = (Dali::Radian*)jarg2;
1883   if(!arg2)
1884   {
1885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
1886     return;
1887   }
1888   arg3 = (Dali::Vector3*)jarg3;
1889   if(!arg3)
1890   {
1891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1892     return;
1893   }
1894   {
1895     try
1896     {
1897       (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3));
1898     }
1899     CALL_CATCH_EXCEPTION();
1900   }
1901 }
1902
1903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void* jarg1, void* jarg2)
1904 {
1905   Dali::Actor*      arg1 = (Dali::Actor*)0;
1906   Dali::Quaternion* arg2 = 0;
1907
1908   if(!jarg1)
1909   {
1910     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1911     return;
1912   }
1913
1914   arg1 = (Dali::Actor*)jarg1;
1915   arg2 = (Dali::Quaternion*)jarg2;
1916   if(!arg2)
1917   {
1918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
1919     return;
1920   }
1921   {
1922     try
1923     {
1924       (arg1)->SetProperty(Actor::Property::ORIENTATION, (Dali::Quaternion const&)*arg2);
1925     }
1926     CALL_CATCH_EXCEPTION();
1927   }
1928 }
1929
1930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void* jarg1, void* jarg2, void* jarg3)
1931 {
1932   Dali::Actor*   arg1 = (Dali::Actor*)0;
1933   Dali::Degree*  arg2 = 0;
1934   Dali::Vector3* arg3 = 0;
1935
1936   if(!jarg1)
1937   {
1938     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1939     return;
1940   }
1941
1942   arg1 = (Dali::Actor*)jarg1;
1943   arg2 = (Dali::Degree*)jarg2;
1944   if(!arg2)
1945   {
1946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
1947     return;
1948   }
1949   arg3 = (Dali::Vector3*)jarg3;
1950   if(!arg3)
1951   {
1952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1953     return;
1954   }
1955   {
1956     try
1957     {
1958       (arg1)->RotateBy((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3);
1959     }
1960     CALL_CATCH_EXCEPTION();
1961   }
1962 }
1963
1964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void* jarg1, void* jarg2, void* jarg3)
1965 {
1966   Dali::Actor*   arg1 = (Dali::Actor*)0;
1967   Dali::Radian*  arg2 = 0;
1968   Dali::Vector3* arg3 = 0;
1969
1970   if(!jarg1)
1971   {
1972     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1973     return;
1974   }
1975
1976   arg1 = (Dali::Actor*)jarg1;
1977   arg2 = (Dali::Radian*)jarg2;
1978   if(!arg2)
1979   {
1980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
1981     return;
1982   }
1983   arg3 = (Dali::Vector3*)jarg3;
1984   if(!arg3)
1985   {
1986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1987     return;
1988   }
1989   {
1990     try
1991     {
1992       (arg1)->RotateBy((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3);
1993     }
1994     CALL_CATCH_EXCEPTION();
1995   }
1996 }
1997
1998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void* jarg1, void* jarg2)
1999 {
2000   Dali::Actor*      arg1 = (Dali::Actor*)0;
2001   Dali::Quaternion* arg2 = 0;
2002
2003   if(!jarg1)
2004   {
2005     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2006     return;
2007   }
2008
2009   arg1 = (Dali::Actor*)jarg1;
2010   arg2 = (Dali::Quaternion*)jarg2;
2011   if(!arg2)
2012   {
2013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
2014     return;
2015   }
2016   {
2017     try
2018     {
2019       (arg1)->RotateBy((Dali::Quaternion const&)*arg2);
2020     }
2021     CALL_CATCH_EXCEPTION();
2022   }
2023 }
2024
2025 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void* jarg1)
2026 {
2027   void*            jresult;
2028   Dali::Actor*     arg1 = (Dali::Actor*)0;
2029   Dali::Quaternion result;
2030
2031   if(!jarg1)
2032   {
2033     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2034     return 0;
2035   }
2036
2037   arg1 = (Dali::Actor*)jarg1;
2038   {
2039     try
2040     {
2041       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION);
2042     }
2043     CALL_CATCH_EXCEPTION(0);
2044   }
2045
2046   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
2047   return jresult;
2048 }
2049
2050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void* jarg1, bool jarg2)
2051 {
2052   Dali::Actor* arg1 = (Dali::Actor*)0;
2053   bool         arg2;
2054
2055   if(!jarg1)
2056   {
2057     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2058     return;
2059   }
2060
2061   arg1 = (Dali::Actor*)jarg1;
2062   arg2 = jarg2 ? true : false;
2063   {
2064     try
2065     {
2066       (arg1)->SetProperty(Actor::Property::INHERIT_ORIENTATION, arg2);
2067     }
2068     CALL_CATCH_EXCEPTION();
2069   }
2070 }
2071
2072 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void* jarg1)
2073 {
2074   bool         jresult;
2075   Dali::Actor* arg1 = (Dali::Actor*)0;
2076   bool         result;
2077
2078   if(!jarg1)
2079   {
2080     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2081     return 0;
2082   }
2083
2084   arg1 = (Dali::Actor*)jarg1;
2085   {
2086     try
2087     {
2088       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::INHERIT_ORIENTATION);
2089     }
2090     CALL_CATCH_EXCEPTION(0);
2091   }
2092
2093   jresult = result;
2094   return jresult;
2095 }
2096
2097 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void* jarg1)
2098 {
2099   void*            jresult;
2100   Dali::Actor*     arg1 = (Dali::Actor*)0;
2101   Dali::Quaternion result;
2102
2103   if(!jarg1)
2104   {
2105     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2106     return 0;
2107   }
2108
2109   arg1 = (Dali::Actor*)jarg1;
2110   {
2111     try
2112     {
2113       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION);
2114     }
2115     CALL_CATCH_EXCEPTION(0);
2116   }
2117
2118   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
2119   return jresult;
2120 }
2121
2122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void* jarg1, float jarg2)
2123 {
2124   Dali::Actor* arg1 = (Dali::Actor*)0;
2125   float        arg2;
2126
2127   if(!jarg1)
2128   {
2129     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2130     return;
2131   }
2132
2133   arg1 = (Dali::Actor*)jarg1;
2134   arg2 = (float)jarg2;
2135   {
2136     try
2137     {
2138       (arg1)->SetProperty(Actor::Property::SCALE, arg2);
2139     }
2140     CALL_CATCH_EXCEPTION();
2141   }
2142 }
2143
2144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
2145 {
2146   Dali::Actor* arg1 = (Dali::Actor*)0;
2147   float        arg2;
2148   float        arg3;
2149   float        arg4;
2150
2151   if(!jarg1)
2152   {
2153     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2154     return;
2155   }
2156
2157   arg1 = (Dali::Actor*)jarg1;
2158   arg2 = (float)jarg2;
2159   arg3 = (float)jarg3;
2160   arg4 = (float)jarg4;
2161   {
2162     try
2163     {
2164       (arg1)->SetProperty(Actor::Property::SCALE, Vector3(arg2, arg3, arg4));
2165     }
2166     CALL_CATCH_EXCEPTION();
2167   }
2168 }
2169
2170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void* jarg1, void* jarg2)
2171 {
2172   Dali::Actor*   arg1 = (Dali::Actor*)0;
2173   Dali::Vector3* arg2 = 0;
2174
2175   if(!jarg1)
2176   {
2177     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2178     return;
2179   }
2180
2181   arg1 = (Dali::Actor*)jarg1;
2182   arg2 = (Dali::Vector3*)jarg2;
2183   if(!arg2)
2184   {
2185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
2186     return;
2187   }
2188   {
2189     try
2190     {
2191       (arg1)->SetProperty(Actor::Property::SCALE, (Dali::Vector3 const&)*arg2);
2192     }
2193     CALL_CATCH_EXCEPTION();
2194   }
2195 }
2196
2197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void* jarg1, void* jarg2)
2198 {
2199   Dali::Actor*   arg1 = (Dali::Actor*)0;
2200   Dali::Vector3* arg2 = 0;
2201
2202   if(!jarg1)
2203   {
2204     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2205     return;
2206   }
2207
2208   arg1 = (Dali::Actor*)jarg1;
2209   arg2 = (Dali::Vector3*)jarg2;
2210   if(!arg2)
2211   {
2212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
2213     return;
2214   }
2215   {
2216     try
2217     {
2218       (arg1)->ScaleBy((Dali::Vector3 const&)*arg2);
2219     }
2220     CALL_CATCH_EXCEPTION();
2221   }
2222 }
2223
2224 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void* jarg1)
2225 {
2226   void*         jresult;
2227   Dali::Actor*  arg1 = (Dali::Actor*)0;
2228   Dali::Vector3 result;
2229
2230   if(!jarg1)
2231   {
2232     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2233     return 0;
2234   }
2235
2236   arg1 = (Dali::Actor*)jarg1;
2237   {
2238     try
2239     {
2240       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::SCALE);
2241     }
2242     CALL_CATCH_EXCEPTION(0);
2243   }
2244
2245   jresult = new Dali::Vector3((const Dali::Vector3&)result);
2246   return jresult;
2247 }
2248
2249 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void* jarg1)
2250 {
2251   void*         jresult;
2252   Dali::Actor*  arg1 = (Dali::Actor*)0;
2253   Dali::Vector3 result;
2254
2255   if(!jarg1)
2256   {
2257     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2258     return 0;
2259   }
2260
2261   arg1 = (Dali::Actor*)jarg1;
2262   {
2263     try
2264     {
2265       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE);
2266     }
2267     CALL_CATCH_EXCEPTION(0);
2268   }
2269
2270   jresult = new Dali::Vector3((const Dali::Vector3&)result);
2271   return jresult;
2272 }
2273
2274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void* jarg1, bool jarg2)
2275 {
2276   Dali::Actor* arg1 = (Dali::Actor*)0;
2277   bool         arg2;
2278
2279   if(!jarg1)
2280   {
2281     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2282     return;
2283   }
2284
2285   arg1 = (Dali::Actor*)jarg1;
2286   arg2 = jarg2 ? true : false;
2287   {
2288     try
2289     {
2290       (arg1)->SetProperty(Actor::Property::INHERIT_SCALE, arg2);
2291     }
2292     CALL_CATCH_EXCEPTION();
2293   }
2294 }
2295
2296 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void* jarg1)
2297 {
2298   bool         jresult;
2299   Dali::Actor* arg1 = (Dali::Actor*)0;
2300   bool         result;
2301
2302   if(!jarg1)
2303   {
2304     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2305     return 0;
2306   }
2307
2308   arg1 = (Dali::Actor*)jarg1;
2309   {
2310     try
2311     {
2312       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::INHERIT_SCALE);
2313     }
2314     CALL_CATCH_EXCEPTION(0);
2315   }
2316
2317   jresult = result;
2318   return jresult;
2319 }
2320
2321 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void* jarg1)
2322 {
2323   void*        jresult;
2324   Dali::Actor* arg1 = (Dali::Actor*)0;
2325   Dali::Matrix result;
2326
2327   if(!jarg1)
2328   {
2329     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2330     return 0;
2331   }
2332
2333   arg1 = (Dali::Actor*)jarg1;
2334   {
2335     try
2336     {
2337       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
2338     }
2339     CALL_CATCH_EXCEPTION(0);
2340   }
2341
2342   jresult = new Dali::Matrix((const Dali::Matrix&)result);
2343   return jresult;
2344 }
2345
2346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void* jarg1)
2347 {
2348   Dali::Actor  arg1;
2349   Dali::Actor* argp1;
2350
2351   argp1 = (Dali::Actor*)jarg1;
2352   if(!argp1)
2353   {
2354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2355     return;
2356   }
2357   arg1 = *argp1;
2358   {
2359     try
2360     {
2361       arg1.Raise();
2362     }
2363     CALL_CATCH_EXCEPTION();
2364   }
2365 }
2366
2367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void* jarg1)
2368 {
2369   Dali::Actor  arg1;
2370   Dali::Actor* argp1;
2371
2372   argp1 = (Dali::Actor*)jarg1;
2373   if(!argp1)
2374   {
2375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2376     return;
2377   }
2378   arg1 = *argp1;
2379   {
2380     try
2381     {
2382       arg1.Lower();
2383     }
2384     CALL_CATCH_EXCEPTION();
2385   }
2386 }
2387
2388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void* jarg1)
2389 {
2390   Dali::Actor  arg1;
2391   Dali::Actor* argp1;
2392
2393   argp1 = (Dali::Actor*)jarg1;
2394   if(!argp1)
2395   {
2396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2397     return;
2398   }
2399   arg1 = *argp1;
2400   {
2401     try
2402     {
2403       arg1.RaiseToTop();
2404     }
2405     CALL_CATCH_EXCEPTION();
2406   }
2407 }
2408
2409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void* jarg1)
2410 {
2411   Dali::Actor  arg1;
2412   Dali::Actor* argp1;
2413
2414   argp1 = (Dali::Actor*)jarg1;
2415   if(!argp1)
2416   {
2417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2418     return;
2419   }
2420   arg1 = *argp1;
2421   {
2422     try
2423     {
2424       arg1.LowerToBottom();
2425     }
2426     CALL_CATCH_EXCEPTION();
2427   }
2428 }
2429
2430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void* jarg1, void* jarg2)
2431 {
2432   Dali::Actor  arg1;
2433   Dali::Actor  arg2;
2434   Dali::Actor* argp1;
2435   Dali::Actor* argp2;
2436
2437   argp1 = (Dali::Actor*)jarg1;
2438   if(!argp1)
2439   {
2440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2441     return;
2442   }
2443   arg1  = *argp1;
2444   argp2 = (Dali::Actor*)jarg2;
2445   if(!argp2)
2446   {
2447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2448     return;
2449   }
2450   arg2 = *argp2;
2451   {
2452     try
2453     {
2454       arg1.RaiseAbove(arg2);
2455     }
2456     CALL_CATCH_EXCEPTION();
2457   }
2458 }
2459
2460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void* jarg1, void* jarg2)
2461 {
2462   Dali::Actor  arg1;
2463   Dali::Actor  arg2;
2464   Dali::Actor* argp1;
2465   Dali::Actor* argp2;
2466
2467   argp1 = (Dali::Actor*)jarg1;
2468   if(!argp1)
2469   {
2470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2471     return;
2472   }
2473   arg1  = *argp1;
2474   argp2 = (Dali::Actor*)jarg2;
2475   if(!argp2)
2476   {
2477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2478     return;
2479   }
2480   arg2 = *argp2;
2481   {
2482     try
2483     {
2484       arg1.LowerBelow(arg2);
2485     }
2486     CALL_CATCH_EXCEPTION();
2487   }
2488 }
2489
2490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void* jarg1, bool jarg2)
2491 {
2492   Dali::Actor* arg1 = (Dali::Actor*)0;
2493   bool         arg2;
2494
2495   if(!jarg1)
2496   {
2497     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2498     return;
2499   }
2500
2501   arg1 = (Dali::Actor*)jarg1;
2502   arg2 = jarg2 ? true : false;
2503   {
2504     try
2505     {
2506       (arg1)->SetProperty(Actor::Property::VISIBLE, arg2);
2507     }
2508     CALL_CATCH_EXCEPTION();
2509   }
2510 }
2511
2512 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void* jarg1)
2513 {
2514   bool         jresult;
2515   Dali::Actor* arg1 = (Dali::Actor*)0;
2516   bool         result;
2517
2518   if(!jarg1)
2519   {
2520     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2521     return 0;
2522   }
2523
2524   arg1 = (Dali::Actor*)jarg1;
2525   {
2526     try
2527     {
2528       result = (bool)((Dali::Actor const*)arg1)->GetCurrentProperty<bool>(Actor::Property::VISIBLE);
2529     }
2530     CALL_CATCH_EXCEPTION(0);
2531   }
2532
2533   jresult = result;
2534   return jresult;
2535 }
2536
2537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void* jarg1, float jarg2)
2538 {
2539   Dali::Actor* arg1 = (Dali::Actor*)0;
2540   float        arg2;
2541
2542   if(!jarg1)
2543   {
2544     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2545     return;
2546   }
2547
2548   arg1 = (Dali::Actor*)jarg1;
2549   arg2 = (float)jarg2;
2550   {
2551     try
2552     {
2553       (arg1)->SetProperty(Actor::Property::OPACITY, arg2);
2554     }
2555     CALL_CATCH_EXCEPTION();
2556   }
2557 }
2558
2559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void* jarg1)
2560 {
2561   float        jresult;
2562   Dali::Actor* arg1 = (Dali::Actor*)0;
2563   float        result;
2564
2565   if(!jarg1)
2566   {
2567     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2568     return 0;
2569   }
2570
2571   arg1 = (Dali::Actor*)jarg1;
2572   {
2573     try
2574     {
2575       result = (float)((Dali::Actor const*)arg1)->GetCurrentProperty<float>(Actor::Property::OPACITY);
2576     }
2577     CALL_CATCH_EXCEPTION(0);
2578   }
2579
2580   jresult = result;
2581   return jresult;
2582 }
2583
2584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void* jarg1, void* jarg2)
2585 {
2586   Dali::Actor*   arg1 = (Dali::Actor*)0;
2587   Dali::Vector4* arg2 = 0;
2588
2589   if(!jarg1)
2590   {
2591     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2592     return;
2593   }
2594
2595   arg1 = (Dali::Actor*)jarg1;
2596   arg2 = (Dali::Vector4*)jarg2;
2597   if(!arg2)
2598   {
2599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
2600     return;
2601   }
2602   {
2603     try
2604     {
2605       (arg1)->SetProperty(Actor::Property::COLOR, (Dali::Vector4 const&)*arg2);
2606     }
2607     CALL_CATCH_EXCEPTION();
2608   }
2609 }
2610
2611 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void* jarg1)
2612 {
2613   void*         jresult;
2614   Dali::Actor*  arg1 = (Dali::Actor*)0;
2615   Dali::Vector4 result;
2616
2617   if(!jarg1)
2618   {
2619     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2620     return 0;
2621   }
2622
2623   arg1 = (Dali::Actor*)jarg1;
2624   {
2625     try
2626     {
2627       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector4>(Actor::Property::COLOR);
2628     }
2629     CALL_CATCH_EXCEPTION(0);
2630   }
2631
2632   jresult = new Dali::Vector4((const Dali::Vector4&)result);
2633   return jresult;
2634 }
2635
2636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void* jarg1, int jarg2)
2637 {
2638   Dali::Actor*    arg1 = (Dali::Actor*)0;
2639   Dali::ColorMode arg2;
2640
2641   if(!jarg1)
2642   {
2643     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2644     return;
2645   }
2646
2647   arg1 = (Dali::Actor*)jarg1;
2648   arg2 = (Dali::ColorMode)jarg2;
2649   {
2650     try
2651     {
2652       (arg1)->SetProperty(Actor::Property::COLOR_MODE, arg2);
2653     }
2654     CALL_CATCH_EXCEPTION();
2655   }
2656 }
2657
2658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void* jarg1)
2659 {
2660   int             jresult;
2661   Dali::Actor*    arg1 = (Dali::Actor*)0;
2662   Dali::ColorMode result;
2663
2664   if(!jarg1)
2665   {
2666     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2667     return 0;
2668   }
2669
2670   arg1 = (Dali::Actor*)jarg1;
2671   {
2672     try
2673     {
2674       result = (Dali::ColorMode)((Dali::Actor const*)arg1)->GetProperty<ColorMode>(Actor::Property::COLOR_MODE);
2675     }
2676     CALL_CATCH_EXCEPTION(0);
2677   }
2678
2679   jresult = (int)result;
2680   return jresult;
2681 }
2682
2683 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void* jarg1)
2684 {
2685   void*         jresult;
2686   Dali::Actor*  arg1 = (Dali::Actor*)0;
2687   Dali::Vector4 result;
2688
2689   if(!jarg1)
2690   {
2691     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2692     return 0;
2693   }
2694
2695   arg1 = (Dali::Actor*)jarg1;
2696   {
2697     try
2698     {
2699       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR);
2700     }
2701     CALL_CATCH_EXCEPTION(0);
2702   }
2703
2704   jresult = new Dali::Vector4((const Dali::Vector4&)result);
2705   return jresult;
2706 }
2707
2708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void* jarg1, int jarg2)
2709 {
2710   Dali::Actor*         arg1 = (Dali::Actor*)0;
2711   Dali::DrawMode::Type arg2;
2712
2713   if(!jarg1)
2714   {
2715     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2716     return;
2717   }
2718
2719   arg1 = (Dali::Actor*)jarg1;
2720   arg2 = (Dali::DrawMode::Type)jarg2;
2721   {
2722     try
2723     {
2724       (arg1)->SetProperty(Actor::Property::DRAW_MODE, arg2);
2725     }
2726     CALL_CATCH_EXCEPTION();
2727   }
2728 }
2729
2730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void* jarg1)
2731 {
2732   int                  jresult;
2733   Dali::Actor*         arg1 = (Dali::Actor*)0;
2734   Dali::DrawMode::Type result;
2735
2736   if(!jarg1)
2737   {
2738     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2739     return 0;
2740   }
2741
2742   arg1 = (Dali::Actor*)jarg1;
2743   {
2744     try
2745     {
2746       result = (Dali::DrawMode::Type)((Dali::Actor const*)arg1)->GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE);
2747     }
2748     CALL_CATCH_EXCEPTION(0);
2749   }
2750
2751   jresult = (int)result;
2752   return jresult;
2753 }
2754
2755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void* jarg1, bool jarg2)
2756 {
2757   Dali::Actor* arg1 = (Dali::Actor*)0;
2758   bool         arg2;
2759
2760   if(!jarg1)
2761   {
2762     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2763     return;
2764   }
2765
2766   arg1 = (Dali::Actor*)jarg1;
2767   arg2 = jarg2 ? true : false;
2768   {
2769     try
2770     {
2771       (arg1)->SetProperty(Actor::Property::SENSITIVE, arg2);
2772     }
2773     CALL_CATCH_EXCEPTION();
2774   }
2775 }
2776
2777 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void* jarg1)
2778 {
2779   bool         jresult;
2780   Dali::Actor* arg1 = (Dali::Actor*)0;
2781   bool         result;
2782
2783   if(!jarg1)
2784   {
2785     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2786     return 0;
2787   }
2788
2789   arg1 = (Dali::Actor*)jarg1;
2790   {
2791     try
2792     {
2793       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::SENSITIVE);
2794     }
2795     CALL_CATCH_EXCEPTION(0);
2796   }
2797
2798   jresult = result;
2799   return jresult;
2800 }
2801
2802 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void* jarg1, float* jarg2, float* jarg3, float jarg4, float jarg5)
2803 {
2804   bool         jresult;
2805   Dali::Actor* arg1 = (Dali::Actor*)0;
2806   float*       arg2 = 0;
2807   float*       arg3 = 0;
2808   float        arg4;
2809   float        arg5;
2810   bool         result;
2811
2812   if(!jarg1)
2813   {
2814     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2815     return 0;
2816   }
2817
2818   arg1 = (Dali::Actor*)jarg1;
2819   arg2 = (float*)jarg2;
2820   arg3 = (float*)jarg3;
2821   arg4 = (float)jarg4;
2822   arg5 = (float)jarg5;
2823   {
2824     try
2825     {
2826       result = (bool)((Dali::Actor const*)arg1)->ScreenToLocal(*arg2, *arg3, arg4, arg5);
2827     }
2828     CALL_CATCH_EXCEPTION(0);
2829   }
2830
2831   jresult = result;
2832   return jresult;
2833 }
2834
2835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void* jarg1, bool jarg2)
2836 {
2837   Dali::Actor* arg1 = (Dali::Actor*)0;
2838   bool         arg2;
2839
2840   if(!jarg1)
2841   {
2842     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2843     return;
2844   }
2845
2846   arg1 = (Dali::Actor*)jarg1;
2847   arg2 = jarg2 ? true : false;
2848   {
2849     try
2850     {
2851       (arg1)->SetProperty(Actor::Property::LEAVE_REQUIRED, arg2);
2852     }
2853     CALL_CATCH_EXCEPTION();
2854   }
2855 }
2856
2857 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void* jarg1)
2858 {
2859   bool         jresult;
2860   Dali::Actor* arg1 = (Dali::Actor*)0;
2861   bool         result;
2862
2863   if(!jarg1)
2864   {
2865     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2866     return 0;
2867   }
2868
2869   arg1 = (Dali::Actor*)jarg1;
2870   {
2871     try
2872     {
2873       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::LEAVE_REQUIRED);
2874     }
2875     CALL_CATCH_EXCEPTION(0);
2876   }
2877
2878   jresult = result;
2879   return jresult;
2880 }
2881
2882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void* jarg1, bool jarg2)
2883 {
2884   Dali::Actor* arg1 = (Dali::Actor*)0;
2885   bool         arg2;
2886
2887   if(!jarg1)
2888   {
2889     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2890     return;
2891   }
2892
2893   arg1 = (Dali::Actor*)jarg1;
2894   arg2 = jarg2 ? true : false;
2895   {
2896     try
2897     {
2898       (arg1)->SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, arg2);
2899     }
2900     CALL_CATCH_EXCEPTION();
2901   }
2902 }
2903
2904 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void* jarg1)
2905 {
2906   bool         jresult;
2907   Dali::Actor* arg1 = (Dali::Actor*)0;
2908   bool         result;
2909
2910   if(!jarg1)
2911   {
2912     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2913     return 0;
2914   }
2915
2916   arg1 = (Dali::Actor*)jarg1;
2917   {
2918     try
2919     {
2920       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE);
2921     }
2922     CALL_CATCH_EXCEPTION(0);
2923   }
2924
2925   jresult = result;
2926   return jresult;
2927 }
2928
2929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void* actor, bool keyboardFocusableChildren)
2930 {
2931   Dali::Actor* arg1 = (Dali::Actor*)0;
2932
2933   if(!actor)
2934   {
2935     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
2936     return;
2937   }
2938
2939   arg1 = (Dali::Actor*)actor;
2940   {
2941     try
2942     {
2943       (arg1)->SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren);
2944     }
2945     CALL_CATCH_EXCEPTION();
2946   }
2947 }
2948
2949 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void* actor)
2950 {
2951   Dali::Actor* arg1 = (Dali::Actor*)0;
2952   bool         result;
2953
2954   if(!actor)
2955   {
2956     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
2957     return 0;
2958   }
2959
2960   arg1 = (Dali::Actor*)actor;
2961   {
2962     try
2963     {
2964       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN);
2965     }
2966     CALL_CATCH_EXCEPTION(0);
2967   }
2968   return result;
2969 }
2970
2971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void* jarg1, bool jarg2)
2972 {
2973   Dali::Actor* arg1 = (Dali::Actor*)0;
2974   bool         arg2;
2975
2976   if(!jarg1)
2977   {
2978     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2979     return;
2980   }
2981
2982   arg1 = (Dali::Actor*)jarg1;
2983   arg2 = jarg2 ? true : false;
2984   {
2985     try
2986     {
2987       (arg1)->SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, arg2);
2988     }
2989     CALL_CATCH_EXCEPTION();
2990   }
2991 }
2992
2993 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void* jarg1)
2994 {
2995   bool         jresult;
2996   Dali::Actor* arg1 = (Dali::Actor*)0;
2997   bool         result;
2998
2999   if(!jarg1)
3000   {
3001     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3002     return 0;
3003   }
3004
3005   arg1 = (Dali::Actor*)jarg1;
3006   {
3007     try
3008     {
3009       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(DevelActor::Property::TOUCH_FOCUSABLE);
3010     }
3011     CALL_CATCH_EXCEPTION(0);
3012   }
3013
3014   jresult = result;
3015   return jresult;
3016 }
3017
3018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void* jarg1, int jarg2, int jarg3)
3019 {
3020   Dali::Actor*             arg1 = (Dali::Actor*)0;
3021   Dali::ResizePolicy::Type arg2;
3022   Dali::Dimension::Type    arg3;
3023
3024   if(!jarg1)
3025   {
3026     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3027     return;
3028   }
3029
3030   arg1 = (Dali::Actor*)jarg1;
3031   arg2 = (Dali::ResizePolicy::Type)jarg2;
3032   arg3 = (Dali::Dimension::Type)jarg3;
3033   {
3034     try
3035     {
3036       (arg1)->SetResizePolicy(arg2, arg3);
3037     }
3038     CALL_CATCH_EXCEPTION();
3039   }
3040 }
3041
3042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void* jarg1, int jarg2)
3043 {
3044   int                      jresult;
3045   Dali::Actor*             arg1 = (Dali::Actor*)0;
3046   Dali::Dimension::Type    arg2;
3047   Dali::ResizePolicy::Type result;
3048
3049   if(!jarg1)
3050   {
3051     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3052     return 0;
3053   }
3054
3055   arg1 = (Dali::Actor*)jarg1;
3056   arg2 = (Dali::Dimension::Type)jarg2;
3057   {
3058     try
3059     {
3060       result = (Dali::ResizePolicy::Type)((Dali::Actor const*)arg1)->GetResizePolicy(arg2);
3061     }
3062     CALL_CATCH_EXCEPTION(0);
3063   }
3064
3065   jresult = (int)result;
3066   return jresult;
3067 }
3068
3069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void* jarg1, int jarg2)
3070 {
3071   Dali::Actor*                arg1 = (Dali::Actor*)0;
3072   Dali::SizeScalePolicy::Type arg2;
3073
3074   if(!jarg1)
3075   {
3076     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3077     return;
3078   }
3079
3080   arg1 = (Dali::Actor*)jarg1;
3081   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
3082   {
3083     try
3084     {
3085       (arg1)->SetProperty(Actor::Property::SIZE_SCALE_POLICY, arg2);
3086     }
3087     CALL_CATCH_EXCEPTION();
3088   }
3089 }
3090
3091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void* jarg1)
3092 {
3093   int                         jresult;
3094   Dali::Actor*                arg1 = (Dali::Actor*)0;
3095   Dali::SizeScalePolicy::Type result;
3096
3097   if(!jarg1)
3098   {
3099     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3100     return 0;
3101   }
3102
3103   arg1 = (Dali::Actor*)jarg1;
3104   {
3105     try
3106     {
3107       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const*)arg1)->GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY);
3108     }
3109     CALL_CATCH_EXCEPTION(0);
3110   }
3111
3112   jresult = (int)result;
3113   return jresult;
3114 }
3115
3116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void* jarg1, void* jarg2)
3117 {
3118   Dali::Actor*   arg1 = (Dali::Actor*)0;
3119   Dali::Vector3* arg2 = 0;
3120
3121   if(!jarg1)
3122   {
3123     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3124     return;
3125   }
3126
3127   arg1 = (Dali::Actor*)jarg1;
3128   arg2 = (Dali::Vector3*)jarg2;
3129   if(!arg2)
3130   {
3131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3132     return;
3133   }
3134   {
3135     try
3136     {
3137       (arg1)->SetProperty(Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const&)*arg2);
3138     }
3139     CALL_CATCH_EXCEPTION();
3140   }
3141 }
3142
3143 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void* jarg1)
3144 {
3145   void*         jresult;
3146   Dali::Actor*  arg1 = (Dali::Actor*)0;
3147   Dali::Vector3 result;
3148
3149   if(!jarg1)
3150   {
3151     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3152     return 0;
3153   }
3154
3155   arg1 = (Dali::Actor*)jarg1;
3156   {
3157     try
3158     {
3159       result = ((Dali::Actor const*)arg1)->GetProperty<Vector3>(Actor::Property::SIZE_MODE_FACTOR);
3160     }
3161     CALL_CATCH_EXCEPTION(0);
3162   }
3163
3164   jresult = new Dali::Vector3((const Dali::Vector3&)result);
3165   return jresult;
3166 }
3167
3168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void* jarg1, float jarg2)
3169 {
3170   float        jresult;
3171   Dali::Actor* arg1 = (Dali::Actor*)0;
3172   float        arg2;
3173   float        result;
3174
3175   if(!jarg1)
3176   {
3177     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3178     return 0;
3179   }
3180
3181   arg1 = (Dali::Actor*)jarg1;
3182   arg2 = (float)jarg2;
3183   {
3184     try
3185     {
3186       result = (float)(arg1)->GetHeightForWidth(arg2);
3187     }
3188     CALL_CATCH_EXCEPTION(0);
3189   }
3190
3191   jresult = result;
3192   return jresult;
3193 }
3194
3195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void* jarg1, float jarg2)
3196 {
3197   float        jresult;
3198   Dali::Actor* arg1 = (Dali::Actor*)0;
3199   float        arg2;
3200   float        result;
3201
3202   if(!jarg1)
3203   {
3204     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3205     return 0;
3206   }
3207
3208   arg1 = (Dali::Actor*)jarg1;
3209   arg2 = (float)jarg2;
3210   {
3211     try
3212     {
3213       result = (float)(arg1)->GetWidthForHeight(arg2);
3214     }
3215     CALL_CATCH_EXCEPTION(0);
3216   }
3217
3218   jresult = result;
3219   return jresult;
3220 }
3221
3222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void* jarg1, int jarg2)
3223 {
3224   float                 jresult;
3225   Dali::Actor*          arg1 = (Dali::Actor*)0;
3226   Dali::Dimension::Type arg2;
3227   float                 result;
3228
3229   if(!jarg1)
3230   {
3231     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3232     return 0;
3233   }
3234
3235   arg1 = (Dali::Actor*)jarg1;
3236   arg2 = (Dali::Dimension::Type)jarg2;
3237   {
3238     try
3239     {
3240       result = (float)((Dali::Actor const*)arg1)->GetRelayoutSize(arg2);
3241     }
3242     CALL_CATCH_EXCEPTION(0);
3243   }
3244
3245   jresult = result;
3246   return jresult;
3247 }
3248
3249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void* jarg1, void* jarg2)
3250 {
3251   Dali::Actor*   arg1 = (Dali::Actor*)0;
3252   Dali::Padding* arg2 = 0;
3253
3254   if(!jarg1)
3255   {
3256     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3257     return;
3258   }
3259
3260   arg1 = (Dali::Actor*)jarg1;
3261   arg2 = (Dali::Padding*)jarg2;
3262   if(!arg2)
3263   {
3264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
3265     return;
3266   }
3267   {
3268     try
3269     {
3270       (arg1)->SetProperty(Actor::Property::PADDING, (Dali::Padding const&)*arg2);
3271     }
3272     CALL_CATCH_EXCEPTION();
3273   }
3274 }
3275
3276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void* jarg1, void* jarg2)
3277 {
3278   Dali::Actor*   arg1 = (Dali::Actor*)0;
3279   Dali::Padding* arg2 = 0;
3280
3281   if(!jarg1)
3282   {
3283     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3284     return;
3285   }
3286
3287   arg1 = (Dali::Actor*)jarg1;
3288   arg2 = (Dali::Padding*)jarg2;
3289   if(!arg2)
3290   {
3291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
3292     return;
3293   }
3294   {
3295     try
3296     {
3297       *arg2 = ((Dali::Actor const*)arg1)->GetProperty<Vector4>(Actor::Property::PADDING);
3298     }
3299     CALL_CATCH_EXCEPTION();
3300   }
3301 }
3302
3303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void* jarg1, void* jarg2)
3304 {
3305   Dali::Actor*   arg1 = (Dali::Actor*)0;
3306   Dali::Vector2* arg2 = 0;
3307
3308   if(!jarg1)
3309   {
3310     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3311     return;
3312   }
3313
3314   arg1 = (Dali::Actor*)jarg1;
3315   arg2 = (Dali::Vector2*)jarg2;
3316   if(!arg2)
3317   {
3318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3319     return;
3320   }
3321   {
3322     try
3323     {
3324       (arg1)->SetProperty(Actor::Property::MINIMUM_SIZE, (Dali::Vector2 const&)*arg2);
3325     }
3326     CALL_CATCH_EXCEPTION();
3327   }
3328 }
3329
3330 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void* jarg1)
3331 {
3332   void*         jresult;
3333   Dali::Actor*  arg1 = (Dali::Actor*)0;
3334   Dali::Vector2 result;
3335
3336   if(!jarg1)
3337   {
3338     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3339     return 0;
3340   }
3341
3342   arg1 = (Dali::Actor*)jarg1;
3343   {
3344     try
3345     {
3346       result = (arg1)->GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
3347     }
3348     CALL_CATCH_EXCEPTION(0);
3349   }
3350
3351   jresult = new Dali::Vector2((const Dali::Vector2&)result);
3352   return jresult;
3353 }
3354
3355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void* jarg1, void* jarg2)
3356 {
3357   Dali::Actor*   arg1 = (Dali::Actor*)0;
3358   Dali::Vector2* arg2 = 0;
3359
3360   if(!jarg1)
3361   {
3362     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3363     return;
3364   }
3365
3366   arg1 = (Dali::Actor*)jarg1;
3367   arg2 = (Dali::Vector2*)jarg2;
3368   if(!arg2)
3369   {
3370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3371     return;
3372   }
3373   {
3374     try
3375     {
3376       (arg1)->SetProperty(Actor::Property::MAXIMUM_SIZE, (Dali::Vector2 const&)*arg2);
3377     }
3378     CALL_CATCH_EXCEPTION();
3379   }
3380 }
3381
3382 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void* jarg1)
3383 {
3384   void*         jresult;
3385   Dali::Actor*  arg1 = (Dali::Actor*)0;
3386   Dali::Vector2 result;
3387
3388   if(!jarg1)
3389   {
3390     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3391     return 0;
3392   }
3393
3394   arg1 = (Dali::Actor*)jarg1;
3395   {
3396     try
3397     {
3398       result = (arg1)->GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
3399     }
3400     CALL_CATCH_EXCEPTION(0);
3401   }
3402
3403   jresult = new Dali::Vector2((const Dali::Vector2&)result);
3404   return jresult;
3405 }
3406
3407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void* jarg1)
3408 {
3409   int          jresult;
3410   Dali::Actor* arg1 = (Dali::Actor*)0;
3411   int          result;
3412
3413   if(!jarg1)
3414   {
3415     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3416     return 0;
3417   }
3418
3419   arg1 = (Dali::Actor*)jarg1;
3420   {
3421     try
3422     {
3423       result             = (int)(arg1)->GetProperty<int>(Actor::Property::HIERARCHY_DEPTH);
3424       Dali::Actor parent = ((Dali::Actor const*)arg1)->GetParent();
3425     }
3426     CALL_CATCH_EXCEPTION(0);
3427   }
3428
3429   jresult = result;
3430   return jresult;
3431 }
3432
3433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void* jarg1, void* jarg2)
3434 {
3435   unsigned int    jresult;
3436   Dali::Actor*    arg1 = (Dali::Actor*)0;
3437   Dali::Renderer* arg2 = 0;
3438   unsigned int    result;
3439
3440   if(!jarg1)
3441   {
3442     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3443     return 0;
3444   }
3445
3446   arg1 = (Dali::Actor*)jarg1;
3447   arg2 = (Dali::Renderer*)jarg2;
3448   if(!arg2)
3449   {
3450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
3451     return 0;
3452   }
3453   {
3454     try
3455     {
3456       result = (unsigned int)(arg1)->AddRenderer(*arg2);
3457     }
3458     CALL_CATCH_EXCEPTION(0);
3459   }
3460
3461   jresult = result;
3462   return jresult;
3463 }
3464
3465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void* jarg1)
3466 {
3467   unsigned int jresult;
3468   Dali::Actor* arg1 = (Dali::Actor*)0;
3469   unsigned int result;
3470
3471   if(!jarg1)
3472   {
3473     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3474     return 0;
3475   }
3476
3477   arg1 = (Dali::Actor*)jarg1;
3478   {
3479     try
3480     {
3481       result = (unsigned int)((Dali::Actor const*)arg1)->GetRendererCount();
3482     }
3483     CALL_CATCH_EXCEPTION(0);
3484   }
3485
3486   jresult = result;
3487   return jresult;
3488 }
3489
3490 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void* jarg1, unsigned int jarg2)
3491 {
3492   void*          jresult;
3493   Dali::Actor*   arg1 = (Dali::Actor*)0;
3494   unsigned int   arg2;
3495   Dali::Renderer result;
3496
3497   if(!jarg1)
3498   {
3499     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3500     return 0;
3501   }
3502
3503   arg1 = (Dali::Actor*)jarg1;
3504   arg2 = (unsigned int)jarg2;
3505   {
3506     try
3507     {
3508       result = (arg1)->GetRendererAt(arg2);
3509     }
3510     CALL_CATCH_EXCEPTION(0);
3511   }
3512
3513   jresult = new Dali::Renderer((const Dali::Renderer&)result);
3514   return jresult;
3515 }
3516
3517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void* jarg1, void* jarg2)
3518 {
3519   Dali::Actor*    arg1 = (Dali::Actor*)0;
3520   Dali::Renderer* arg2 = 0;
3521
3522   if(!jarg1)
3523   {
3524     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3525     return;
3526   }
3527
3528   arg1 = (Dali::Actor*)jarg1;
3529   arg2 = (Dali::Renderer*)jarg2;
3530   if(!arg2)
3531   {
3532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
3533     return;
3534   }
3535   {
3536     try
3537     {
3538       (arg1)->RemoveRenderer(*arg2);
3539     }
3540     CALL_CATCH_EXCEPTION();
3541   }
3542 }
3543
3544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void* jarg1, unsigned int jarg2)
3545 {
3546   Dali::Actor* arg1 = (Dali::Actor*)0;
3547   unsigned int arg2;
3548
3549   if(!jarg1)
3550   {
3551     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3552     return;
3553   }
3554
3555   arg1 = (Dali::Actor*)jarg1;
3556   arg2 = (unsigned int)jarg2;
3557   {
3558     try
3559     {
3560       (arg1)->RemoveRenderer(arg2);
3561     }
3562     CALL_CATCH_EXCEPTION();
3563   }
3564 }
3565
3566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void* jarg1, bool jarg2)
3567 {
3568   Dali::Actor  arg1;
3569   bool         arg2;
3570   Dali::Actor* argp1 = (Dali::Actor*)0;
3571
3572   argp1 = (Dali::Actor*)jarg1;
3573   if(!argp1)
3574   {
3575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3576     return;
3577   }
3578   arg1 = *argp1;
3579   arg2 = jarg2;
3580   {
3581     try
3582     {
3583       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
3584     }
3585     CALL_CATCH_EXCEPTION();
3586   }
3587   return;
3588 }
3589
3590 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenPosition(void* actor)
3591 {
3592   void*         jresult;
3593   Dali::Actor   arg1;
3594   Dali::Actor*  argp1 = (Dali::Actor*)0;
3595   Dali::Vector2 result;
3596
3597   argp1 = (Dali::Actor*)actor;
3598   if(!argp1)
3599   {
3600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3601     return 0;
3602   }
3603   arg1 = *argp1;
3604   {
3605     try
3606     {
3607       result = Dali::DevelActor::CalculateScreenPosition(arg1);
3608     }
3609     CALL_CATCH_EXCEPTION(0);
3610   }
3611
3612   jresult = new Dali::Vector2((const Dali::Vector2&)result);
3613   return jresult;
3614 }
3615
3616 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void* actor)
3617 {
3618   Dali::Actor       arg1;
3619   Dali::Actor*      argp1 = (Dali::Actor*)0;
3620   Dali::Rect<float> result;
3621
3622   argp1 = (Dali::Actor*)actor;
3623   if(!argp1)
3624   {
3625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3626     return 0;
3627   }
3628   arg1 = *argp1;
3629   {
3630     try
3631     {
3632       result = Dali::DevelActor::CalculateScreenExtents(arg1);
3633     }
3634     CALL_CATCH_EXCEPTION(0);
3635   }
3636
3637   // Note: The float type Rectangle class is not ready yet.
3638   //      Therefore, it transmits data in Vector4 class.
3639   //      This type should later be changed to the appropriate data type.
3640   return new Dali::Vector4(result.x, result.y, result.width, result.height);
3641 }
3642
3643 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CurrentScreenExtents(void* actor)
3644 {
3645   Dali::Actor       arg1;
3646   Dali::Actor*      argp1 = (Dali::Actor*)0;
3647   Dali::Rect<float> result;
3648
3649   argp1 = (Dali::Actor*)actor;
3650   if(!argp1)
3651   {
3652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3653     return 0;
3654   }
3655   arg1 = *argp1;
3656   {
3657     try
3658     {
3659       result = Dali::DevelActor::CalculateCurrentScreenExtents(arg1);
3660     }
3661     CALL_CATCH_EXCEPTION(0);
3662   }
3663
3664   // Note: The float type Rectangle class is not ready yet.
3665   //      Therefore, it transmits data in Vector4 class.
3666   //      This type should later be changed to the appropriate data type.
3667   return new Dali::Vector4(result.x, result.y, result.width, result.height);
3668 }
3669
3670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_LookAt(void* csActor, void* csTarget, void* csUp, void* csLocalForward, void* csLocalUp)
3671 {
3672   Dali::Actor   actor;
3673   Dali::Vector3 target;
3674   Dali::Vector3 up           = Vector3::YAXIS;
3675   Dali::Vector3 localForward = Vector3::ZAXIS;
3676   Dali::Vector3 localUp      = Vector3::YAXIS;
3677
3678   if(!csActor)
3679   {
3680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3681     return;
3682   }
3683
3684   if(!csTarget)
3685   {
3686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null target Dali::Vector3", 0);
3687     return;
3688   }
3689
3690   actor  = *(Dali::Actor*)csActor;
3691   target = *(Dali::Vector3*)csTarget;
3692
3693   // Use default value if csUp is null
3694   if(csUp)
3695   {
3696     up = *(Dali::Vector3*)csUp;
3697   }
3698
3699   // Use default value if csLocalForward is null
3700   if(csLocalForward)
3701   {
3702     localForward = *(Dali::Vector3*)csLocalForward;
3703   }
3704
3705   // Use default value if csLocalForward is null
3706   if(csLocalUp)
3707   {
3708     localUp = *(Dali::Vector3*)csLocalUp;
3709   }
3710
3711   {
3712     try
3713     {
3714       Dali::DevelActor::LookAt(actor, target, up, localForward, localUp);
3715     }
3716     CALL_CATCH_EXCEPTION();
3717   }
3718 }
3719
3720 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5)
3721 {
3722   Dali::Actor* arg1 = (Dali::Actor*)0;
3723   arg1              = (Dali::Actor*)jarg1;
3724   Rect<int> arg2    = Rect(jarg2, jarg3, jarg4, jarg5);
3725   {
3726     try
3727     {
3728       (arg1)->SetProperty(Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2);
3729     }
3730     CALL_CATCH_EXCEPTION();
3731   }
3732 }
3733
3734 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void* jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5)
3735 {
3736   Dali::Actor* arg1 = (Dali::Actor*)0;
3737   arg1              = (Dali::Actor*)jarg1;
3738
3739   Rect<int32_t> result;
3740   {
3741     try
3742     {
3743       result = (arg1)->GetProperty<Rect<int32_t>>(Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
3744       *jarg2 = result.left;
3745       *jarg3 = result.right;
3746       *jarg4 = result.bottom;
3747       *jarg5 = result.top;
3748     }
3749     CALL_CATCH_EXCEPTION();
3750   }
3751 }
3752
3753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void* jarg1)
3754 {
3755   Dali::Actor* arg1 = 0;
3756
3757   arg1 = (Dali::Actor*)jarg1;
3758   if(!arg1)
3759   {
3760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
3761     return;
3762   }
3763   {
3764     try
3765     {
3766       Dali::UnparentAndReset(*arg1);
3767     }
3768     CALL_CATCH_EXCEPTION();
3769   }
3770 }
3771
3772
3773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumWidth(void * jarg1) {
3774   Dali::Actor *arg1 = (Dali::Actor *) 0;
3775   Dali::Vector2 maximumSize;
3776   Dali::Vector2 minimumSize;
3777   Dali::Vector3 naturalSize;
3778   bool widthForHeight;
3779   float result;
3780   {
3781     try {
3782       arg1 = (Dali::Actor *)jarg1;
3783       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
3784       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
3785       naturalSize = arg1->GetNaturalSize();
3786       widthForHeight = arg1->GetProperty< bool >( Actor::Property::WIDTH_FOR_HEIGHT );
3787
3788       float baseWidth;
3789       if (widthForHeight)
3790       {
3791         float baseHeight = maximumSize.height > 0 ? std::min(maximumSize.height, naturalSize.height) : naturalSize.height;
3792         baseWidth = arg1->GetWidthForHeight(baseHeight);
3793       }
3794       else
3795       {
3796         baseWidth = naturalSize.width;
3797       }
3798
3799       result = minimumSize.width > 0 ? std::max(baseWidth, minimumSize.width) : baseWidth;
3800       result = maximumSize.width > 0 ? std::min(result, maximumSize.width) : result;
3801     } CALL_CATCH_EXCEPTION(0);
3802   }
3803
3804   return result;
3805 }
3806
3807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetSuggestedMinimumHeight(void * jarg1) {
3808   Dali::Actor *arg1 = (Dali::Actor *) 0;
3809   Dali::Vector2 maximumSize;
3810   Dali::Vector2 minimumSize;
3811   Dali::Vector3 naturalSize;
3812   bool heightForWidth;
3813   float result;
3814   {
3815     try {
3816       arg1 = (Dali::Actor *)jarg1;
3817       maximumSize = arg1->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
3818       minimumSize = arg1->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
3819       naturalSize = arg1->GetNaturalSize();
3820       heightForWidth = arg1->GetProperty< bool >( Actor::Property::HEIGHT_FOR_WIDTH );
3821
3822       float baseHeight;
3823       if (heightForWidth)
3824       {
3825         float baseWidth = maximumSize.width > 0 ? std::min(maximumSize.width, naturalSize.width) : naturalSize.width;
3826         baseHeight = arg1->GetHeightForWidth(baseWidth);
3827       }
3828       else
3829       {
3830         baseHeight = naturalSize.height;
3831       }
3832
3833       result = minimumSize.height > 0 ? std::max(baseHeight, minimumSize.height) : baseHeight;
3834       result = maximumSize.height > 0 ? std::min(result, maximumSize.height) : result;
3835     } CALL_CATCH_EXCEPTION(0);
3836   }
3837
3838   return result;
3839 }
3840
3841
3842 // Signals
3843 #ifndef GENERATE_DEVEL_ACTOR_SIGNAL
3844 #define GENERATE_DEVEL_ACTOR_SIGNAL(HType, SignalName) GENERATE_DEVEL_SIGNAL(Dali::Actor*, HType, Dali::DevelActor, Dali_Actor, SignalName)
3845 #endif
3846 #ifndef GENERATE_ACTOR_SIGNAL
3847 #define GENERATE_ACTOR_SIGNAL(HType, SignalName) GENERATE_SIGNAL(Dali::Actor*, HType, Dali_Actor, SignalName)
3848 #endif
3849
3850 GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), HitTestResultSignal)
3851 // CSharp_Dali_Actor_HitTestResultSignal_Connect
3852 // CSharp_Dali_Actor_HitTestResultSignal_Disconnect
3853
3854 GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), InterceptTouchedSignal)
3855 // CSharp_Dali_Actor_InterceptTouchedSignal_Connect
3856 // CSharp_Dali_Actor_InterceptTouchedSignal_Disconnect
3857
3858 GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), TouchedSignal)
3859 // CSharp_Dali_Actor_TouchedSignal_Connect
3860 // CSharp_Dali_Actor_TouchedSignal_Disconnect
3861
3862 GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::HoverEvent const&), HoveredSignal)
3863 // CSharp_Dali_Actor_HoveredSignal_Connect
3864 // CSharp_Dali_Actor_HoveredSignal_Disconnect
3865
3866 GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), WheelEventSignal)
3867 // CSharp_Dali_Actor_WheelEventSignal_Connect
3868 // CSharp_Dali_Actor_WheelEventSignal_Disconnect
3869
3870 GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), InterceptWheelSignal)
3871 // CSharp_Dali_Actor_InterceptWheelSignal_Connect
3872 // CSharp_Dali_Actor_InterceptWheelSignal_Disconnect
3873
3874 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnSceneSignal)
3875 // CSharp_Dali_Actor_OnSceneSignal_Connect
3876 // CSharp_Dali_Actor_OnSceneSignal_Disconnect
3877
3878 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OffSceneSignal)
3879 // CSharp_Dali_Actor_OffSceneSignal_Connect
3880 // CSharp_Dali_Actor_OffSceneSignal_Disconnect
3881
3882 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnRelayoutSignal)
3883 // CSharp_Dali_Actor_OnRelayoutSignal_Connect
3884 // CSharp_Dali_Actor_OnRelayoutSignal_Disconnect
3885
3886 GENERATE_DEVEL_ACTOR_SIGNAL(void(*)(Dali::Actor, bool, Dali::DevelActor::VisibilityChange::Type), VisibilityChangedSignal)
3887 // CSharp_Dali_Actor_VisibilityChangedSignal_Connect
3888 // CSharp_Dali_Actor_VisibilityChangedSignal_Disconnect
3889
3890 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor, LayoutDirection::Type), LayoutDirectionChangedSignal)
3891 // CSharp_Dali_Actor_LayoutDirectionChangedSignal_Connect
3892 // CSharp_Dali_Actor_LayoutDirectionChangedSignal_Disconnect
3893
3894 #ifdef __cplusplus
3895 }
3896 #endif