dali-csharp-binder/src/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 "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 // Creation
 699
 700 SWIGEXPORT Dali::Handle* SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor* jarg1)
 701 {
 702   return (Dali::Handle*)jarg1;
 703 }
 704
 705 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor_Property()
 706 {
 707   void*                  jresult;
 708   Dali::Actor::Property* result = 0;
 709
 710   {
 711     try
 712     {
 713       result = (Dali::Actor::Property*)new Dali::Actor::Property();
 714     }
 715     CALL_CATCH_EXCEPTION(0);
 716   }
 717
 718   jresult = (void*)result;
 719   return jresult;
 720 }
 721
 722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void* jarg1)
 723 {
 724   Dali::Actor::Property* arg1 = (Dali::Actor::Property*)0;
 725
 726   arg1 = (Dali::Actor::Property*)jarg1;
 727   {
 728     try
 729     {
 730       delete arg1;
 731     }
 732     CALL_CATCH_EXCEPTION();
 733   }
 734 }
 735
 736 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0()
 737 {
 738   void*        jresult;
 739   Dali::Actor* result = 0;
 740
 741   {
 742     try
 743     {
 744       result = (Dali::Actor*)new Dali::Actor();
 745     }
 746     CALL_CATCH_EXCEPTION(0);
 747   }
 748
 749   jresult = (void*)result;
 750   return jresult;
 751 }
 752
 753 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_New()
 754 {
 755   void*       jresult;
 756   Dali::Actor result;
 757
 758   {
 759     try
 760     {
 761       result = Dali::Actor::New();
 762     }
 763     CALL_CATCH_EXCEPTION(0);
 764   }
 765
 766   jresult = new Dali::Actor((const Dali::Actor&)result);
 767   return jresult;
 768 }
 769
 770 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_DownCast(void* jarg1)
 771 {
 772   void*             jresult;
 773   Dali::BaseHandle  arg1;
 774   Dali::BaseHandle* argp1;
 775   Dali::Actor       result;
 776
 777   argp1 = (Dali::BaseHandle*)jarg1;
 778   if(!argp1)
 779   {
 780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 781     return 0;
 782   }
 783   arg1 = *argp1;
 784   {
 785     try
 786     {
 787       result = Dali::Actor::DownCast(arg1);
 788     }
 789     CALL_CATCH_EXCEPTION(0);
 790   }
 791
 792   jresult = new Dali::Actor((const Dali::Actor&)result);
 793   return jresult;
 794 }
 795
 796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void* jarg1)
 797 {
 798   Dali::Actor* arg1 = (Dali::Actor*)0;
 799
 800   arg1 = (Dali::Actor*)jarg1;
 801   {
 802     try
 803     {
 804       delete arg1;
 805     }
 806     CALL_CATCH_EXCEPTION();
 807   }
 808 }
 809
 810 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void* jarg1)
 811 {
 812   void*        jresult;
 813   Dali::Actor* arg1   = 0;
 814   Dali::Actor* result = 0;
 815
 816   arg1 = (Dali::Actor*)jarg1;
 817   if(!arg1)
 818   {
 819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
 820     return 0;
 821   }
 822   {
 823     try
 824     {
 825       result = (Dali::Actor*)new Dali::Actor((Dali::Actor const&)*arg1);
 826     }
 827     CALL_CATCH_EXCEPTION(0);
 828   }
 829
 830   jresult = (void*)result;
 831   return jresult;
 832 }
 833
 834 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_Assign(void* jarg1, void* jarg2)
 835 {
 836   void*        jresult;
 837   Dali::Actor* arg1   = (Dali::Actor*)0;
 838   Dali::Actor* arg2   = 0;
 839   Dali::Actor* result = 0;
 840
 841   if(!jarg1)
 842   {
 843     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 844     return 0;
 845   }
 846
 847   if(!jarg2)
 848   {
 849     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
 850     return 0;
 851   }
 852
 853   arg1 = (Dali::Actor*)jarg1;
 854   arg2 = (Dali::Actor*)jarg2;
 855   {
 856     try
 857     {
 858       result = (Dali::Actor*)&(arg1)->operator=((Dali::Actor const&)*arg2);
 859     }
 860     CALL_CATCH_EXCEPTION(0);
 861   }
 862
 863   jresult = (void*)result;
 864   return jresult;
 865 }
 866
 867 // Method
 868
 869 SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Actor_GetName(void* jarg1)
 870 {
 871   char*        jresult;
 872   Dali::Actor* arg1   = (Dali::Actor*)0;
 873   std::string* result = 0;
 874   std::string  name   = "";
 875
 876   if(!jarg1)
 877   {
 878     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 879     return 0;
 880   }
 881
 882   arg1 = (Dali::Actor*)jarg1;
 883   {
 884     try
 885     {
 886       name    = ((Dali::Actor const*)arg1)->GetProperty<std::string>(Dali::Actor::Property::NAME);
 887       result  = (std::string*)&name;
 888       jresult = SWIG_csharp_string_callback(result->c_str());
 889     }
 890     CALL_CATCH_EXCEPTION(0);
 891   }
 892   return jresult;
 893 }
 894
 895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void* jarg1, char* jarg2)
 896 {
 897   Dali::Actor* arg1 = (Dali::Actor*)0;
 898   std::string* arg2 = 0;
 899
 900   if(!jarg1)
 901   {
 902     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 903     return;
 904   }
 905
 906   arg1 = (Dali::Actor*)jarg1;
 907   if(!jarg2)
 908   {
 909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
 910     return;
 911   }
 912   std::string arg2_str(jarg2);
 913   arg2 = &arg2_str;
 914   {
 915     try
 916     {
 917       (arg1)->SetProperty(Dali::Actor::Property::NAME, (std::string const&)*arg2);
 918     }
 919     CALL_CATCH_EXCEPTION();
 920   }
 921
 922   //argout typemap for const std::string&
 923 }
 924
 925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void* jarg1)
 926 {
 927   unsigned int jresult;
 928   Dali::Actor* arg1 = (Dali::Actor*)0;
 929   unsigned int result;
 930
 931   arg1 = (Dali::Actor*)jarg1;
 932
 933   if(!arg1)
 934   {
 935     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
 936     return -1;
 937   }
 938
 939   {
 940     try
 941     {
 942       result = (unsigned int)((Dali::Actor const*)arg1)->GetProperty<int>(Actor::Property::ID);
 943     }
 944     CALL_CATCH_EXCEPTION(0);
 945   }
 946
 947   jresult = result;
 948   return jresult;
 949 }
 950
 951 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void* jarg1)
 952 {
 953   bool         jresult;
 954   Dali::Actor* arg1 = (Dali::Actor*)0;
 955   bool         result;
 956
 957   if(!jarg1)
 958   {
 959     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 960     return 0;
 961   }
 962
 963   arg1 = (Dali::Actor*)jarg1;
 964   {
 965     try
 966     {
 967       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::IS_ROOT);
 968     }
 969     CALL_CATCH_EXCEPTION(0);
 970   }
 971
 972   jresult = result;
 973   return jresult;
 974 }
 975
 976 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void* jarg1)
 977 {
 978   bool         jresult;
 979   Dali::Actor* arg1 = (Dali::Actor*)0;
 980   bool         result;
 981
 982   if(!jarg1)
 983   {
 984     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
 985     return 0;
 986   }
 987
 988   arg1 = (Dali::Actor*)jarg1;
 989   {
 990     try
 991     {
 992       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE);
 993     }
 994     CALL_CATCH_EXCEPTION(0);
 995   }
 996
 997   jresult = result;
 998   return jresult;
 999 }
