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