dali-csharp-binder/src/animation.cpp

   1 /*
   2  * Copyright (c) 2017 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 #ifndef CSHARP_ANIMATION
  19 #define CSHARP_ANIMATION
  20 #endif
  21
  22 #include "common.h"
  23 #include <dali/public-api/animation/animation.h>
  24 #include <dali/devel-api/animation/animation-devel.h>
  25
  26
  27 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
  28   return self->Empty();
  29 }
  30 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
  31 return self->GetConnectionCount();
  32 }
  33 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
  34   self->Connect( func );
  35 }
  36 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
  37   self->Disconnect( func );
  38 }
  39 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
  40   self->Emit( arg );
  41 }
  42
  43 #ifdef __cplusplus
  44 extern "C" {
  45 #endif
  46
  47 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
  48     return (Dali::BaseHandle *)jarg1;
  49 }
  50
  51 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
  52   void * jresult ;
  53   Dali::Animation *result = 0 ;
  54
  55   {
  56     try {
  57       result = (Dali::Animation *)new Dali::Animation();
  58     } catch (std::out_of_range& e) {
  59       {
  60         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  61       };
  62     } catch (std::exception& e) {
  63       {
  64         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  65       };
  66     } catch (...) {
  67       {
  68         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  69       };
  70     }
  71   }
  72   jresult = (void *)result;
  73   return jresult;
  74 }
  75
  76
  77 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
  78   void * jresult ;
  79   float arg1 ;
  80   Dali::Animation result;
  81
  82   arg1 = (float)jarg1;
  83   {
  84     try {
  85       result = Dali::Animation::New(arg1);
  86     } catch (std::out_of_range& e) {
  87       {
  88         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
  89       };
  90     } catch (std::exception& e) {
  91       {
  92         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
  93       };
  94     } catch (...) {
  95       {
  96         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
  97       };
  98     }
  99   }
 100   jresult = new Dali::Animation((const Dali::Animation &)result);
 101   return jresult;
 102 }
 103
 104
 105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
 106   void * jresult ;
 107   Dali::BaseHandle arg1 ;
 108   Dali::BaseHandle *argp1 ;
 109   Dali::Animation result;
 110
 111   argp1 = (Dali::BaseHandle *)jarg1;
 112   if (!argp1) {
 113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 114     return 0;
 115   }
 116   arg1 = *argp1;
 117   {
 118     try {
 119       result = Dali::Animation::DownCast(arg1);
 120     } catch (std::out_of_range& e) {
 121       {
 122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 123       };
 124     } catch (std::exception& e) {
 125       {
 126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 127       };
 128     } catch (...) {
 129       {
 130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 131       };
 132     }
 133   }
 134   jresult = new Dali::Animation((const Dali::Animation &)result);
 135   return jresult;
 136 }
 137
 138
 139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
 140   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 141
 142   arg1 = (Dali::Animation *)jarg1;
 143   {
 144     try {
 145       delete arg1;
 146     } catch (std::out_of_range& e) {
 147       {
 148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 149       };
 150     } catch (std::exception& e) {
 151       {
 152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 153       };
 154     } catch (...) {
 155       {
 156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 157       };
 158     }
 159   }
 160 }
 161
 162
 163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
 164   void * jresult ;
 165   Dali::Animation *arg1 = 0 ;
 166   Dali::Animation *result = 0 ;
 167
 168   arg1 = (Dali::Animation *)jarg1;
 169   if (!arg1) {
 170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
 171     return 0;
 172   }
 173   {
 174     try {
 175       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
 176     } catch (std::out_of_range& e) {
 177       {
 178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 179       };
 180     } catch (std::exception& e) {
 181       {
 182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 183       };
 184     } catch (...) {
 185       {
 186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 187       };
 188     }
 189   }
 190   jresult = (void *)result;
 191   return jresult;
 192 }
 193
 194
 195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
 196   void * jresult ;
 197   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 198   Dali::Animation *arg2 = 0 ;
 199   Dali::Animation *result = 0 ;
 200
 201   arg1 = (Dali::Animation *)jarg1;
 202   arg2 = (Dali::Animation *)jarg2;
 203   if (!arg2) {
 204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
 205     return 0;
 206   }
 207   {
 208     try {
 209       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
 210     } catch (std::out_of_range& e) {
 211       {
 212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 213       };
 214     } catch (std::exception& e) {
 215       {
 216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 217       };
 218     } catch (...) {
 219       {
 220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 221       };
 222     }
 223   }
 224   jresult = (void *)result;
 225   return jresult;
 226 }
 227
 228
 229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
 230   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 231   float arg2 ;
 232
 233   arg1 = (Dali::Animation *)jarg1;
 234   arg2 = (float)jarg2;
 235   {
 236     try {
 237       (arg1)->SetDuration(arg2);
 238     } catch (std::out_of_range& e) {
 239       {
 240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 241       };
 242     } catch (std::exception& e) {
 243       {
 244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 245       };
 246     } catch (...) {
 247       {
 248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 249       };
 250     }
 251   }
 252 }
 253
 254
 255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
 256   float jresult ;
 257   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 258   float result;
 259
 260   arg1 = (Dali::Animation *)jarg1;
 261   {
 262     try {
 263       result = (float)((Dali::Animation const *)arg1)->GetDuration();
 264     } catch (std::out_of_range& e) {
 265       {
 266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 267       };
 268     } catch (std::exception& e) {
 269       {
 270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 271       };
 272     } catch (...) {
 273       {
 274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 275       };
 276     }
 277   }
 278   jresult = result;
 279   return jresult;
 280 }
 281
 282
 283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
 284   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 285   bool arg2 ;
 286
 287   arg1 = (Dali::Animation *)jarg1;
 288   arg2 = jarg2 ? true : false;
 289   {
 290     try {
 291       (arg1)->SetLooping(arg2);
 292     } catch (std::out_of_range& e) {
 293       {
 294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 295       };
 296     } catch (std::exception& e) {
 297       {
 298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 299       };
 300     } catch (...) {
 301       {
 302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 303       };
 304     }
 305   }
 306 }
 307
 308
 309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
 310   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 311   int arg2 ;
 312
 313   arg1 = (Dali::Animation *)jarg1;
 314   arg2 = (int)jarg2;
 315   {
 316     try {
 317       (arg1)->SetLoopCount(arg2);
 318     } catch (std::out_of_range& e) {
 319       {
 320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 321       };
 322     } catch (std::exception& e) {
 323       {
 324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 325       };
 326     } catch (...) {
 327       {
 328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 329       };
 330     }
 331   }
 332 }
 333
 334
 335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
 336   int jresult ;
 337   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 338   int result;
 339
 340   arg1 = (Dali::Animation *)jarg1;
 341   {
 342     try {
 343       result = (int)(arg1)->GetLoopCount();
 344     } catch (std::out_of_range& e) {
 345       {
 346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 347       };
 348     } catch (std::exception& e) {
 349       {
 350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 351       };
 352     } catch (...) {
 353       {
 354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 355       };
 356     }
 357   }
 358   jresult = result;
 359   return jresult;
 360 }
 361
 362
 363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
 364   int jresult ;
 365   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 366   int result;
 367
 368   arg1 = (Dali::Animation *)jarg1;
 369   {
 370     try {
 371       result = (int)(arg1)->GetCurrentLoop();
 372     } catch (std::out_of_range& e) {
 373       {
 374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 375       };
 376     } catch (std::exception& e) {
 377       {
 378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 379       };
 380     } catch (...) {
 381       {
 382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 383       };
 384     }
 385   }
 386   jresult = result;
 387   return jresult;
 388 }
 389
 390
 391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
 392   unsigned int jresult ;
 393   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 394   bool result;
 395
 396   arg1 = (Dali::Animation *)jarg1;
 397   {
 398     try {
 399       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
 400     } catch (std::out_of_range& e) {
 401       {
 402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 403       };
 404     } catch (std::exception& e) {
 405       {
 406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 407       };
 408     } catch (...) {
 409       {
 410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 411       };
 412     }
 413   }
 414   jresult = result;
 415   return jresult;
 416 }
 417
 418
 419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
 420   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 421   Dali::Animation::EndAction arg2 ;
 422
 423   arg1 = (Dali::Animation *)jarg1;
 424   arg2 = (Dali::Animation::EndAction)jarg2;
 425   {
 426     try {
 427       (arg1)->SetEndAction(arg2);
 428     } catch (std::out_of_range& e) {
 429       {
 430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 431       };
 432     } catch (std::exception& e) {
 433       {
 434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 435       };
 436     } catch (...) {
 437       {
 438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 439       };
 440     }
 441   }
 442 }
 443
 444
 445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
 446   int jresult ;
 447   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 448   Dali::Animation::EndAction result;
 449
 450   arg1 = (Dali::Animation *)jarg1;
 451   {
 452     try {
 453       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
 454     } catch (std::out_of_range& e) {
 455       {
 456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 457       };
 458     } catch (std::exception& e) {
 459       {
 460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 461       };
 462     } catch (...) {
 463       {
 464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 465       };
 466     }
 467   }
 468   jresult = (int)result;
 469   return jresult;
 470 }
 471
 472
 473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
 474   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 475   Dali::Animation::EndAction arg2 ;
 476
 477   arg1 = (Dali::Animation *)jarg1;
 478   arg2 = (Dali::Animation::EndAction)jarg2;
 479   {
 480     try {
 481       (arg1)->SetDisconnectAction(arg2);
 482     } catch (std::out_of_range& e) {
 483       {
 484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 485       };
 486     } catch (std::exception& e) {
 487       {
 488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 489       };
 490     } catch (...) {
 491       {
 492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 493       };
 494     }
 495   }
 496 }
 497
 498
 499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
 500   int jresult ;
 501   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 502   Dali::Animation::EndAction result;
 503
 504   arg1 = (Dali::Animation *)jarg1;
 505   {
 506     try {
 507       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
 508     } catch (std::out_of_range& e) {
 509       {
 510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 511       };
 512     } catch (std::exception& e) {
 513       {
 514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 515       };
 516     } catch (...) {
 517       {
 518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 519       };
 520     }
 521   }
 522   jresult = (int)result;
 523   return jresult;
 524 }
 525
 526
 527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
 528   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 529   Dali::AlphaFunction arg2 ;
 530   Dali::AlphaFunction *argp2 ;
 531
 532   arg1 = (Dali::Animation *)jarg1;
 533   argp2 = (Dali::AlphaFunction *)jarg2;
 534   if (!argp2) {
 535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
 536     return ;
 537   }
 538   arg2 = *argp2;
 539   {
 540     try {
 541       (arg1)->SetDefaultAlphaFunction(arg2);
 542     } catch (std::out_of_range& e) {
 543       {
 544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 545       };
 546     } catch (std::exception& e) {
 547       {
 548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 549       };
 550     } catch (...) {
 551       {
 552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 553       };
 554     }
 555   }
 556 }
 557
 558
 559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
 560   void * jresult ;
 561   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 562   Dali::AlphaFunction result;
 563
 564   arg1 = (Dali::Animation *)jarg1;
 565   {
 566     try {
 567       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
 568     } catch (std::out_of_range& e) {
 569       {
 570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 571       };
 572     } catch (std::exception& e) {
 573       {
 574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 575       };
 576     } catch (...) {
 577       {
 578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 579       };
 580     }
 581   }
 582   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
 583   return jresult;
 584 }
 585
 586
 587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
 588   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 589   float arg2 ;
 590
 591   arg1 = (Dali::Animation *)jarg1;
 592   arg2 = (float)jarg2;
 593   {
 594     try {
 595       (arg1)->SetCurrentProgress(arg2);
 596     } catch (std::out_of_range& e) {
 597       {
 598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 599       };
 600     } catch (std::exception& e) {
 601       {
 602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 603       };
 604     } catch (...) {
 605       {
 606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 607       };
 608     }
 609   }
 610 }
 611
 612
 613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
 614   float jresult ;
 615   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 616   float result;
 617
 618   arg1 = (Dali::Animation *)jarg1;
 619   {
 620     try {
 621       result = (float)(arg1)->GetCurrentProgress();
 622     } catch (std::out_of_range& e) {
 623       {
 624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 625       };
 626     } catch (std::exception& e) {
 627       {
 628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 629       };
 630     } catch (...) {
 631       {
 632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 633       };
 634     }
 635   }
 636   jresult = result;
 637   return jresult;
 638 }
 639
 640
 641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
 642   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 643   float arg2 ;
 644
 645   arg1 = (Dali::Animation *)jarg1;
 646   arg2 = (float)jarg2;
 647   {
 648     try {
 649       (arg1)->SetSpeedFactor(arg2);
 650     } catch (std::out_of_range& e) {
 651       {
 652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 653       };
 654     } catch (std::exception& e) {
 655       {
 656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 657       };
 658     } catch (...) {
 659       {
 660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 661       };
 662     }
 663   }
 664 }
 665
 666
 667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
 668   float jresult ;
 669   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 670   float result;
 671
 672   arg1 = (Dali::Animation *)jarg1;
 673   {
 674     try {
 675       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
 676     } catch (std::out_of_range& e) {
 677       {
 678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 679       };
 680     } catch (std::exception& e) {
 681       {
 682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 683       };
 684     } catch (...) {
 685       {
 686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 687       };
 688     }
 689   }
 690   jresult = result;
 691   return jresult;
 692 }
 693
 694
 695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
 696   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 697   Dali::Vector2 *arg2 = 0 ;
 698
 699   arg1 = (Dali::Animation *)jarg1;
 700   arg2 = (Dali::Vector2 *)jarg2;
 701   if (!arg2) {
 702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
 703     return ;
 704   }
 705   {
 706     try {
 707       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
 708     } catch (std::out_of_range& e) {
 709       {
 710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 711       };
 712     } catch (std::exception& e) {
 713       {
 714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 715       };
 716     } catch (...) {
 717       {
 718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 719       };
 720     }
 721   }
 722 }
 723
 724
 725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
 726   void * jresult ;
 727   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 728   Dali::Vector2 result;
 729
 730   arg1 = (Dali::Animation *)jarg1;
 731   {
 732     try {
 733       result = ((Dali::Animation const *)arg1)->GetPlayRange();
 734     } catch (std::out_of_range& e) {
 735       {
 736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 737       };
 738     } catch (std::exception& e) {
 739       {
 740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 741       };
 742     } catch (...) {
 743       {
 744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 745       };
 746     }
 747   }
 748   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
 749   return jresult;
 750 }
 751
 752
 753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
 754   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 755
 756   arg1 = (Dali::Animation *)jarg1;
 757   {
 758     try {
 759       (arg1)->Play();
 760     } catch (std::out_of_range& e) {
 761       {
 762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 763       };
 764     } catch (std::exception& e) {
 765       {
 766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 767       };
 768     } catch (...) {
 769       {
 770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 771       };
 772     }
 773   }
 774 }
 775
 776
 777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
 778   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 779   float arg2 ;
 780
 781   arg1 = (Dali::Animation *)jarg1;
 782   arg2 = (float)jarg2;
 783   {
 784     try {
 785       (arg1)->PlayFrom(arg2);
 786     } catch (std::out_of_range& e) {
 787       {
 788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 789       };
 790     } catch (std::exception& e) {
 791       {
 792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 793       };
 794     } catch (...) {
 795       {
 796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 797       };
 798     }
 799   }
 800 }
 801
 802
 803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
 804   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 805
 806   arg1 = (Dali::Animation *)jarg1;
 807   {
 808     try {
 809       (arg1)->Pause();
 810     } catch (std::out_of_range& e) {
 811       {
 812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 813       };
 814     } catch (std::exception& e) {
 815       {
 816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 817       };
 818     } catch (...) {
 819       {
 820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 821       };
 822     }
 823   }
 824 }
 825
 826
 827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
 828   int jresult ;
 829   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 830   Dali::Animation::State result;
 831
 832   arg1 = (Dali::Animation *)jarg1;
 833   {
 834     try {
 835       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
 836     } catch (std::out_of_range& e) {
 837       {
 838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 839       };
 840     } catch (std::exception& e) {
 841       {
 842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 843       };
 844     } catch (...) {
 845       {
 846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 847       };
 848     }
 849   }
 850   jresult = (int)result;
 851   return jresult;
 852 }
 853
 854
 855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
 856   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 857
 858   arg1 = (Dali::Animation *)jarg1;
 859   {
 860     try {
 861       (arg1)->Stop();
 862     } catch (std::out_of_range& e) {
 863       {
 864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 865       };
 866     } catch (std::exception& e) {
 867       {
 868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 869       };
 870     } catch (...) {
 871       {
 872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 873       };
 874     }
 875   }
 876 }
 877
 878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) {
 879   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
 880
 881   Dali::Animation arg1 = *argp1;
 882   float arg2 = (float)jarg2;
 883
 884   {
 885     try {
 886       Dali::DevelAnimation::SetProgressNotification(arg1, arg2);
 887     } catch (std::out_of_range& e) {
 888       {
 889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 890       };
 891     } catch (std::exception& e) {
 892       {
 893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 894       };
 895     } catch (...) {
 896       {
 897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 898       };
 899     }
 900   }
 901 }
 902
 903
 904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) {
 905   float jresult ;
 906   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
 907   float result;
 908
 909   Dali::Animation arg1 = *argp1;
 910   {
 911     try {
 912       result = (float)Dali::DevelAnimation::GetProgressNotification(arg1);
 913     } catch (std::out_of_range& e) {
 914       {
 915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 916       };
 917     } catch (std::exception& e) {
 918       {
 919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 920       };
 921     } catch (...) {
 922       {
 923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 924       };
 925     }
 926   }
 927   jresult = result;
 928   return jresult;
 929 }
 930
 931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
 932   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 933
 934   arg1 = (Dali::Animation *)jarg1;
 935   {
 936     try {
 937       (arg1)->Clear();
 938     } catch (std::out_of_range& e) {
 939       {
 940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
 941       };
 942     } catch (std::exception& e) {
 943       {
 944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
 945       };
 946     } catch (...) {
 947       {
 948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
 949       };
 950     }
 951   }
 952 }
 953
 954
 955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
 956   void * jresult ;
 957   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
 958   Dali::Animation::AnimationSignalType *result = 0 ;
 959
 960   arg1 = (Dali::Animation *)jarg1;
 961   {
 962     try {
 963       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
 964     } catch (std::out_of_range& e) {
 965       {
 966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 967       };
 968     } catch (std::exception& e) {
 969       {
 970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 971       };
 972     } catch (...) {
 973       {
 974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
 975       };
 976     }
 977   }
 978   jresult = (void *)result;
 979   return jresult;
 980 }
 981
 982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) {
 983   void * jresult ;
 984   Dali::Animation* argp1 = (Dali::Animation*) jarg1 ;
 985   Dali::Animation::AnimationSignalType *result = 0 ;
 986
 987   Dali::Animation arg1 = *argp1;
 988   {
 989     try {
 990       result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1);
 991     } catch (std::out_of_range& e) {
 992       {
 993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
 994       };
 995     } catch (std::exception& e) {
 996       {
 997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
 998       };
 999     } catch (...) {
1000       {
1001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1002       };
1003     }
1004   }
1005   jresult = (void *)result;
1006   return jresult;
1007 }
1008
1009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayAfter(void * jarg1, float jarg2) {
1010   Dali::Animation arg1 ;
1011   float arg2 ;
1012   Dali::Animation *argp1 ;
1013
1014   argp1 = (Dali::Animation *)jarg1;
1015   if (!argp1) {
1016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Animation", 0);
1017     return ;
1018   }
1019   arg1 = *argp1;
1020   arg2 = (float)jarg2;
1021   {
1022     try {
1023       arg1.PlayAfter(arg2);
1024     } catch (std::out_of_range& e) {
1025       {
1026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1027       };
1028     } catch (std::exception& e) {
1029       {
1030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1031       };
1032     } catch (...) {
1033       {
1034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1035       };
1036     }
1037   }
1038 }
1039
1040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
1041   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1042   SwigValueWrapper< Dali::Property > arg2 ;
1043   Dali::Property::Value arg3 ;
1044   Dali::Property *argp2 ;
1045   Dali::Property::Value *argp3 ;
1046
1047   arg1 = (Dali::Animation *)jarg1;
1048   argp2 = (Dali::Property *)jarg2;
1049   if (!argp2) {
1050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1051     return ;
1052   }
1053   arg2 = *argp2;
1054   argp3 = (Dali::Property::Value *)jarg3;
1055   if (!argp3) {
1056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1057     return ;
1058   }
1059   arg3 = *argp3;
1060   {
1061     try {
1062       (arg1)->AnimateBy(arg2,arg3);
1063     } catch (std::out_of_range& e) {
1064       {
1065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1066       };
1067     } catch (std::exception& e) {
1068       {
1069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1070       };
1071     } catch (...) {
1072       {
1073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1074       };
1075     }
1076   }
1077 }
1078
1079
1080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
1081   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1082   SwigValueWrapper< Dali::Property > arg2 ;
1083   Dali::Property::Value arg3 ;
1084   Dali::AlphaFunction arg4 ;
1085   Dali::Property *argp2 ;
1086   Dali::Property::Value *argp3 ;
1087   Dali::AlphaFunction *argp4 ;
1088
1089   arg1 = (Dali::Animation *)jarg1;
1090   argp2 = (Dali::Property *)jarg2;
1091   if (!argp2) {
1092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1093     return ;
1094   }
1095   arg2 = *argp2;
1096   argp3 = (Dali::Property::Value *)jarg3;
1097   if (!argp3) {
1098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1099     return ;
1100   }
1101   arg3 = *argp3;
1102   argp4 = (Dali::AlphaFunction *)jarg4;
1103   if (!argp4) {
1104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1105     return ;
1106   }
1107   arg4 = *argp4;
1108   {
1109     try {
1110       (arg1)->AnimateBy(arg2,arg3,arg4);
1111     } catch (std::out_of_range& e) {
1112       {
1113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1114       };
1115     } catch (std::exception& e) {
1116       {
1117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1118       };
1119     } catch (...) {
1120       {
1121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1122       };
1123     }
1124   }
1125 }
1126
1127
1128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
1129   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1130   SwigValueWrapper< Dali::Property > arg2 ;
1131   Dali::Property::Value arg3 ;
1132   SwigValueWrapper< Dali::TimePeriod > arg4 ;
1133   Dali::Property *argp2 ;
1134   Dali::Property::Value *argp3 ;
1135   Dali::TimePeriod *argp4 ;
1136
1137   arg1 = (Dali::Animation *)jarg1;
1138   argp2 = (Dali::Property *)jarg2;
1139   if (!argp2) {
1140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1141     return ;
1142   }
1143   arg2 = *argp2;
1144   argp3 = (Dali::Property::Value *)jarg3;
1145   if (!argp3) {
1146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1147     return ;
1148   }
1149   arg3 = *argp3;
1150   argp4 = (Dali::TimePeriod *)jarg4;
1151   if (!argp4) {
1152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1153     return ;
1154   }
1155   arg4 = *argp4;
1156   {
1157     try {
1158       (arg1)->AnimateBy(arg2,arg3,arg4);
1159     } catch (std::out_of_range& e) {
1160       {
1161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1162       };
1163     } catch (std::exception& e) {
1164       {
1165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1166       };
1167     } catch (...) {
1168       {
1169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1170       };
1171     }
1172   }
1173 }
1174
1175
1176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
1177   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1178   SwigValueWrapper< Dali::Property > arg2 ;
1179   Dali::Property::Value arg3 ;
1180   Dali::AlphaFunction arg4 ;
1181   SwigValueWrapper< Dali::TimePeriod > arg5 ;
1182   Dali::Property *argp2 ;
1183   Dali::Property::Value *argp3 ;
1184   Dali::AlphaFunction *argp4 ;
1185   Dali::TimePeriod *argp5 ;
1186
1187   arg1 = (Dali::Animation *)jarg1;
1188   argp2 = (Dali::Property *)jarg2;
1189   if (!argp2) {
1190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1191     return ;
1192   }
1193   arg2 = *argp2;
1194   argp3 = (Dali::Property::Value *)jarg3;
1195   if (!argp3) {
1196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1197     return ;
1198   }
1199   arg3 = *argp3;
1200   argp4 = (Dali::AlphaFunction *)jarg4;
1201   if (!argp4) {
1202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1203     return ;
1204   }
1205   arg4 = *argp4;
1206   argp5 = (Dali::TimePeriod *)jarg5;
1207   if (!argp5) {
1208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1209     return ;
1210   }
1211   arg5 = *argp5;
1212   {
1213     try {
1214       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
1215     } catch (std::out_of_range& e) {
1216       {
1217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1218       };
1219     } catch (std::exception& e) {
1220       {
1221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1222       };
1223     } catch (...) {
1224       {
1225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1226       };
1227     }
1228   }
1229 }
1230
1231
1232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
1233   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1234   SwigValueWrapper< Dali::Property > arg2 ;
1235   Dali::Property::Value arg3 ;
1236   Dali::Property *argp2 ;
1237   Dali::Property::Value *argp3 ;
1238
1239   arg1 = (Dali::Animation *)jarg1;
1240   argp2 = (Dali::Property *)jarg2;
1241   if (!argp2) {
1242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1243     return ;
1244   }
1245   arg2 = *argp2;
1246   argp3 = (Dali::Property::Value *)jarg3;
1247   if (!argp3) {
1248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1249     return ;
1250   }
1251   arg3 = *argp3;
1252   {
1253     try {
1254       (arg1)->AnimateTo(arg2,arg3);
1255     } catch (std::out_of_range& e) {
1256       {
1257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1258       };
1259     } catch (std::exception& e) {
1260       {
1261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1262       };
1263     } catch (...) {
1264       {
1265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1266       };
1267     }
1268   }
1269 }
1270
1271
1272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
1273   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1274   SwigValueWrapper< Dali::Property > arg2 ;
1275   Dali::Property::Value arg3 ;
1276   Dali::AlphaFunction arg4 ;
1277   Dali::Property *argp2 ;
1278   Dali::Property::Value *argp3 ;
1279   Dali::AlphaFunction *argp4 ;
1280
1281   arg1 = (Dali::Animation *)jarg1;
1282   argp2 = (Dali::Property *)jarg2;
1283   if (!argp2) {
1284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1285     return ;
1286   }
1287   arg2 = *argp2;
1288   argp3 = (Dali::Property::Value *)jarg3;
1289   if (!argp3) {
1290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1291     return ;
1292   }
1293   arg3 = *argp3;
1294   argp4 = (Dali::AlphaFunction *)jarg4;
1295   if (!argp4) {
1296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1297     return ;
1298   }
1299   arg4 = *argp4;
1300   {
1301     try {
1302       (arg1)->AnimateTo(arg2,arg3,arg4);
1303     } catch (std::out_of_range& e) {
1304       {
1305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1306       };
1307     } catch (std::exception& e) {
1308       {
1309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1310       };
1311     } catch (...) {
1312       {
1313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1314       };
1315     }
1316   }
1317 }
1318
1319
1320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
1321   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1322   SwigValueWrapper< Dali::Property > arg2 ;
1323   Dali::Property::Value arg3 ;
1324   SwigValueWrapper< Dali::TimePeriod > arg4 ;
1325   Dali::Property *argp2 ;
1326   Dali::Property::Value *argp3 ;
1327   Dali::TimePeriod *argp4 ;
1328
1329   arg1 = (Dali::Animation *)jarg1;
1330   argp2 = (Dali::Property *)jarg2;
1331   if (!argp2) {
1332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1333     return ;
1334   }
1335   arg2 = *argp2;
1336   argp3 = (Dali::Property::Value *)jarg3;
1337   if (!argp3) {
1338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1339     return ;
1340   }
1341   arg3 = *argp3;
1342   argp4 = (Dali::TimePeriod *)jarg4;
1343   if (!argp4) {
1344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1345     return ;
1346   }
1347   arg4 = *argp4;
1348   {
1349     try {
1350       (arg1)->AnimateTo(arg2,arg3,arg4);
1351     } catch (std::out_of_range& e) {
1352       {
1353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1354       };
1355     } catch (std::exception& e) {
1356       {
1357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1358       };
1359     } catch (...) {
1360       {
1361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1362       };
1363     }
1364   }
1365 }
1366
1367
1368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
1369   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1370   SwigValueWrapper< Dali::Property > arg2 ;
1371   Dali::Property::Value arg3 ;
1372   Dali::AlphaFunction arg4 ;
1373   SwigValueWrapper< Dali::TimePeriod > arg5 ;
1374   Dali::Property *argp2 ;
1375   Dali::Property::Value *argp3 ;
1376   Dali::AlphaFunction *argp4 ;
1377   Dali::TimePeriod *argp5 ;
1378
1379   arg1 = (Dali::Animation *)jarg1;
1380   argp2 = (Dali::Property *)jarg2;
1381   if (!argp2) {
1382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1383     return ;
1384   }
1385   arg2 = *argp2;
1386   argp3 = (Dali::Property::Value *)jarg3;
1387   if (!argp3) {
1388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
1389     return ;
1390   }
1391   arg3 = *argp3;
1392   argp4 = (Dali::AlphaFunction *)jarg4;
1393   if (!argp4) {
1394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1395     return ;
1396   }
1397   arg4 = *argp4;
1398   argp5 = (Dali::TimePeriod *)jarg5;
1399   if (!argp5) {
1400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1401     return ;
1402   }
1403   arg5 = *argp5;
1404   {
1405     try {
1406       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
1407     } catch (std::out_of_range& e) {
1408       {
1409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1410       };
1411     } catch (std::exception& e) {
1412       {
1413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1414       };
1415     } catch (...) {
1416       {
1417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1418       };
1419     }
1420   }
1421 }
1422
1423
1424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
1425   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1426   SwigValueWrapper< Dali::Property > arg2 ;
1427   Dali::KeyFrames *arg3 = 0 ;
1428   Dali::Property *argp2 ;
1429
1430   arg1 = (Dali::Animation *)jarg1;
1431   argp2 = (Dali::Property *)jarg2;
1432   if (!argp2) {
1433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1434     return ;
1435   }
1436   arg2 = *argp2;
1437   arg3 = (Dali::KeyFrames *)jarg3;
1438   if (!arg3) {
1439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1440     return ;
1441   }
1442   {
1443     try {
1444       (arg1)->AnimateBetween(arg2,*arg3);
1445     } catch (std::out_of_range& e) {
1446       {
1447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1448       };
1449     } catch (std::exception& e) {
1450       {
1451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1452       };
1453     } catch (...) {
1454       {
1455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1456       };
1457     }
1458   }
1459 }
1460
1461
1462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
1463   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1464   SwigValueWrapper< Dali::Property > arg2 ;
1465   Dali::KeyFrames *arg3 = 0 ;
1466   Dali::Animation::Interpolation arg4 ;
1467   Dali::Property *argp2 ;
1468
1469   arg1 = (Dali::Animation *)jarg1;
1470   argp2 = (Dali::Property *)jarg2;
1471   if (!argp2) {
1472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1473     return ;
1474   }
1475   arg2 = *argp2;
1476   arg3 = (Dali::KeyFrames *)jarg3;
1477   if (!arg3) {
1478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1479     return ;
1480   }
1481   arg4 = (Dali::Animation::Interpolation)jarg4;
1482   {
1483     try {
1484       (arg1)->AnimateBetween(arg2,*arg3,arg4);
1485     } catch (std::out_of_range& e) {
1486       {
1487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1488       };
1489     } catch (std::exception& e) {
1490       {
1491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1492       };
1493     } catch (...) {
1494       {
1495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1496       };
1497     }
1498   }
1499 }
1500
1501
1502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
1503   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1504   SwigValueWrapper< Dali::Property > arg2 ;
1505   Dali::KeyFrames *arg3 = 0 ;
1506   Dali::AlphaFunction arg4 ;
1507   Dali::Property *argp2 ;
1508   Dali::AlphaFunction *argp4 ;
1509
1510   arg1 = (Dali::Animation *)jarg1;
1511   argp2 = (Dali::Property *)jarg2;
1512   if (!argp2) {
1513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1514     return ;
1515   }
1516   arg2 = *argp2;
1517   arg3 = (Dali::KeyFrames *)jarg3;
1518   if (!arg3) {
1519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1520     return ;
1521   }
1522   argp4 = (Dali::AlphaFunction *)jarg4;
1523   if (!argp4) {
1524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1525     return ;
1526   }
1527   arg4 = *argp4;
1528   {
1529     try {
1530       (arg1)->AnimateBetween(arg2,*arg3,arg4);
1531     } catch (std::out_of_range& e) {
1532       {
1533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1534       };
1535     } catch (std::exception& e) {
1536       {
1537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1538       };
1539     } catch (...) {
1540       {
1541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1542       };
1543     }
1544   }
1545 }
1546
1547
1548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
1549   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1550   SwigValueWrapper< Dali::Property > arg2 ;
1551   Dali::KeyFrames *arg3 = 0 ;
1552   Dali::AlphaFunction arg4 ;
1553   Dali::Animation::Interpolation arg5 ;
1554   Dali::Property *argp2 ;
1555   Dali::AlphaFunction *argp4 ;
1556
1557   arg1 = (Dali::Animation *)jarg1;
1558   argp2 = (Dali::Property *)jarg2;
1559   if (!argp2) {
1560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1561     return ;
1562   }
1563   arg2 = *argp2;
1564   arg3 = (Dali::KeyFrames *)jarg3;
1565   if (!arg3) {
1566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1567     return ;
1568   }
1569   argp4 = (Dali::AlphaFunction *)jarg4;
1570   if (!argp4) {
1571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1572     return ;
1573   }
1574   arg4 = *argp4;
1575   arg5 = (Dali::Animation::Interpolation)jarg5;
1576   {
1577     try {
1578       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
1579     } catch (std::out_of_range& e) {
1580       {
1581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1582       };
1583     } catch (std::exception& e) {
1584       {
1585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1586       };
1587     } catch (...) {
1588       {
1589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1590       };
1591     }
1592   }
1593 }
1594
1595
1596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
1597   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1598   SwigValueWrapper< Dali::Property > arg2 ;
1599   Dali::KeyFrames *arg3 = 0 ;
1600   SwigValueWrapper< Dali::TimePeriod > arg4 ;
1601   Dali::Property *argp2 ;
1602   Dali::TimePeriod *argp4 ;
1603
1604   arg1 = (Dali::Animation *)jarg1;
1605   argp2 = (Dali::Property *)jarg2;
1606   if (!argp2) {
1607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1608     return ;
1609   }
1610   arg2 = *argp2;
1611   arg3 = (Dali::KeyFrames *)jarg3;
1612   if (!arg3) {
1613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1614     return ;
1615   }
1616   argp4 = (Dali::TimePeriod *)jarg4;
1617   if (!argp4) {
1618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1619     return ;
1620   }
1621   arg4 = *argp4;
1622   {
1623     try {
1624       (arg1)->AnimateBetween(arg2,*arg3,arg4);
1625     } catch (std::out_of_range& e) {
1626       {
1627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1628       };
1629     } catch (std::exception& e) {
1630       {
1631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1632       };
1633     } catch (...) {
1634       {
1635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1636       };
1637     }
1638   }
1639 }
1640
1641
1642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
1643   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1644   SwigValueWrapper< Dali::Property > arg2 ;
1645   Dali::KeyFrames *arg3 = 0 ;
1646   SwigValueWrapper< Dali::TimePeriod > arg4 ;
1647   Dali::Animation::Interpolation arg5 ;
1648   Dali::Property *argp2 ;
1649   Dali::TimePeriod *argp4 ;
1650
1651   arg1 = (Dali::Animation *)jarg1;
1652   argp2 = (Dali::Property *)jarg2;
1653   if (!argp2) {
1654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1655     return ;
1656   }
1657   arg2 = *argp2;
1658   arg3 = (Dali::KeyFrames *)jarg3;
1659   if (!arg3) {
1660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1661     return ;
1662   }
1663   argp4 = (Dali::TimePeriod *)jarg4;
1664   if (!argp4) {
1665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1666     return ;
1667   }
1668   arg4 = *argp4;
1669   arg5 = (Dali::Animation::Interpolation)jarg5;
1670   {
1671     try {
1672       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
1673     } catch (std::out_of_range& e) {
1674       {
1675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1676       };
1677     } catch (std::exception& e) {
1678       {
1679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1680       };
1681     } catch (...) {
1682       {
1683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1684       };
1685     }
1686   }
1687 }
1688
1689
1690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
1691   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1692   SwigValueWrapper< Dali::Property > arg2 ;
1693   Dali::KeyFrames *arg3 = 0 ;
1694   Dali::AlphaFunction arg4 ;
1695   SwigValueWrapper< Dali::TimePeriod > arg5 ;
1696   Dali::Property *argp2 ;
1697   Dali::AlphaFunction *argp4 ;
1698   Dali::TimePeriod *argp5 ;
1699
1700   arg1 = (Dali::Animation *)jarg1;
1701   argp2 = (Dali::Property *)jarg2;
1702   if (!argp2) {
1703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1704     return ;
1705   }
1706   arg2 = *argp2;
1707   arg3 = (Dali::KeyFrames *)jarg3;
1708   if (!arg3) {
1709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1710     return ;
1711   }
1712   argp4 = (Dali::AlphaFunction *)jarg4;
1713   if (!argp4) {
1714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1715     return ;
1716   }
1717   arg4 = *argp4;
1718   argp5 = (Dali::TimePeriod *)jarg5;
1719   if (!argp5) {
1720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1721     return ;
1722   }
1723   arg5 = *argp5;
1724   {
1725     try {
1726       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
1727     } catch (std::out_of_range& e) {
1728       {
1729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1730       };
1731     } catch (std::exception& e) {
1732       {
1733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1734       };
1735     } catch (...) {
1736       {
1737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1738       };
1739     }
1740   }
1741 }
1742
1743
1744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
1745   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1746   SwigValueWrapper< Dali::Property > arg2 ;
1747   Dali::KeyFrames *arg3 = 0 ;
1748   Dali::AlphaFunction arg4 ;
1749   SwigValueWrapper< Dali::TimePeriod > arg5 ;
1750   Dali::Animation::Interpolation arg6 ;
1751   Dali::Property *argp2 ;
1752   Dali::AlphaFunction *argp4 ;
1753   Dali::TimePeriod *argp5 ;
1754
1755   arg1 = (Dali::Animation *)jarg1;
1756   argp2 = (Dali::Property *)jarg2;
1757   if (!argp2) {
1758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
1759     return ;
1760   }
1761   arg2 = *argp2;
1762   arg3 = (Dali::KeyFrames *)jarg3;
1763   if (!arg3) {
1764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
1765     return ;
1766   }
1767   argp4 = (Dali::AlphaFunction *)jarg4;
1768   if (!argp4) {
1769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1770     return ;
1771   }
1772   arg4 = *argp4;
1773   argp5 = (Dali::TimePeriod *)jarg5;
1774   if (!argp5) {
1775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1776     return ;
1777   }
1778   arg5 = *argp5;
1779   arg6 = (Dali::Animation::Interpolation)jarg6;
1780   {
1781     try {
1782       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
1783     } catch (std::out_of_range& e) {
1784       {
1785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1786       };
1787     } catch (std::exception& e) {
1788       {
1789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1790       };
1791     } catch (...) {
1792       {
1793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1794       };
1795     }
1796   }
1797 }
1798
1799
1800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
1801   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1802   Dali::Actor arg2 ;
1803   Dali::Path arg3 ;
1804   Dali::Vector3 *arg4 = 0 ;
1805   Dali::Actor *argp2 ;
1806   Dali::Path *argp3 ;
1807
1808   arg1 = (Dali::Animation *)jarg1;
1809   argp2 = (Dali::Actor *)jarg2;
1810   if (!argp2) {
1811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
1812     return ;
1813   }
1814   arg2 = *argp2;
1815   argp3 = (Dali::Path *)jarg3;
1816   if (!argp3) {
1817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
1818     return ;
1819   }
1820   arg3 = *argp3;
1821   arg4 = (Dali::Vector3 *)jarg4;
1822   if (!arg4) {
1823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1824     return ;
1825   }
1826   {
1827     try {
1828       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
1829     } catch (std::out_of_range& e) {
1830       {
1831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1832       };
1833     } catch (std::exception& e) {
1834       {
1835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1836       };
1837     } catch (...) {
1838       {
1839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1840       };
1841     }
1842   }
1843 }
1844
1845
1846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
1847   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1848   Dali::Actor arg2 ;
1849   Dali::Path arg3 ;
1850   Dali::Vector3 *arg4 = 0 ;
1851   Dali::AlphaFunction arg5 ;
1852   Dali::Actor *argp2 ;
1853   Dali::Path *argp3 ;
1854   Dali::AlphaFunction *argp5 ;
1855
1856   arg1 = (Dali::Animation *)jarg1;
1857   argp2 = (Dali::Actor *)jarg2;
1858   if (!argp2) {
1859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
1860     return ;
1861   }
1862   arg2 = *argp2;
1863   argp3 = (Dali::Path *)jarg3;
1864   if (!argp3) {
1865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
1866     return ;
1867   }
1868   arg3 = *argp3;
1869   arg4 = (Dali::Vector3 *)jarg4;
1870   if (!arg4) {
1871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1872     return ;
1873   }
1874   argp5 = (Dali::AlphaFunction *)jarg5;
1875   if (!argp5) {
1876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1877     return ;
1878   }
1879   arg5 = *argp5;
1880   {
1881     try {
1882       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
1883     } catch (std::out_of_range& e) {
1884       {
1885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1886       };
1887     } catch (std::exception& e) {
1888       {
1889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1890       };
1891     } catch (...) {
1892       {
1893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1894       };
1895     }
1896   }
1897 }
1898
1899
1900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
1901   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1902   Dali::Actor arg2 ;
1903   Dali::Path arg3 ;
1904   Dali::Vector3 *arg4 = 0 ;
1905   SwigValueWrapper< Dali::TimePeriod > arg5 ;
1906   Dali::Actor *argp2 ;
1907   Dali::Path *argp3 ;
1908   Dali::TimePeriod *argp5 ;
1909
1910   arg1 = (Dali::Animation *)jarg1;
1911   argp2 = (Dali::Actor *)jarg2;
1912   if (!argp2) {
1913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
1914     return ;
1915   }
1916   arg2 = *argp2;
1917   argp3 = (Dali::Path *)jarg3;
1918   if (!argp3) {
1919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
1920     return ;
1921   }
1922   arg3 = *argp3;
1923   arg4 = (Dali::Vector3 *)jarg4;
1924   if (!arg4) {
1925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1926     return ;
1927   }
1928   argp5 = (Dali::TimePeriod *)jarg5;
1929   if (!argp5) {
1930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1931     return ;
1932   }
1933   arg5 = *argp5;
1934   {
1935     try {
1936       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
1937     } catch (std::out_of_range& e) {
1938       {
1939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1940       };
1941     } catch (std::exception& e) {
1942       {
1943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1944       };
1945     } catch (...) {
1946       {
1947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1948       };
1949     }
1950   }
1951 }
1952
1953
1954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
1955   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
1956   Dali::Actor arg2 ;
1957   Dali::Path arg3 ;
1958   Dali::Vector3 *arg4 = 0 ;
1959   Dali::AlphaFunction arg5 ;
1960   SwigValueWrapper< Dali::TimePeriod > arg6 ;
1961   Dali::Actor *argp2 ;
1962   Dali::Path *argp3 ;
1963   Dali::AlphaFunction *argp5 ;
1964   Dali::TimePeriod *argp6 ;
1965
1966   arg1 = (Dali::Animation *)jarg1;
1967   argp2 = (Dali::Actor *)jarg2;
1968   if (!argp2) {
1969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
1970     return ;
1971   }
1972   arg2 = *argp2;
1973   argp3 = (Dali::Path *)jarg3;
1974   if (!argp3) {
1975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
1976     return ;
1977   }
1978   arg3 = *argp3;
1979   arg4 = (Dali::Vector3 *)jarg4;
1980   if (!arg4) {
1981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
1982     return ;
1983   }
1984   argp5 = (Dali::AlphaFunction *)jarg5;
1985   if (!argp5) {
1986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
1987     return ;
1988   }
1989   arg5 = *argp5;
1990   argp6 = (Dali::TimePeriod *)jarg6;
1991   if (!argp6) {
1992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
1993     return ;
1994   }
1995   arg6 = *argp6;
1996   {
1997     try {
1998       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
1999     } catch (std::out_of_range& e) {
2000       {
2001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2002       };
2003     } catch (std::exception& e) {
2004       {
2005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2006       };
2007     } catch (...) {
2008       {
2009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2010       };
2011     }
2012   }
2013 }
2014
2015
2016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
2017   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
2018   Dali::Actor arg2 ;
2019   float arg3 ;
2020   Dali::Actor *argp2 ;
2021
2022   arg1 = (Dali::Animation *)jarg1;
2023   argp2 = (Dali::Actor *)jarg2;
2024   if (!argp2) {
2025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2026     return ;
2027   }
2028   arg2 = *argp2;
2029   arg3 = (float)jarg3;
2030   {
2031     try {
2032       (arg1)->Show(arg2,arg3);
2033     } catch (std::out_of_range& e) {
2034       {
2035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2036       };
2037     } catch (std::exception& e) {
2038       {
2039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2040       };
2041     } catch (...) {
2042       {
2043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2044       };
2045     }
2046   }
2047 }
2048
2049
2050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
2051   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
2052   Dali::Actor arg2 ;
2053   float arg3 ;
2054   Dali::Actor *argp2 ;
2055
2056   arg1 = (Dali::Animation *)jarg1;
2057   argp2 = (Dali::Actor *)jarg2;
2058   if (!argp2) {
2059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
2060     return ;
2061   }
2062   arg2 = *argp2;
2063   arg3 = (float)jarg3;
2064   {
2065     try {
2066       (arg1)->Hide(arg2,arg3);
2067     } catch (std::out_of_range& e) {
2068       {
2069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2070       };
2071     } catch (std::exception& e) {
2072       {
2073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2074       };
2075     } catch (...) {
2076       {
2077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2078       };
2079     }
2080   }
2081 }
2082
2083
2084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
2085   unsigned int jresult ;
2086   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
2087   bool result;
2088
2089   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
2090   {
2091     try {
2092       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
2093     } catch (std::out_of_range& e) {
2094       {
2095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2096       };
2097     } catch (std::exception& e) {
2098       {
2099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2100       };
2101     } catch (...) {
2102       {
2103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2104       };
2105     }
2106   }
2107   jresult = result;
2108   return jresult;
2109 }
2110
2111
2112 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
2113   unsigned long jresult ;
2114   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
2115   std::size_t result;
2116
2117   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
2118   {
2119     try {
2120       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
2121     } catch (std::out_of_range& e) {
2122       {
2123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2124       };
2125     } catch (std::exception& e) {
2126       {
2127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2128       };
2129     } catch (...) {
2130       {
2131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2132       };
2133     }
2134   }
2135   jresult = (unsigned long)result;
2136   return jresult;
2137 }
2138
2139
2140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
2141   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
2142   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
2143
2144   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
2145   arg2 = (void (*)(Dali::Animation &))jarg2;
2146   {
2147     try {
2148       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
2149     } catch (std::out_of_range& e) {
2150       {
2151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2152       };
2153     } catch (std::exception& e) {
2154       {
2155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2156       };
2157     } catch (...) {
2158       {
2159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2160       };
2161     }
2162   }
2163 }
2164
2165
2166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
2167   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
2168   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
2169
2170   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
2171   arg2 = (void (*)(Dali::Animation &))jarg2;
2172   {
2173     try {
2174       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
2175     } catch (std::out_of_range& e) {
2176       {
2177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2178       };
2179     } catch (std::exception& e) {
2180       {
2181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2182       };
2183     } catch (...) {
2184       {
2185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2186       };
2187     }
2188   }
2189 }
2190
2191
2192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
2193   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
2194   Dali::Animation *arg2 = 0 ;
2195
2196   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
2197   arg2 = (Dali::Animation *)jarg2;
2198   if (!arg2) {
2199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
2200     return ;
2201   }
2202   {
2203     try {
2204       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
2205     } catch (std::out_of_range& e) {
2206       {
2207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2208       };
2209     } catch (std::exception& e) {
2210       {
2211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2212       };
2213     } catch (...) {
2214       {
2215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2216       };
2217     }
2218   }
2219 }
2220
2221
2222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
2223   void * jresult ;
2224   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
2225
2226   {
2227     try {
2228       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
2229     } catch (std::out_of_range& e) {
2230       {
2231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2232       };
2233     } catch (std::exception& e) {
2234       {
2235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2236       };
2237     } catch (...) {
2238       {
2239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2240       };
2241     }
2242   }
2243   jresult = (void *)result;
2244   return jresult;
2245 }
2246
2247
2248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
2249   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
2250
2251   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
2252   {
2253     try {
2254       delete arg1;
2255     } catch (std::out_of_range& e) {
2256       {
2257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2258       };
2259     } catch (std::exception& e) {
2260       {
2261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2262       };
2263     } catch (...) {
2264       {
2265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2266       };
2267     }
2268   }
2269 }
2270
2271
2272 #ifdef __cplusplus
2273 }
2274 #endif
2275