1000
1001 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void* jarg1)
1002 {
1003   bool         jresult;
1004   Dali::Actor* arg1 = (Dali::Actor*)0;
1005   bool         result;
1006
1007   if(!jarg1)
1008   {
1009     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1010     return 0;
1011   }
1012
1013   arg1 = (Dali::Actor*)jarg1;
1014   {
1015     try
1016     {
1017       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::IS_LAYER);
1018     }
1019     CALL_CATCH_EXCEPTION(0);
1020   }
1021
1022   jresult = result;
1023   return jresult;
1024 }
1025
1026 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void* jarg1)
1027 {
1028   void*        jresult;
1029   Dali::Actor* arg1 = (Dali::Actor*)0;
1030   Dali::Layer  result;
1031
1032   if(!jarg1)
1033   {
1034     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1035     return 0;
1036   }
1037
1038   arg1 = (Dali::Actor*)jarg1;
1039   {
1040     try
1041     {
1042       result = (arg1)->GetLayer();
1043     }
1044     CALL_CATCH_EXCEPTION(0);
1045   }
1046
1047   jresult = new Dali::Layer((const Dali::Layer&)result);
1048   return jresult;
1049 }
1050
1051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void* jarg1, void* jarg2)
1052 {
1053   Dali::Actor* arg1 = (Dali::Actor*)0;
1054   Dali::Actor  arg2;
1055
1056   if(!jarg1)
1057   {
1058     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1059     return;
1060   }
1061   if(!jarg2)
1062   {
1063     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
1064     return;
1065   }
1066
1067   arg1 = (Dali::Actor*)jarg1;
1068   arg2 = *((Dali::Actor*)jarg2);
1069   {
1070     try
1071     {
1072       (arg1)->Add(arg2);
1073     }
1074     CALL_CATCH_EXCEPTION();
1075   }
1076 }
1077
1078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void* jarg1, void* jarg2)
1079 {
1080   Dali::Actor* arg1 = (Dali::Actor*)0;
1081   Dali::Actor  arg2;
1082
1083   if(!jarg1)
1084   {
1085     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1086     return;
1087   }
1088   if(!jarg2)
1089   {
1090     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
1091     return;
1092   }
1093
1094   arg1 = (Dali::Actor*)jarg1;
1095   arg2 = *((Dali::Actor*)jarg2);
1096   {
1097     try
1098     {
1099       (arg1)->Remove(arg2);
1100     }
1101     CALL_CATCH_EXCEPTION();
1102   }
1103 }
1104
1105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void* jarg1)
1106 {
1107   Dali::Actor* arg1 = (Dali::Actor*)0;
1108
1109   if(!jarg1)
1110   {
1111     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1112     return;
1113   }
1114
1115   arg1 = (Dali::Actor*)jarg1;
1116   {
1117     try
1118     {
1119       (arg1)->Unparent();
1120     }
1121     CALL_CATCH_EXCEPTION();
1122   }
1123 }
1124
1125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void* jarg1)
1126 {
1127   unsigned int jresult;
1128   Dali::Actor* arg1 = (Dali::Actor*)0;
1129   unsigned int result;
1130
1131   if(!jarg1)
1132   {
1133     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1134     return 0;
1135   }
1136
1137   arg1 = (Dali::Actor*)jarg1;
1138   {
1139     try
1140     {
1141       result = (unsigned int)((Dali::Actor const*)arg1)->GetChildCount();
1142     }
1143     CALL_CATCH_EXCEPTION(0);
1144   }
1145
1146   jresult = result;
1147   return jresult;
1148 }
1149
1150 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void* jarg1, unsigned int jarg2)
1151 {
1152   void*        jresult;
1153   Dali::Actor* arg1 = (Dali::Actor*)0;
1154   unsigned int arg2;
1155   Dali::Actor  result;
1156
1157   if(!jarg1)
1158   {
1159     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1160     return 0;
1161   }
1162
1163   arg1 = (Dali::Actor*)jarg1;
1164   arg2 = (unsigned int)jarg2;
1165   {
1166     try
1167     {
1168       result = ((Dali::Actor const*)arg1)->GetChildAt(arg2);
1169     }
1170     CALL_CATCH_EXCEPTION(0);
1171   }
1172
1173   jresult = new Dali::Actor((const Dali::Actor&)result);
1174   return jresult;
1175 }
1176
1177 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void* jarg1, char* jarg2)
1178 {
1179   void*        jresult;
1180   Dali::Actor* arg1 = (Dali::Actor*)0;
1181   std::string* arg2 = 0;
1182   Dali::Actor  result;
1183
1184   if(!jarg1)
1185   {
1186     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1187     return 0;
1188   }
1189
1190   arg1 = (Dali::Actor*)jarg1;
1191   if(!jarg2)
1192   {
1193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
1194     return 0;
1195   }
1196   std::string arg2_str(jarg2);
1197   arg2 = &arg2_str;
1198   {
1199     try
1200     {
1201       result = (arg1)->FindChildByName((std::string const&)*arg2);
1202     }
1203     CALL_CATCH_EXCEPTION(0);
1204   }
1205
1206   jresult = new Dali::Actor((const Dali::Actor&)result);
1207
1208   //argout typemap for const std::string&
1209
1210   return jresult;
1211 }
1212
1213 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void* jarg1, unsigned int jarg2)
1214 {
1215   void*        jresult;
1216   Dali::Actor* arg1 = (Dali::Actor*)0;
1217   unsigned int arg2;
1218   Dali::Actor  result;
1219
1220   if(!jarg1)
1221   {
1222     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1223     return 0;
1224   }
1225
1226   arg1 = (Dali::Actor*)jarg1;
1227   arg2 = (unsigned int)jarg2;
1228   {
1229     try
1230     {
1231       result = (arg1)->FindChildById(arg2);
1232     }
1233     CALL_CATCH_EXCEPTION(0);
1234   }
1235
1236   jresult = new Dali::Actor((const Dali::Actor&)result);
1237   return jresult;
1238 }
1239
1240 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetParent(void* jarg1)
1241 {
1242   void*        jresult;
1243   Dali::Actor* arg1 = (Dali::Actor*)0;
1244   Dali::Actor  result;
1245
1246   if(!jarg1)
1247   {
1248     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1249     return 0;
1250   }
1251
1252   arg1 = (Dali::Actor*)jarg1;
1253   {
1254     try
1255     {
1256       result = ((Dali::Actor const*)arg1)->GetParent();
1257     }
1258     CALL_CATCH_EXCEPTION(0);
1259   }
1260
1261   jresult = new Dali::Actor((const Dali::Actor&)result);
1262   return jresult;
1263 }
1264
1265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void* jarg1, void* jarg2)
1266 {
1267   Dali::Actor*   arg1 = (Dali::Actor*)0;
1268   Dali::Vector3* arg2 = 0;
1269
1270   if(!jarg1)
1271   {
1272     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1273     return;
1274   }
1275
1276   arg1 = (Dali::Actor*)jarg1;
1277   arg2 = (Dali::Vector3*)jarg2;
1278   if(!arg2)
1279   {
1280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1281     return;
1282   }
1283   {
1284     try
1285     {
1286       (arg1)->SetProperty(Actor::Property::PARENT_ORIGIN, (Dali::Vector3 const&)*arg2);
1287     }
1288     CALL_CATCH_EXCEPTION();
1289   }
1290 }
1291
1292 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void* jarg1)
1293 {
1294   void*         jresult;
1295   Dali::Actor*  arg1 = (Dali::Actor*)0;
1296   Dali::Vector3 result;
1297
1298   if(!jarg1)
1299   {
1300     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1301     return 0;
1302   }
1303
1304   arg1 = (Dali::Actor*)jarg1;
1305   {
1306     try
1307     {
1308       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN);
1309     }
1310     CALL_CATCH_EXCEPTION(0);
1311   }
1312
1313   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1314   return jresult;
1315 }
1316
1317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void* jarg1, void* jarg2)
1318 {
1319   Dali::Actor*   arg1 = (Dali::Actor*)0;
1320   Dali::Vector3* arg2 = 0;
1321
1322   if(!jarg1)
1323   {
1324     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1325     return;
1326   }
1327
1328   arg1 = (Dali::Actor*)jarg1;
1329   arg2 = (Dali::Vector3*)jarg2;
1330   if(!arg2)
1331   {
1332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1333     return;
1334   }
1335   {
1336     try
1337     {
1338       (arg1)->SetProperty(Actor::Property::ANCHOR_POINT, (Dali::Vector3 const&)*arg2);
1339     }
1340     CALL_CATCH_EXCEPTION();
1341   }
1342 }
1343
1344 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void* jarg1)
1345 {
1346   void*         jresult;
1347   Dali::Actor*  arg1 = (Dali::Actor*)0;
1348   Dali::Vector3 result;
1349
1350   if(!jarg1)
1351   {
1352     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1353     return 0;
1354   }
1355
1356   arg1 = (Dali::Actor*)jarg1;
1357   {
1358     try
1359     {
1360       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT);
1361     }
1362     CALL_CATCH_EXCEPTION(0);
1363   }
1364
1365   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1366   return jresult;
1367 }
1368
1369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void* jarg1, float jarg2, float jarg3)
1370 {
1371   Dali::Actor* arg1 = (Dali::Actor*)0;
1372   float        arg2;
1373   float        arg3;
1374
1375   if(!jarg1)
1376   {
1377     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1378     return;
1379   }
1380
1381   arg1 = (Dali::Actor*)jarg1;
1382   arg2 = (float)jarg2;
1383   arg3 = (float)jarg3;
1384   {
1385     try
1386     {
1387       (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector2(arg2, arg3));
1388     }
1389     CALL_CATCH_EXCEPTION();
1390   }
1391 }
1392
1393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
1394 {
1395   Dali::Actor* arg1 = (Dali::Actor*)0;
1396   float        arg2;
1397   float        arg3;
1398   float        arg4;
1399
1400   if(!jarg1)
1401   {
1402     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1403     return;
1404   }
1405
1406   arg1 = (Dali::Actor*)jarg1;
1407   arg2 = (float)jarg2;
1408   arg3 = (float)jarg3;
1409   arg4 = (float)jarg4;
1410   {
1411     try
1412     {
1413       (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector3(arg2, arg3, arg4));
1414     }
1415     CALL_CATCH_EXCEPTION();
1416   }
1417 }
1418
1419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void* jarg1, void* jarg2)
1420 {
1421   Dali::Actor*   arg1 = (Dali::Actor*)0;
1422   Dali::Vector2* arg2 = 0;
1423
1424   if(!jarg1)
1425   {
1426     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1427     return;
1428   }
1429
1430   arg1 = (Dali::Actor*)jarg1;
1431   arg2 = (Dali::Vector2*)jarg2;
1432   if(!arg2)
1433   {
1434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
1435     return;
1436   }
1437   {
1438     try
1439     {
1440       (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector2 const&)*arg2);
1441     }
1442     CALL_CATCH_EXCEPTION();
1443   }
1444 }
1445
1446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void* jarg1, void* jarg2)
1447 {
1448   Dali::Actor*   arg1 = (Dali::Actor*)0;
1449   Dali::Vector3* arg2 = 0;
1450
1451   if(!jarg1)
1452   {
1453     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1454     return;
1455   }
1456
1457   arg1 = (Dali::Actor*)jarg1;
1458   arg2 = (Dali::Vector3*)jarg2;
1459   if(!arg2)
1460   {
1461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1462     return;
1463   }
1464   {
1465     try
1466     {
1467       (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector3 const&)*arg2);
1468     }
1469     CALL_CATCH_EXCEPTION();
1470   }
1471 }
1472
1473 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void* jarg1)
1474 {
1475   void*         jresult;
1476   Dali::Actor*  arg1 = (Dali::Actor*)0;
1477   Dali::Vector3 result;
1478
1479   if(!jarg1)
1480   {
1481     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1482     return 0;
1483   }
1484
1485   arg1 = (Dali::Actor*)jarg1;
1486   {
1487     try
1488     {
1489       result = ((Dali::Actor const*)arg1)->GetTargetSize();
1490     }
1491     CALL_CATCH_EXCEPTION(0);
1492   }
1493
1494   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1495   return jresult;
1496 }
1497
1498 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void* jarg1)
1499 {
1500   void*         jresult;
1501   Dali::Actor*  arg1 = (Dali::Actor*)0;
1502   Dali::Vector3 result;
1503
1504   if(!jarg1)
1505   {
1506     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1507     return 0;
1508   }
1509
1510   arg1 = (Dali::Actor*)jarg1;
1511   {
1512     try
1513     {
1514       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::SIZE);
1515     }
1516     CALL_CATCH_EXCEPTION(0);
1517   }
1518
1519   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1520   return jresult;
1521 }
1522
1523 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void* jarg1)
1524 {
1525   void*         jresult;
1526   Dali::Actor*  arg1 = (Dali::Actor*)0;
1527   Dali::Vector3 result;
1528
1529   if(!jarg1)
1530   {
1531     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1532     return 0;
1533   }
1534
1535   arg1 = (Dali::Actor*)jarg1;
1536   {
1537     try
1538     {
1539       result = ((Dali::Actor const*)arg1)->GetNaturalSize();
1540     }
1541     CALL_CATCH_EXCEPTION(0);
1542   }
1543
1544   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1545   return jresult;
1546 }
1547
1548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void* jarg1, float jarg2, float jarg3)
1549 {
1550   Dali::Actor* arg1 = (Dali::Actor*)0;
1551   float        arg2;
1552   float        arg3;
1553
1554   if(!jarg1)
1555   {
1556     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1557     return;
1558   }
1559
1560   arg1 = (Dali::Actor*)jarg1;
1561   arg2 = (float)jarg2;
1562   arg3 = (float)jarg3;
1563   {
1564     try
1565     {
1566       (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector2(arg2, arg3));
1567     }
1568     CALL_CATCH_EXCEPTION();
1569   }
1570 }
1571
1572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
1573 {
1574   Dali::Actor* arg1 = (Dali::Actor*)0;
1575   float        arg2;
1576   float        arg3;
1577   float        arg4;
1578
1579   if(!jarg1)
1580   {
1581     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1582     return;
1583   }
1584
1585   arg1 = (Dali::Actor*)jarg1;
1586   arg2 = (float)jarg2;
1587   arg3 = (float)jarg3;
1588   arg4 = (float)jarg4;
1589   {
1590     try
1591     {
1592       (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector3(arg2, arg3, arg4));
1593     }
1594     CALL_CATCH_EXCEPTION();
1595   }
1596 }
1597
1598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void* jarg1, void* jarg2)
1599 {
1600   Dali::Actor*   arg1 = (Dali::Actor*)0;
1601   Dali::Vector3* arg2 = 0;
1602
1603   if(!jarg1)
1604   {
1605     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1606     return;
1607   }
1608
1609   arg1 = (Dali::Actor*)jarg1;
1610   arg2 = (Dali::Vector3*)jarg2;
1611   if(!arg2)
1612   {
1613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1614     return;
1615   }
1616   {
1617     try
1618     {
1619       (arg1)->SetProperty(Actor::Property::POSITION, (Dali::Vector3 const&)*arg2);
1620     }
1621     CALL_CATCH_EXCEPTION();
1622   }
1623 }
1624
1625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void* jarg1, float jarg2)
1626 {
1627   Dali::Actor* arg1 = (Dali::Actor*)0;
1628   float        arg2;
1629
1630   if(!jarg1)
1631   {
1632     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1633     return;
1634   }
1635
1636   arg1 = (Dali::Actor*)jarg1;
1637   arg2 = (float)jarg2;
1638   {
1639     try
1640     {
1641       (arg1)->SetProperty(Actor::Property::POSITION_X, (arg2));
1642     }
1643     CALL_CATCH_EXCEPTION();
1644   }
1645 }
1646
1647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void* jarg1, float jarg2)
1648 {
1649   Dali::Actor* arg1 = (Dali::Actor*)0;
1650   float        arg2;
1651
1652   if(!jarg1)
1653   {
1654     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1655     return;
1656   }
1657
1658   arg1 = (Dali::Actor*)jarg1;
1659   arg2 = (float)jarg2;
1660   {
1661     try
1662     {
1663       (arg1)->SetProperty(Actor::Property::POSITION_Y, arg2);
1664     }
1665     CALL_CATCH_EXCEPTION();
1666   }
1667 }
1668
1669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void* jarg1, float jarg2)
1670 {
1671   Dali::Actor* arg1 = (Dali::Actor*)0;
1672   float        arg2;
1673
1674   if(!jarg1)
1675   {
1676     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1677     return;
1678   }
1679
1680   arg1 = (Dali::Actor*)jarg1;
1681   arg2 = (float)jarg2;
1682   {
1683     try
1684     {
1685       (arg1)->SetProperty(Actor::Property::POSITION_Z, arg2);
1686     }
1687     CALL_CATCH_EXCEPTION();
1688   }
1689 }
1690
1691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void* jarg1, void* jarg2)
1692 {
1693   Dali::Actor*   arg1 = (Dali::Actor*)0;
1694   Dali::Vector3* arg2 = 0;
1695
1696   if(!jarg1)
1697   {
1698     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1699     return;
1700   }
1701
1702   arg1 = (Dali::Actor*)jarg1;
1703   arg2 = (Dali::Vector3*)jarg2;
1704   if(!arg2)
1705   {
1706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1707     return;
1708   }
1709   {
1710     try
1711     {
1712       (arg1)->TranslateBy((Dali::Vector3 const&)*arg2);
1713     }
1714     CALL_CATCH_EXCEPTION();
1715   }
1716 }
1717
1718 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void* jarg1)
1719 {
1720   void*         jresult;
1721   Dali::Actor*  arg1 = (Dali::Actor*)0;
1722   Dali::Vector3 result;
1723
1724   if(!jarg1)
1725   {
1726     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1727     return 0;
1728   }
1729
1730   arg1 = (Dali::Actor*)jarg1;
1731   {
1732     try
1733     {
1734       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::POSITION);
1735     }
1736     CALL_CATCH_EXCEPTION(0);
1737   }
1738
1739   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1740   return jresult;
1741 }
1742
1743 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void* jarg1)
1744 {
1745   void*         jresult;
1746   Dali::Actor*  arg1 = (Dali::Actor*)0;
1747   Dali::Vector3 result;
1748
1749   if(!jarg1)
1750   {
1751     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1752     return 0;
1753   }
1754
1755   arg1 = (Dali::Actor*)jarg1;
1756   {
1757     try
1758     {
1759       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION);
1760     }
1761     CALL_CATCH_EXCEPTION(0);
1762   }
1763
1764   jresult = new Dali::Vector3((const Dali::Vector3&)result);
1765   return jresult;
1766 }
1767
1768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void* jarg1, bool jarg2)
1769 {
1770   Dali::Actor* arg1 = (Dali::Actor*)0;
1771   bool         arg2;
1772
1773   if(!jarg1)
1774   {
1775     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1776     return;
1777   }
1778
1779   arg1 = (Dali::Actor*)jarg1;
1780   arg2 = jarg2 ? true : false;
1781   {
1782     try
1783     {
1784       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
1785     }
1786     CALL_CATCH_EXCEPTION();
1787   }
1788 }
1789
1790 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void* jarg1)
1791 {
1792   bool         jresult;
1793   Dali::Actor* arg1 = (Dali::Actor*)0;
1794   bool         result;
1795
1796   if(!jarg1)
1797   {
1798     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1799     return 0;
1800   }
1801
1802   arg1 = (Dali::Actor*)jarg1;
1803   {
1804     try
1805     {
1806       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
1807     }
1808     CALL_CATCH_EXCEPTION(0);
1809   }
1810
1811   jresult = result;
1812   return jresult;
1813 }
1814
1815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void* jarg1, void* jarg2, void* jarg3)
1816 {
1817   Dali::Actor*   arg1 = (Dali::Actor*)0;
1818   Dali::Degree*  arg2 = 0;
1819   Dali::Vector3* arg3 = 0;
1820
1821   if(!jarg1)
1822   {
1823     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1824     return;
1825   }
1826
1827   arg1 = (Dali::Actor*)jarg1;
1828   arg2 = (Dali::Degree*)jarg2;
1829   if(!arg2)
1830   {
1831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
1832     return;
1833   }
1834   arg3 = (Dali::Vector3*)jarg3;
1835   if(!arg3)
1836   {
1837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1838     return;
1839   }
1840   {
1841     try
1842     {
1843       (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3));
1844     }
1845     CALL_CATCH_EXCEPTION();
1846   }
1847 }
1848
1849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void* jarg1, void* jarg2, void* jarg3)
1850 {
1851   Dali::Actor*   arg1 = (Dali::Actor*)0;
1852   Dali::Radian*  arg2 = 0;
1853   Dali::Vector3* arg3 = 0;
1854
1855   if(!jarg1)
1856   {
1857     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1858     return;
1859   }
1860
1861   arg1 = (Dali::Actor*)jarg1;
1862   arg2 = (Dali::Radian*)jarg2;
1863   if(!arg2)
1864   {
1865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
1866     return;
1867   }
1868   arg3 = (Dali::Vector3*)jarg3;
1869   if(!arg3)
1870   {
1871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1872     return;
1873   }
1874   {
1875     try
1876     {
1877       (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3));
1878     }
1879     CALL_CATCH_EXCEPTION();
1880   }
1881 }
1882
1883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void* jarg1, void* jarg2)
1884 {
1885   Dali::Actor*      arg1 = (Dali::Actor*)0;
1886   Dali::Quaternion* arg2 = 0;
1887
1888   if(!jarg1)
1889   {
1890     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1891     return;
1892   }
1893
1894   arg1 = (Dali::Actor*)jarg1;
1895   arg2 = (Dali::Quaternion*)jarg2;
1896   if(!arg2)
1897   {
1898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
1899     return;
1900   }
1901   {
1902     try
1903     {
1904       (arg1)->SetProperty(Actor::Property::ORIENTATION, (Dali::Quaternion const&)*arg2);
1905     }
1906     CALL_CATCH_EXCEPTION();
1907   }
1908 }
1909
1910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void* jarg1, void* jarg2, void* jarg3)
1911 {
1912   Dali::Actor*   arg1 = (Dali::Actor*)0;
1913   Dali::Degree*  arg2 = 0;
1914   Dali::Vector3* arg3 = 0;
1915
1916   if(!jarg1)
1917   {
1918     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1919     return;
1920   }
1921
1922   arg1 = (Dali::Actor*)jarg1;
1923   arg2 = (Dali::Degree*)jarg2;
1924   if(!arg2)
1925   {
1926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
1927     return;
1928   }
1929   arg3 = (Dali::Vector3*)jarg3;
1930   if(!arg3)
1931   {
1932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1933     return;
1934   }
1935   {
1936     try
1937     {
1938       (arg1)->RotateBy((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3);
1939     }
1940     CALL_CATCH_EXCEPTION();
1941   }
1942 }
1943
1944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void* jarg1, void* jarg2, void* jarg3)
1945 {
1946   Dali::Actor*   arg1 = (Dali::Actor*)0;
1947   Dali::Radian*  arg2 = 0;
1948   Dali::Vector3* arg3 = 0;
1949
1950   if(!jarg1)
1951   {
1952     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1953     return;
1954   }
1955
1956   arg1 = (Dali::Actor*)jarg1;
1957   arg2 = (Dali::Radian*)jarg2;
1958   if(!arg2)
1959   {
1960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
1961     return;
1962   }
1963   arg3 = (Dali::Vector3*)jarg3;
1964   if(!arg3)
1965   {
1966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1967     return;
1968   }
1969   {
1970     try
1971     {
1972       (arg1)->RotateBy((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3);
1973     }
1974     CALL_CATCH_EXCEPTION();
1975   }
1976 }
1977
1978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void* jarg1, void* jarg2)
1979 {
1980   Dali::Actor*      arg1 = (Dali::Actor*)0;
1981   Dali::Quaternion* arg2 = 0;
1982
1983   if(!jarg1)
1984   {
1985     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
1986     return;
1987   }
1988
1989   arg1 = (Dali::Actor*)jarg1;
1990   arg2 = (Dali::Quaternion*)jarg2;
1991   if(!arg2)
1992   {
1993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
1994     return;
1995   }
1996   {
1997     try
1998     {
1999       (arg1)->RotateBy((Dali::Quaternion const&)*arg2);
2000     }
2001     CALL_CATCH_EXCEPTION();
2002   }
2003 }
2004
2005 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void* jarg1)
2006 {
2007   void*            jresult;
2008   Dali::Actor*     arg1 = (Dali::Actor*)0;
2009   Dali::Quaternion result;
2010
2011   if(!jarg1)
2012   {
2013     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2014     return 0;
2015   }
2016
2017   arg1 = (Dali::Actor*)jarg1;
2018   {
2019     try
2020     {
2021       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION);
2022     }
2023     CALL_CATCH_EXCEPTION(0);
2024   }
2025
2026   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
2027   return jresult;
2028 }
2029
2030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void* jarg1, bool jarg2)
2031 {
2032   Dali::Actor* arg1 = (Dali::Actor*)0;
2033   bool         arg2;
2034
2035   if(!jarg1)
2036   {
2037     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2038     return;
2039   }
2040
2041   arg1 = (Dali::Actor*)jarg1;
2042   arg2 = jarg2 ? true : false;
2043   {
2044     try
2045     {
2046       (arg1)->SetProperty(Actor::Property::INHERIT_ORIENTATION, arg2);
2047     }
2048     CALL_CATCH_EXCEPTION();
2049   }
2050 }
2051
2052 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void* jarg1)
2053 {
2054   bool         jresult;
2055   Dali::Actor* arg1 = (Dali::Actor*)0;
2056   bool         result;
2057
2058   if(!jarg1)
2059   {
2060     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2061     return 0;
2062   }
2063
2064   arg1 = (Dali::Actor*)jarg1;
2065   {
2066     try
2067     {
2068       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::INHERIT_ORIENTATION);
2069     }
2070     CALL_CATCH_EXCEPTION(0);
2071   }
2072
2073   jresult = result;
2074   return jresult;
2075 }
2076
2077 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void* jarg1)
2078 {
2079   void*            jresult;
2080   Dali::Actor*     arg1 = (Dali::Actor*)0;
2081   Dali::Quaternion result;
2082
2083   if(!jarg1)
2084   {
2085     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2086     return 0;
2087   }
2088
2089   arg1 = (Dali::Actor*)jarg1;
2090   {
2091     try
2092     {
2093       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION);
2094     }
2095     CALL_CATCH_EXCEPTION(0);
2096   }
2097
2098   jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
2099   return jresult;
2100 }
2101
2102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void* jarg1, float jarg2)
2103 {
2104   Dali::Actor* arg1 = (Dali::Actor*)0;
2105   float        arg2;
2106
2107   if(!jarg1)
2108   {
2109     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2110     return;
2111   }
2112
2113   arg1 = (Dali::Actor*)jarg1;
2114   arg2 = (float)jarg2;
2115   {
2116     try
2117     {
2118       (arg1)->SetProperty(Actor::Property::SCALE, arg2);
2119     }
2120     CALL_CATCH_EXCEPTION();
2121   }
2122 }
2123
2124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
2125 {
2126   Dali::Actor* arg1 = (Dali::Actor*)0;
2127   float        arg2;
2128   float        arg3;
2129   float        arg4;
2130
2131   if(!jarg1)
2132   {
2133     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2134     return;
2135   }
2136
2137   arg1 = (Dali::Actor*)jarg1;
2138   arg2 = (float)jarg2;
2139   arg3 = (float)jarg3;
2140   arg4 = (float)jarg4;
2141   {
2142     try
2143     {
2144       (arg1)->SetProperty(Actor::Property::SCALE, Vector3(arg2, arg3, arg4));
2145     }
2146     CALL_CATCH_EXCEPTION();
2147   }
2148 }
2149
2150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void* jarg1, void* jarg2)
2151 {
2152   Dali::Actor*   arg1 = (Dali::Actor*)0;
2153   Dali::Vector3* arg2 = 0;
2154
2155   if(!jarg1)
2156   {
2157     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2158     return;
2159   }
2160
2161   arg1 = (Dali::Actor*)jarg1;
2162   arg2 = (Dali::Vector3*)jarg2;
2163   if(!arg2)
2164   {
2165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
2166     return;
2167   }
2168   {
2169     try
2170     {
2171       (arg1)->SetProperty(Actor::Property::SCALE, (Dali::Vector3 const&)*arg2);
2172     }
2173     CALL_CATCH_EXCEPTION();
2174   }
2175 }
2176
2177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void* jarg1, void* jarg2)
2178 {
2179   Dali::Actor*   arg1 = (Dali::Actor*)0;
2180   Dali::Vector3* arg2 = 0;
2181
2182   if(!jarg1)
2183   {
2184     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2185     return;
2186   }
2187
2188   arg1 = (Dali::Actor*)jarg1;
2189   arg2 = (Dali::Vector3*)jarg2;
2190   if(!arg2)
2191   {
2192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
2193     return;
2194   }
2195   {
2196     try
2197     {
2198       (arg1)->ScaleBy((Dali::Vector3 const&)*arg2);
2199     }
2200     CALL_CATCH_EXCEPTION();
2201   }
2202 }
2203
2204 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void* jarg1)
2205 {
2206   void*         jresult;
2207   Dali::Actor*  arg1 = (Dali::Actor*)0;
2208   Dali::Vector3 result;
2209
2210   if(!jarg1)
2211   {
2212     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2213     return 0;
2214   }
2215
2216   arg1 = (Dali::Actor*)jarg1;
2217   {
2218     try
2219     {
2220       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::SCALE);
2221     }
2222     CALL_CATCH_EXCEPTION(0);
2223   }
2224
2225   jresult = new Dali::Vector3((const Dali::Vector3&)result);
2226   return jresult;
2227 }
2228
2229 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void* jarg1)
2230 {
2231   void*         jresult;
2232   Dali::Actor*  arg1 = (Dali::Actor*)0;
2233   Dali::Vector3 result;
2234
2235   if(!jarg1)
2236   {
2237     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2238     return 0;
2239   }
2240
2241   arg1 = (Dali::Actor*)jarg1;
2242   {
2243     try
2244     {
2245       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE);
2246     }
2247     CALL_CATCH_EXCEPTION(0);
2248   }
2249
2250   jresult = new Dali::Vector3((const Dali::Vector3&)result);
2251   return jresult;
2252 }
2253
2254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void* jarg1, bool jarg2)
2255 {
2256   Dali::Actor* arg1 = (Dali::Actor*)0;
2257   bool         arg2;
2258
2259   if(!jarg1)
2260   {
2261     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2262     return;
2263   }
2264
2265   arg1 = (Dali::Actor*)jarg1;
2266   arg2 = jarg2 ? true : false;
2267   {
2268     try
2269     {
2270       (arg1)->SetProperty(Actor::Property::INHERIT_SCALE, arg2);
2271     }
2272     CALL_CATCH_EXCEPTION();
2273   }
2274 }
2275
2276 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void* jarg1)
2277 {
2278   bool         jresult;
2279   Dali::Actor* arg1 = (Dali::Actor*)0;
2280   bool         result;
2281
2282   if(!jarg1)
2283   {
2284     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2285     return 0;
2286   }
2287
2288   arg1 = (Dali::Actor*)jarg1;
2289   {
2290     try
2291     {
2292       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::INHERIT_SCALE);
2293     }
2294     CALL_CATCH_EXCEPTION(0);
2295   }
2296
2297   jresult = result;
2298   return jresult;
2299 }
2300
2301 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void* jarg1)
2302 {
2303   void*        jresult;
2304   Dali::Actor* arg1 = (Dali::Actor*)0;
2305   Dali::Matrix result;
2306
2307   if(!jarg1)
2308   {
2309     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2310     return 0;
2311   }
2312
2313   arg1 = (Dali::Actor*)jarg1;
2314   {
2315     try
2316     {
2317       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
2318     }
2319     CALL_CATCH_EXCEPTION(0);
2320   }
2321
2322   jresult = new Dali::Matrix((const Dali::Matrix&)result);
2323   return jresult;
2324 }
2325
2326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void* jarg1)
2327 {
2328   Dali::Actor  arg1;
2329   Dali::Actor* argp1;
2330
2331   argp1 = (Dali::Actor*)jarg1;
2332   if(!argp1)
2333   {
2334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2335     return;
2336   }
2337   arg1 = *argp1;
2338   {
2339     try
2340     {
2341       arg1.Raise();
2342     }
2343     CALL_CATCH_EXCEPTION();
2344   }
2345 }
2346
2347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void* jarg1)
2348 {
2349   Dali::Actor  arg1;
2350   Dali::Actor* argp1;
2351
2352   argp1 = (Dali::Actor*)jarg1;
2353   if(!argp1)
2354   {
2355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2356     return;
2357   }
2358   arg1 = *argp1;
2359   {
2360     try
2361     {
2362       arg1.Lower();
2363     }
2364     CALL_CATCH_EXCEPTION();
2365   }
2366 }
2367
2368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void* jarg1)
2369 {
2370   Dali::Actor  arg1;
2371   Dali::Actor* argp1;
2372
2373   argp1 = (Dali::Actor*)jarg1;
2374   if(!argp1)
2375   {
2376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2377     return;
2378   }
2379   arg1 = *argp1;
2380   {
2381     try
2382     {
2383       arg1.RaiseToTop();
2384     }
2385     CALL_CATCH_EXCEPTION();
2386   }
2387 }
2388
2389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void* jarg1)
2390 {
2391   Dali::Actor  arg1;
2392   Dali::Actor* argp1;
2393
2394   argp1 = (Dali::Actor*)jarg1;
2395   if(!argp1)
2396   {
2397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2398     return;
2399   }
2400   arg1 = *argp1;
2401   {
2402     try
2403     {
2404       arg1.LowerToBottom();
2405     }
2406     CALL_CATCH_EXCEPTION();
2407   }
2408 }
2409
2410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void* jarg1, void* jarg2)
2411 {
2412   Dali::Actor  arg1;
2413   Dali::Actor  arg2;
2414   Dali::Actor* argp1;
2415   Dali::Actor* argp2;
2416
2417   argp1 = (Dali::Actor*)jarg1;
2418   if(!argp1)
2419   {
2420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2421     return;
2422   }
2423   arg1  = *argp1;
2424   argp2 = (Dali::Actor*)jarg2;
2425   if(!argp2)
2426   {
2427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2428     return;
2429   }
2430   arg2 = *argp2;
2431   {
2432     try
2433     {
2434       arg1.RaiseAbove(arg2);
2435     }
2436     CALL_CATCH_EXCEPTION();
2437   }
2438 }
2439
2440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void* jarg1, void* jarg2)
2441 {
2442   Dali::Actor  arg1;
2443   Dali::Actor  arg2;
2444   Dali::Actor* argp1;
2445   Dali::Actor* argp2;
2446
2447   argp1 = (Dali::Actor*)jarg1;
2448   if(!argp1)
2449   {
2450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2451     return;
2452   }
2453   arg1  = *argp1;
2454   argp2 = (Dali::Actor*)jarg2;
2455   if(!argp2)
2456   {
2457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2458     return;
2459   }
2460   arg2 = *argp2;
2461   {
2462     try
2463     {
2464       arg1.LowerBelow(arg2);
2465     }
2466     CALL_CATCH_EXCEPTION();
2467   }
2468 }
2469
2470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void* jarg1, bool jarg2)
2471 {
2472   Dali::Actor* arg1 = (Dali::Actor*)0;
2473   bool         arg2;
2474
2475   if(!jarg1)
2476   {
2477     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2478     return;
2479   }
2480
2481   arg1 = (Dali::Actor*)jarg1;
2482   arg2 = jarg2 ? true : false;
2483   {
2484     try
2485     {
2486       (arg1)->SetProperty(Actor::Property::VISIBLE, arg2);
2487     }
2488     CALL_CATCH_EXCEPTION();
2489   }
2490 }
2491
2492 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void* jarg1)
2493 {
2494   bool         jresult;
2495   Dali::Actor* arg1 = (Dali::Actor*)0;
2496   bool         result;
2497
2498   if(!jarg1)
2499   {
2500     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2501     return 0;
2502   }
2503
2504   arg1 = (Dali::Actor*)jarg1;
2505   {
2506     try
2507     {
2508       result = (bool)((Dali::Actor const*)arg1)->GetCurrentProperty<bool>(Actor::Property::VISIBLE);
2509     }
2510     CALL_CATCH_EXCEPTION(0);
2511   }
2512
2513   jresult = result;
2514   return jresult;
2515 }
2516
2517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void* jarg1, float jarg2)
2518 {
2519   Dali::Actor* arg1 = (Dali::Actor*)0;
2520   float        arg2;
2521
2522   if(!jarg1)
2523   {
2524     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2525     return;
2526   }
2527
2528   arg1 = (Dali::Actor*)jarg1;
2529   arg2 = (float)jarg2;
2530   {
2531     try
2532     {
2533       (arg1)->SetProperty(Actor::Property::OPACITY, arg2);
2534     }
2535     CALL_CATCH_EXCEPTION();
2536   }
2537 }
2538
2539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void* jarg1)
2540 {
2541   float        jresult;
2542   Dali::Actor* arg1 = (Dali::Actor*)0;
2543   float        result;
2544
2545   if(!jarg1)
2546   {
2547     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2548     return 0;
2549   }
2550
2551   arg1 = (Dali::Actor*)jarg1;
2552   {
2553     try
2554     {
2555       result = (float)((Dali::Actor const*)arg1)->GetCurrentProperty<float>(Actor::Property::OPACITY);
2556     }
2557     CALL_CATCH_EXCEPTION(0);
2558   }
2559
2560   jresult = result;
2561   return jresult;
2562 }
2563
2564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void* jarg1, void* jarg2)
2565 {
2566   Dali::Actor*   arg1 = (Dali::Actor*)0;
2567   Dali::Vector4* arg2 = 0;
2568
2569   if(!jarg1)
2570   {
2571     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2572     return;
2573   }
2574
2575   arg1 = (Dali::Actor*)jarg1;
2576   arg2 = (Dali::Vector4*)jarg2;
2577   if(!arg2)
2578   {
2579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
2580     return;
2581   }
2582   {
2583     try
2584     {
2585       (arg1)->SetProperty(Actor::Property::COLOR, (Dali::Vector4 const&)*arg2);
2586     }
2587     CALL_CATCH_EXCEPTION();
2588   }
2589 }
2590
2591 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void* jarg1)
2592 {
2593   void*         jresult;
2594   Dali::Actor*  arg1 = (Dali::Actor*)0;
2595   Dali::Vector4 result;
2596
2597   if(!jarg1)
2598   {
2599     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2600     return 0;
2601   }
2602
2603   arg1 = (Dali::Actor*)jarg1;
2604   {
2605     try
2606     {
2607       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector4>(Actor::Property::COLOR);
2608     }
2609     CALL_CATCH_EXCEPTION(0);
2610   }
2611
2612   jresult = new Dali::Vector4((const Dali::Vector4&)result);
2613   return jresult;
2614 }
2615
2616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void* jarg1, int jarg2)
2617 {
2618   Dali::Actor*    arg1 = (Dali::Actor*)0;
2619   Dali::ColorMode arg2;
2620
2621   if(!jarg1)
2622   {
2623     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2624     return;
2625   }
2626
2627   arg1 = (Dali::Actor*)jarg1;
2628   arg2 = (Dali::ColorMode)jarg2;
2629   {
2630     try
2631     {
2632       (arg1)->SetProperty(Actor::Property::COLOR_MODE, arg2);
2633     }
2634     CALL_CATCH_EXCEPTION();
2635   }
2636 }
2637
2638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void* jarg1)
2639 {
2640   int             jresult;
2641   Dali::Actor*    arg1 = (Dali::Actor*)0;
2642   Dali::ColorMode result;
2643
2644   if(!jarg1)
2645   {
2646     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2647     return 0;
2648   }
2649
2650   arg1 = (Dali::Actor*)jarg1;
2651   {
2652     try
2653     {
2654       result = (Dali::ColorMode)((Dali::Actor const*)arg1)->GetProperty<ColorMode>(Actor::Property::COLOR_MODE);
2655     }
2656     CALL_CATCH_EXCEPTION(0);
2657   }
2658
2659   jresult = (int)result;
2660   return jresult;
2661 }
2662
2663 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void* jarg1)
2664 {
2665   void*         jresult;
2666   Dali::Actor*  arg1 = (Dali::Actor*)0;
2667   Dali::Vector4 result;
2668
2669   if(!jarg1)
2670   {
2671     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2672     return 0;
2673   }
2674
2675   arg1 = (Dali::Actor*)jarg1;
2676   {
2677     try
2678     {
2679       result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR);
2680     }
2681     CALL_CATCH_EXCEPTION(0);
2682   }
2683
2684   jresult = new Dali::Vector4((const Dali::Vector4&)result);
2685   return jresult;
2686 }
2687
2688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void* jarg1, int jarg2)
2689 {
2690   Dali::Actor*         arg1 = (Dali::Actor*)0;
2691   Dali::DrawMode::Type arg2;
2692
2693   if(!jarg1)
2694   {
2695     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2696     return;
2697   }
2698
2699   arg1 = (Dali::Actor*)jarg1;
2700   arg2 = (Dali::DrawMode::Type)jarg2;
2701   {
2702     try
2703     {
2704       (arg1)->SetProperty(Actor::Property::DRAW_MODE, arg2);
2705     }
2706     CALL_CATCH_EXCEPTION();
2707   }
2708 }
2709
2710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void* jarg1)
2711 {
2712   int                  jresult;
2713   Dali::Actor*         arg1 = (Dali::Actor*)0;
2714   Dali::DrawMode::Type result;
2715
2716   if(!jarg1)
2717   {
2718     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2719     return 0;
2720   }
2721
2722   arg1 = (Dali::Actor*)jarg1;
2723   {
2724     try
2725     {
2726       result = (Dali::DrawMode::Type)((Dali::Actor const*)arg1)->GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE);
2727     }
2728     CALL_CATCH_EXCEPTION(0);
2729   }
2730
2731   jresult = (int)result;
2732   return jresult;
2733 }
2734
2735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void* jarg1, bool jarg2)
2736 {
2737   Dali::Actor* arg1 = (Dali::Actor*)0;
2738   bool         arg2;
2739
2740   if(!jarg1)
2741   {
2742     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2743     return;
2744   }
2745
2746   arg1 = (Dali::Actor*)jarg1;
2747   arg2 = jarg2 ? true : false;
2748   {
2749     try
2750     {
2751       (arg1)->SetProperty(Actor::Property::SENSITIVE, arg2);
2752     }
2753     CALL_CATCH_EXCEPTION();
2754   }
2755 }
2756
2757 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void* jarg1)
2758 {
2759   bool         jresult;
2760   Dali::Actor* arg1 = (Dali::Actor*)0;
2761   bool         result;
2762
2763   if(!jarg1)
2764   {
2765     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2766     return 0;
2767   }
2768
2769   arg1 = (Dali::Actor*)jarg1;
2770   {
2771     try
2772     {
2773       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::SENSITIVE);
2774     }
2775     CALL_CATCH_EXCEPTION(0);
2776   }
2777
2778   jresult = result;
2779   return jresult;
2780 }
2781
2782 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void* jarg1, float* jarg2, float* jarg3, float jarg4, float jarg5)
2783 {
2784   bool         jresult;
2785   Dali::Actor* arg1 = (Dali::Actor*)0;
2786   float*       arg2 = 0;
2787   float*       arg3 = 0;
2788   float        arg4;
2789   float        arg5;
2790   bool         result;
2791
2792   if(!jarg1)
2793   {
2794     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2795     return 0;
2796   }
2797
2798   arg1 = (Dali::Actor*)jarg1;
2799   arg2 = (float*)jarg2;
2800   arg3 = (float*)jarg3;
2801   arg4 = (float)jarg4;
2802   arg5 = (float)jarg5;
2803   {
2804     try
2805     {
2806       result = (bool)((Dali::Actor const*)arg1)->ScreenToLocal(*arg2, *arg3, arg4, arg5);
2807     }
2808     CALL_CATCH_EXCEPTION(0);
2809   }
2810
2811   jresult = result;
2812   return jresult;
2813 }
2814
2815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void* jarg1, bool jarg2)
2816 {
2817   Dali::Actor* arg1 = (Dali::Actor*)0;
2818   bool         arg2;
2819
2820   if(!jarg1)
2821   {
2822     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2823     return;
2824   }
2825
2826   arg1 = (Dali::Actor*)jarg1;
2827   arg2 = jarg2 ? true : false;
2828   {
2829     try
2830     {
2831       (arg1)->SetProperty(Actor::Property::LEAVE_REQUIRED, arg2);
2832     }
2833     CALL_CATCH_EXCEPTION();
2834   }
2835 }
2836
2837 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void* jarg1)
2838 {
2839   bool         jresult;
2840   Dali::Actor* arg1 = (Dali::Actor*)0;
2841   bool         result;
2842
2843   if(!jarg1)
2844   {
2845     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2846     return 0;
2847   }
2848
2849   arg1 = (Dali::Actor*)jarg1;
2850   {
2851     try
2852     {
2853       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::LEAVE_REQUIRED);
2854     }
2855     CALL_CATCH_EXCEPTION(0);
2856   }
2857
2858   jresult = result;
2859   return jresult;
2860 }
2861
2862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void* jarg1, bool jarg2)
2863 {
2864   Dali::Actor* arg1 = (Dali::Actor*)0;
2865   bool         arg2;
2866
2867   if(!jarg1)
2868   {
2869     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2870     return;
2871   }
2872
2873   arg1 = (Dali::Actor*)jarg1;
2874   arg2 = jarg2 ? true : false;
2875   {
2876     try
2877     {
2878       (arg1)->SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, arg2);
2879     }
2880     CALL_CATCH_EXCEPTION();
2881   }
2882 }
2883
2884 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void* jarg1)
2885 {
2886   bool         jresult;
2887   Dali::Actor* arg1 = (Dali::Actor*)0;
2888   bool         result;
2889
2890   if(!jarg1)
2891   {
2892     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2893     return 0;
2894   }
2895
2896   arg1 = (Dali::Actor*)jarg1;
2897   {
2898     try
2899     {
2900       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE);
2901     }
2902     CALL_CATCH_EXCEPTION(0);
2903   }
2904
2905   jresult = result;
2906   return jresult;
2907 }
2908
2909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void* actor, bool keyboardFocusableChildren)
2910 {
2911   Dali::Actor* arg1 = (Dali::Actor*)0;
2912
2913   if(!actor)
2914   {
2915     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
2916     return;
2917   }
2918
2919   arg1 = (Dali::Actor*)actor;
2920   {
2921     try
2922     {
2923       (arg1)->SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren);
2924     }
2925     CALL_CATCH_EXCEPTION();
2926   }
2927 }
2928
2929 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void* actor)
2930 {
2931   Dali::Actor* arg1 = (Dali::Actor*)0;
2932   bool         result;
2933
2934   if(!actor)
2935   {
2936     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
2937     return 0;
2938   }
2939
2940   arg1 = (Dali::Actor*)actor;
2941   {
2942     try
2943     {
2944       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN);
2945     }
2946     CALL_CATCH_EXCEPTION(0);
2947   }
2948   return result;
2949 }
2950
2951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void* jarg1, bool jarg2)
2952 {
2953   Dali::Actor* arg1 = (Dali::Actor*)0;
2954   bool         arg2;
2955
2956   if(!jarg1)
2957   {
2958     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2959     return;
2960   }
2961
2962   arg1 = (Dali::Actor*)jarg1;
2963   arg2 = jarg2 ? true : false;
2964   {
2965     try
2966     {
2967       (arg1)->SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, arg2);
2968     }
2969     CALL_CATCH_EXCEPTION();
2970   }
2971 }
2972
2973 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void* jarg1)
2974 {
2975   bool         jresult;
2976   Dali::Actor* arg1 = (Dali::Actor*)0;
2977   bool         result;
2978
2979   if(!jarg1)
2980   {
2981     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
2982     return 0;
2983   }
2984
2985   arg1 = (Dali::Actor*)jarg1;
2986   {
2987     try
2988     {
2989       result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(DevelActor::Property::TOUCH_FOCUSABLE);
2990     }
2991     CALL_CATCH_EXCEPTION(0);
2992   }
2993
2994   jresult = result;
2995   return jresult;
2996 }
2997
2998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void* jarg1, int jarg2, int jarg3)
2999 {
3000   Dali::Actor*             arg1 = (Dali::Actor*)0;
3001   Dali::ResizePolicy::Type arg2;
3002   Dali::Dimension::Type    arg3;
3003
3004   if(!jarg1)
3005   {
3006     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3007     return;
3008   }
3009
3010   arg1 = (Dali::Actor*)jarg1;
3011   arg2 = (Dali::ResizePolicy::Type)jarg2;
3012   arg3 = (Dali::Dimension::Type)jarg3;
3013   {
3014     try
3015     {
3016       (arg1)->SetResizePolicy(arg2, arg3);
3017     }
3018     CALL_CATCH_EXCEPTION();
3019   }
3020 }
3021
3022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void* jarg1, int jarg2)
3023 {
3024   int                      jresult;
3025   Dali::Actor*             arg1 = (Dali::Actor*)0;
3026   Dali::Dimension::Type    arg2;
3027   Dali::ResizePolicy::Type result;
3028
3029   if(!jarg1)
3030   {
3031     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3032     return 0;
3033   }
3034
3035   arg1 = (Dali::Actor*)jarg1;
3036   arg2 = (Dali::Dimension::Type)jarg2;
3037   {
3038     try
3039     {
3040       result = (Dali::ResizePolicy::Type)((Dali::Actor const*)arg1)->GetResizePolicy(arg2);
3041     }
3042     CALL_CATCH_EXCEPTION(0);
3043   }
3044
3045   jresult = (int)result;
3046   return jresult;
3047 }
3048
3049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void* jarg1, int jarg2)
3050 {
3051   Dali::Actor*                arg1 = (Dali::Actor*)0;
3052   Dali::SizeScalePolicy::Type arg2;
3053
3054   if(!jarg1)
3055   {
3056     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3057     return;
3058   }
3059
3060   arg1 = (Dali::Actor*)jarg1;
3061   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
3062   {
3063     try
3064     {
3065       (arg1)->SetProperty(Actor::Property::SIZE_SCALE_POLICY, arg2);
3066     }
3067     CALL_CATCH_EXCEPTION();
3068   }
3069 }
3070
3071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void* jarg1)
3072 {
3073   int                         jresult;
3074   Dali::Actor*                arg1 = (Dali::Actor*)0;
3075   Dali::SizeScalePolicy::Type result;
3076
3077   if(!jarg1)
3078   {
3079     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3080     return 0;
3081   }
3082
3083   arg1 = (Dali::Actor*)jarg1;
3084   {
3085     try
3086     {
3087       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const*)arg1)->GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY);
3088     }
3089     CALL_CATCH_EXCEPTION(0);
3090   }
3091
3092   jresult = (int)result;
3093   return jresult;
3094 }
3095
3096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void* jarg1, void* jarg2)
3097 {
3098   Dali::Actor*   arg1 = (Dali::Actor*)0;
3099   Dali::Vector3* arg2 = 0;
3100
3101   if(!jarg1)
3102   {
3103     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3104     return;
3105   }
3106
3107   arg1 = (Dali::Actor*)jarg1;
3108   arg2 = (Dali::Vector3*)jarg2;
3109   if(!arg2)
3110   {
3111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3112     return;
3113   }
3114   {
3115     try
3116     {
3117       (arg1)->SetProperty(Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const&)*arg2);
3118     }
3119     CALL_CATCH_EXCEPTION();
3120   }
3121 }
3122
3123 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void* jarg1)
3124 {
3125   void*         jresult;
3126   Dali::Actor*  arg1 = (Dali::Actor*)0;
3127   Dali::Vector3 result;
3128
3129   if(!jarg1)
3130   {
3131     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3132     return 0;
3133   }
3134
3135   arg1 = (Dali::Actor*)jarg1;
3136   {
3137     try
3138     {
3139       result = ((Dali::Actor const*)arg1)->GetProperty<Vector3>(Actor::Property::SIZE_MODE_FACTOR);
3140     }
3141     CALL_CATCH_EXCEPTION(0);
3142   }
3143
3144   jresult = new Dali::Vector3((const Dali::Vector3&)result);
3145   return jresult;
3146 }
3147
3148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void* jarg1, float jarg2)
3149 {
3150   float        jresult;
3151   Dali::Actor* arg1 = (Dali::Actor*)0;
3152   float        arg2;
3153   float        result;
3154
3155   if(!jarg1)
3156   {
3157     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3158     return 0;
3159   }
3160
3161   arg1 = (Dali::Actor*)jarg1;
3162   arg2 = (float)jarg2;
3163   {
3164     try
3165     {
3166       result = (float)(arg1)->GetHeightForWidth(arg2);
3167     }
3168     CALL_CATCH_EXCEPTION(0);
3169   }
3170
3171   jresult = result;
3172   return jresult;
3173 }
3174
3175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void* jarg1, float jarg2)
3176 {
3177   float        jresult;
3178   Dali::Actor* arg1 = (Dali::Actor*)0;
3179   float        arg2;
3180   float        result;
3181
3182   if(!jarg1)
3183   {
3184     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3185     return 0;
3186   }
3187
3188   arg1 = (Dali::Actor*)jarg1;
3189   arg2 = (float)jarg2;
3190   {
3191     try
3192     {
3193       result = (float)(arg1)->GetWidthForHeight(arg2);
3194     }
3195     CALL_CATCH_EXCEPTION(0);
3196   }
3197
3198   jresult = result;
3199   return jresult;
3200 }
3201
3202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void* jarg1, int jarg2)
3203 {
3204   float                 jresult;
3205   Dali::Actor*          arg1 = (Dali::Actor*)0;
3206   Dali::Dimension::Type arg2;
3207   float                 result;
3208
3209   if(!jarg1)
3210   {
3211     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3212     return 0;
3213   }
3214
3215   arg1 = (Dali::Actor*)jarg1;
3216   arg2 = (Dali::Dimension::Type)jarg2;
3217   {
3218     try
3219     {
3220       result = (float)((Dali::Actor const*)arg1)->GetRelayoutSize(arg2);
3221     }
3222     CALL_CATCH_EXCEPTION(0);
3223   }
3224
3225   jresult = result;
3226   return jresult;
3227 }
3228
3229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void* jarg1, void* jarg2)
3230 {
3231   Dali::Actor*   arg1 = (Dali::Actor*)0;
3232   Dali::Padding* arg2 = 0;
3233
3234   if(!jarg1)
3235   {
3236     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3237     return;
3238   }
3239
3240   arg1 = (Dali::Actor*)jarg1;
3241   arg2 = (Dali::Padding*)jarg2;
3242   if(!arg2)
3243   {
3244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
3245     return;
3246   }
3247   {
3248     try
3249     {
3250       (arg1)->SetProperty(Actor::Property::PADDING, (Dali::Padding const&)*arg2);
3251     }
3252     CALL_CATCH_EXCEPTION();
3253   }
3254 }
3255
3256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void* jarg1, void* jarg2)
3257 {
3258   Dali::Actor*   arg1 = (Dali::Actor*)0;
3259   Dali::Padding* arg2 = 0;
3260
3261   if(!jarg1)
3262   {
3263     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3264     return;
3265   }
3266
3267   arg1 = (Dali::Actor*)jarg1;
3268   arg2 = (Dali::Padding*)jarg2;
3269   if(!arg2)
3270   {
3271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
3272     return;
3273   }
3274   {
3275     try
3276     {
3277       *arg2 = ((Dali::Actor const*)arg1)->GetProperty<Vector4>(Actor::Property::PADDING);
3278     }
3279     CALL_CATCH_EXCEPTION();
3280   }
3281 }
3282
3283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void* jarg1, void* jarg2)
3284 {
3285   Dali::Actor*   arg1 = (Dali::Actor*)0;
3286   Dali::Vector2* arg2 = 0;
3287
3288   if(!jarg1)
3289   {
3290     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3291     return;
3292   }
3293
3294   arg1 = (Dali::Actor*)jarg1;
3295   arg2 = (Dali::Vector2*)jarg2;
3296   if(!arg2)
3297   {
3298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3299     return;
3300   }
3301   {
3302     try
3303     {
3304       (arg1)->SetProperty(Actor::Property::MINIMUM_SIZE, (Dali::Vector2 const&)*arg2);
3305     }
3306     CALL_CATCH_EXCEPTION();
3307   }
3308 }
3309
3310 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void* jarg1)
3311 {
3312   void*         jresult;
3313   Dali::Actor*  arg1 = (Dali::Actor*)0;
3314   Dali::Vector2 result;
3315
3316   if(!jarg1)
3317   {
3318     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3319     return 0;
3320   }
3321
3322   arg1 = (Dali::Actor*)jarg1;
3323   {
3324     try
3325     {
3326       result = (arg1)->GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
3327     }
3328     CALL_CATCH_EXCEPTION(0);
3329   }
3330
3331   jresult = new Dali::Vector2((const Dali::Vector2&)result);
3332   return jresult;
3333 }
3334
3335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void* jarg1, void* jarg2)
3336 {
3337   Dali::Actor*   arg1 = (Dali::Actor*)0;
3338   Dali::Vector2* arg2 = 0;
3339
3340   if(!jarg1)
3341   {
3342     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3343     return;
3344   }
3345
3346   arg1 = (Dali::Actor*)jarg1;
3347   arg2 = (Dali::Vector2*)jarg2;
3348   if(!arg2)
3349   {
3350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3351     return;
3352   }
3353   {
3354     try
3355     {
3356       (arg1)->SetProperty(Actor::Property::MAXIMUM_SIZE, (Dali::Vector2 const&)*arg2);
3357     }
3358     CALL_CATCH_EXCEPTION();
3359   }
3360 }
3361
3362 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void* jarg1)
3363 {
3364   void*         jresult;
3365   Dali::Actor*  arg1 = (Dali::Actor*)0;
3366   Dali::Vector2 result;
3367
3368   if(!jarg1)
3369   {
3370     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3371     return 0;
3372   }
3373
3374   arg1 = (Dali::Actor*)jarg1;
3375   {
3376     try
3377     {
3378       result = (arg1)->GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
3379     }
3380     CALL_CATCH_EXCEPTION(0);
3381   }
3382
3383   jresult = new Dali::Vector2((const Dali::Vector2&)result);
3384   return jresult;
3385 }
3386
3387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void* jarg1)
3388 {
3389   int          jresult;
3390   Dali::Actor* arg1 = (Dali::Actor*)0;
3391   int          result;
3392
3393   if(!jarg1)
3394   {
3395     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3396     return 0;
3397   }
3398
3399   arg1 = (Dali::Actor*)jarg1;
3400   {
3401     try
3402     {
3403       result             = (int)(arg1)->GetProperty<int>(Actor::Property::HIERARCHY_DEPTH);
3404       Dali::Actor parent = ((Dali::Actor const*)arg1)->GetParent();
3405     }
3406     CALL_CATCH_EXCEPTION(0);
3407   }
3408
3409   jresult = result;
3410   return jresult;
3411 }
3412
3413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void* jarg1, void* jarg2)
3414 {
3415   unsigned int    jresult;
3416   Dali::Actor*    arg1 = (Dali::Actor*)0;
3417   Dali::Renderer* arg2 = 0;
3418   unsigned int    result;
3419
3420   if(!jarg1)
3421   {
3422     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3423     return 0;
3424   }
3425
3426   arg1 = (Dali::Actor*)jarg1;
3427   arg2 = (Dali::Renderer*)jarg2;
3428   if(!arg2)
3429   {
3430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
3431     return 0;
3432   }
3433   {
3434     try
3435     {
3436       result = (unsigned int)(arg1)->AddRenderer(*arg2);
3437     }
3438     CALL_CATCH_EXCEPTION(0);
3439   }
3440
3441   jresult = result;
3442   return jresult;
3443 }
3444
3445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void* jarg1)
3446 {
3447   unsigned int jresult;
3448   Dali::Actor* arg1 = (Dali::Actor*)0;
3449   unsigned int result;
3450
3451   if(!jarg1)
3452   {
3453     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3454     return 0;
3455   }
3456
3457   arg1 = (Dali::Actor*)jarg1;
3458   {
3459     try
3460     {
3461       result = (unsigned int)((Dali::Actor const*)arg1)->GetRendererCount();
3462     }
3463     CALL_CATCH_EXCEPTION(0);
3464   }
3465
3466   jresult = result;
3467   return jresult;
3468 }
3469
3470 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void* jarg1, unsigned int jarg2)
3471 {
3472   void*          jresult;
3473   Dali::Actor*   arg1 = (Dali::Actor*)0;
3474   unsigned int   arg2;
3475   Dali::Renderer result;
3476
3477   if(!jarg1)
3478   {
3479     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3480     return 0;
3481   }
3482
3483   arg1 = (Dali::Actor*)jarg1;
3484   arg2 = (unsigned int)jarg2;
3485   {
3486     try
3487     {
3488       result = (arg1)->GetRendererAt(arg2);
3489     }
3490     CALL_CATCH_EXCEPTION(0);
3491   }
3492
3493   jresult = new Dali::Renderer((const Dali::Renderer&)result);
3494   return jresult;
3495 }
3496
3497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void* jarg1, void* jarg2)
3498 {
3499   Dali::Actor*    arg1 = (Dali::Actor*)0;
3500   Dali::Renderer* arg2 = 0;
3501
3502   if(!jarg1)
3503   {
3504     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3505     return;
3506   }
3507
3508   arg1 = (Dali::Actor*)jarg1;
3509   arg2 = (Dali::Renderer*)jarg2;
3510   if(!arg2)
3511   {
3512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
3513     return;
3514   }
3515   {
3516     try
3517     {
3518       (arg1)->RemoveRenderer(*arg2);
3519     }
3520     CALL_CATCH_EXCEPTION();
3521   }
3522 }
3523
3524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void* jarg1, unsigned int jarg2)
3525 {
3526   Dali::Actor* arg1 = (Dali::Actor*)0;
3527   unsigned int arg2;
3528
3529   if(!jarg1)
3530   {
3531     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
3532     return;
3533   }
3534
3535   arg1 = (Dali::Actor*)jarg1;
3536   arg2 = (unsigned int)jarg2;
3537   {
3538     try
3539     {
3540       (arg1)->RemoveRenderer(arg2);
3541     }
3542     CALL_CATCH_EXCEPTION();
3543   }
3544 }
3545
3546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void* jarg1, bool jarg2)
3547 {
3548   Dali::Actor  arg1;
3549   bool         arg2;
3550   Dali::Actor* argp1 = (Dali::Actor*)0;
3551
3552   argp1 = (Dali::Actor*)jarg1;
3553   if(!argp1)
3554   {
3555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3556     return;
3557   }
3558   arg1 = *argp1;
3559   arg2 = jarg2;
3560   {
3561     try
3562     {
3563       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
3564     }
3565     CALL_CATCH_EXCEPTION();
3566   }
3567   return;
3568 }
3569
3570 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenPosition(void* actor)
3571 {
3572   void*         jresult;
3573   Dali::Actor   arg1;
3574   Dali::Actor*  argp1 = (Dali::Actor*)0;
3575   Dali::Vector2 result;
3576
3577   argp1 = (Dali::Actor*)actor;
3578   if(!argp1)
3579   {
3580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3581     return 0;
3582   }
3583   arg1 = *argp1;
3584   {
3585     try
3586     {
3587       result = Dali::DevelActor::CalculateScreenPosition(arg1);
3588     }
3589     CALL_CATCH_EXCEPTION(0);
3590   }
3591
3592   jresult = new Dali::Vector2((const Dali::Vector2&)result);
3593   return jresult;
3594 }
3595
3596 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void* actor)
3597 {
3598   Dali::Actor       arg1;
3599   Dali::Actor*      argp1 = (Dali::Actor*)0;
3600   Dali::Rect<float> result;
3601
3602   argp1 = (Dali::Actor*)actor;
3603   if(!argp1)
3604   {
3605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3606     return 0;
3607   }
3608   arg1 = *argp1;
3609   {
3610     try
3611     {
3612       result = Dali::DevelActor::CalculateScreenExtents(arg1);
3613     }
3614     CALL_CATCH_EXCEPTION(0);
3615   }
3616
3617   // Note: The float type Rectangle class is not ready yet.
3618   //      Therefore, it transmits data in Vector4 class.
3619   //      This type should later be changed to the appropriate data type.
3620   return new Dali::Vector4(result.x, result.y, result.width, result.height);
3621 }
3622
3623 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CurrentScreenExtents(void* actor)
3624 {
3625   Dali::Actor       arg1;
3626   Dali::Actor*      argp1 = (Dali::Actor*)0;
3627   Dali::Rect<float> result;
3628
3629   argp1 = (Dali::Actor*)actor;
3630   if(!argp1)
3631   {
3632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3633     return 0;
3634   }
3635   arg1 = *argp1;
3636   {
3637     try
3638     {
3639       result = Dali::DevelActor::CalculateCurrentScreenExtents(arg1);
3640     }
3641     CALL_CATCH_EXCEPTION(0);
3642   }
3643
3644   // Note: The float type Rectangle class is not ready yet.
3645   //      Therefore, it transmits data in Vector4 class.
3646   //      This type should later be changed to the appropriate data type.
3647   return new Dali::Vector4(result.x, result.y, result.width, result.height);
3648 }
3649
3650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_LookAt(void* csActor, void* csTarget, void* csUp, void* csLocalForward, void* csLocalUp)
3651 {
3652   Dali::Actor   actor;
3653   Dali::Vector3 target;
3654   Dali::Vector3 up           = Vector3::YAXIS;
3655   Dali::Vector3 localForward = Vector3::ZAXIS;
3656   Dali::Vector3 localUp      = Vector3::YAXIS;
3657
3658   if(!csActor)
3659   {
3660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
3661     return;
3662   }
3663
3664   if(!csTarget)
3665   {
3666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null target Dali::Vector3", 0);
3667     return;
3668   }
3669
3670   actor  = *(Dali::Actor*)csActor;
3671   target = *(Dali::Vector3*)csTarget;
3672
3673   // Use default value if csUp is null
3674   if(csUp)
3675   {
3676     up = *(Dali::Vector3*)csUp;
3677   }
3678
3679   // Use default value if csLocalForward is null
3680   if(csLocalForward)
3681   {
3682     localForward = *(Dali::Vector3*)csLocalForward;
3683   }
3684
3685   // Use default value if csLocalForward is null
3686   if(csLocalUp)
3687   {
3688     localUp = *(Dali::Vector3*)csLocalUp;
3689   }
3690
3691   {
3692     try
3693     {
3694       Dali::DevelActor::LookAt(actor, target, up, localForward, localUp);
3695     }
3696     CALL_CATCH_EXCEPTION();
3697   }
3698 }
3699
3700 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5)
3701 {
3702   Dali::Actor* arg1 = (Dali::Actor*)0;
3703   arg1              = (Dali::Actor*)jarg1;
3704   Rect<int> arg2    = Rect(jarg2, jarg3, jarg4, jarg5);
3705   {
3706     try
3707     {
3708       (arg1)->SetProperty(Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2);
3709     }
3710     CALL_CATCH_EXCEPTION();
3711   }
3712 }
3713
3714 SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void* jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5)
3715 {
3716   Dali::Actor* arg1 = (Dali::Actor*)0;
3717   arg1              = (Dali::Actor*)jarg1;
3718
3719   Rect<int32_t> result;
3720   {
3721     try
3722     {
3723       result = (arg1)->GetProperty<Rect<int32_t>>(Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
3724       *jarg2 = result.left;
3725       *jarg3 = result.right;
3726       *jarg4 = result.bottom;
3727       *jarg5 = result.top;
3728     }
3729     CALL_CATCH_EXCEPTION();
3730   }
3731 }
3732
3733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void* jarg1)
3734 {
3735   Dali::Actor* arg1 = 0;
3736
3737   arg1 = (Dali::Actor*)jarg1;
3738   if(!arg1)
3739   {
3740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
3741     return;
3742   }
3743   {
3744     try
3745     {
3746       Dali::UnparentAndReset(*arg1);
3747     }
3748     CALL_CATCH_EXCEPTION();
3749   }
3750 }
3751
3752 // Signals
3753 #ifndef GENERATE_DEVEL_ACTOR_SIGNAL
3754 #define GENERATE_DEVEL_ACTOR_SIGNAL(HType, SignalName) GENERATE_DEVEL_SIGNAL(Dali::Actor*, HType, Dali::DevelActor, Dali_Actor, SignalName)
3755 #endif
3756 #ifndef GENERATE_ACTOR_SIGNAL
3757 #define GENERATE_ACTOR_SIGNAL(HType, SignalName) GENERATE_SIGNAL(Dali::Actor*, HType, Dali_Actor, SignalName)
3758 #endif
3759
3760 GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), HitTestResultSignal)
3761 // CSharp_Dali_Actor_HitTestResultSignal_Connect
3762 // CSharp_Dali_Actor_HitTestResultSignal_Disconnect
3763
3764 GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), InterceptTouchedSignal)
3765 // CSharp_Dali_Actor_InterceptTouchedSignal_Connect
3766 // CSharp_Dali_Actor_InterceptTouchedSignal_Disconnect
3767
3768 GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::TouchEvent const&), TouchedSignal)
3769 // CSharp_Dali_Actor_TouchedSignal_Connect
3770 // CSharp_Dali_Actor_TouchedSignal_Disconnect
3771
3772 GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::HoverEvent const&), HoveredSignal)
3773 // CSharp_Dali_Actor_HoveredSignal_Connect
3774 // CSharp_Dali_Actor_HoveredSignal_Disconnect
3775
3776 GENERATE_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), WheelEventSignal)
3777 // CSharp_Dali_Actor_WheelEventSignal_Connect
3778 // CSharp_Dali_Actor_WheelEventSignal_Disconnect
3779
3780 GENERATE_DEVEL_ACTOR_SIGNAL(bool(*)(Dali::Actor, Dali::WheelEvent const&), InterceptWheelSignal)
3781 // CSharp_Dali_Actor_InterceptWheelSignal_Connect
3782 // CSharp_Dali_Actor_InterceptWheelSignal_Disconnect
3783
3784 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnSceneSignal)
3785 // CSharp_Dali_Actor_OnSceneSignal_Connect
3786 // CSharp_Dali_Actor_OnSceneSignal_Disconnect
3787
3788 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OffSceneSignal)
3789 // CSharp_Dali_Actor_OffSceneSignal_Connect
3790 // CSharp_Dali_Actor_OffSceneSignal_Disconnect
3791
3792 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor), OnRelayoutSignal)
3793 // CSharp_Dali_Actor_OnRelayoutSignal_Connect
3794 // CSharp_Dali_Actor_OnRelayoutSignal_Disconnect
3795
3796 GENERATE_DEVEL_ACTOR_SIGNAL(void(*)(Dali::Actor, bool, Dali::DevelActor::VisibilityChange::Type), VisibilityChangedSignal)
3797 // CSharp_Dali_Actor_VisibilityChangedSignal_Connect
3798 // CSharp_Dali_Actor_VisibilityChangedSignal_Disconnect
3799
3800 GENERATE_ACTOR_SIGNAL(void(*)(Dali::Actor, LayoutDirection::Type), LayoutDirectionChangedSignal)
3801 // CSharp_Dali_Actor_LayoutDirectionChangedSignal_Connect
3802 // CSharp_Dali_Actor_LayoutDirectionChangedSignal_Disconnect
3803
3804 #ifdef __cplusplus
3805 }
3806 #endif