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

   1 /*
   2  * Copyright (c) 2023 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // EXTERNAL INCLUDES
  19 #include <dali/public-api/actors/layer.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali-csharp-binder/common/common.h>
  23
  24 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
  25
  26 using namespace Dali;
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 // Property
  33
  34 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get()
  35 {
  36   int jresult;
  37   int result;
  38
  39   result  = (int)Dali::Layer::Property::CLIPPING_ENABLE;
  40   jresult = (int)result;
  41   return jresult;
  42 }
  43
  44 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get()
  45 {
  46   int jresult;
  47   int result;
  48
  49   result  = (int)Dali::Layer::Property::CLIPPING_BOX;
  50   jresult = (int)result;
  51   return jresult;
  52 }
  53
  54 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get()
  55 {
  56   int jresult;
  57   int result;
  58
  59   result  = (int)Dali::Layer::Property::BEHAVIOR;
  60   jresult = (int)result;
  61   return jresult;
  62 }
  63
  64 // Creation
  65
  66 SWIGEXPORT Dali::Actor* SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer* jarg1)
  67 {
  68   return (Dali::Actor*)jarg1;
  69 }
  70
  71 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer_Property()
  72 {
  73   void*                  jresult;
  74   Dali::Layer::Property* result = 0;
  75
  76   {
  77     try
  78     {
  79       result = (Dali::Layer::Property*)new Dali::Layer::Property();
  80     }
  81     CALL_CATCH_EXCEPTION(0);
  82   }
  83
  84   jresult = (void*)result;
  85   return jresult;
  86 }
  87
  88 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void* jarg1)
  89 {
  90   Dali::Layer::Property* arg1 = (Dali::Layer::Property*)0;
  91
  92   arg1 = (Dali::Layer::Property*)jarg1;
  93   {
  94     try
  95     {
  96       delete arg1;
  97     }
  98     CALL_CATCH_EXCEPTION();
  99   }
 100 }
 101
 102 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0()
 103 {
 104   void*        jresult;
 105   Dali::Layer* result = 0;
 106
 107   {
 108     try
 109     {
 110       result = (Dali::Layer*)new Dali::Layer();
 111     }
 112     CALL_CATCH_EXCEPTION(0);
 113   }
 114
 115   jresult = (void*)result;
 116   return jresult;
 117 }
 118
 119 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_New()
 120 {
 121   void*       jresult;
 122   Dali::Layer result;
 123
 124   {
 125     try
 126     {
 127       result = Dali::Layer::New();
 128     }
 129     CALL_CATCH_EXCEPTION(0);
 130   }
 131
 132   jresult = new Dali::Layer((const Dali::Layer&)result);
 133   return jresult;
 134 }
 135
 136 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_DownCast(void* jarg1)
 137 {
 138   void*             jresult;
 139   Dali::BaseHandle  arg1;
 140   Dali::BaseHandle* argp1;
 141   Dali::Layer       result;
 142
 143   argp1 = (Dali::BaseHandle*)jarg1;
 144   if(!argp1)
 145   {
 146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
 147     return 0;
 148   }
 149   arg1 = *argp1;
 150   {
 151     try
 152     {
 153       result = Dali::Layer::DownCast(arg1);
 154     }
 155     CALL_CATCH_EXCEPTION(0);
 156   }
 157
 158   jresult = new Dali::Layer((const Dali::Layer&)result);
 159   return jresult;
 160 }
 161
 162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void* jarg1)
 163 {
 164   Dali::Layer* arg1 = (Dali::Layer*)0;
 165
 166   arg1 = (Dali::Layer*)jarg1;
 167   {
 168     try
 169     {
 170       delete arg1;
 171     }
 172     CALL_CATCH_EXCEPTION();
 173   }
 174 }
 175
 176 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void* jarg1)
 177 {
 178   void*        jresult;
 179   Dali::Layer* arg1   = 0;
 180   Dali::Layer* result = 0;
 181
 182   arg1 = (Dali::Layer*)jarg1;
 183   if(!arg1)
 184   {
 185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
 186     return 0;
 187   }
 188   {
 189     try
 190     {
 191       result = (Dali::Layer*)new Dali::Layer((Dali::Layer const&)*arg1);
 192     }
 193     CALL_CATCH_EXCEPTION(0);
 194   }
 195
 196   jresult = (void*)result;
 197   return jresult;
 198 }
 199
 200 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_Assign(void* jarg1, void* jarg2)
 201 {
 202   void*        jresult;
 203   Dali::Layer* arg1   = (Dali::Layer*)0;
 204   Dali::Layer* arg2   = 0;
 205   Dali::Layer* result = 0;
 206
 207   arg1 = (Dali::Layer*)jarg1;
 208   arg2 = (Dali::Layer*)jarg2;
 209   if(!arg2)
 210   {
 211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
 212     return 0;
 213   }
 214   {
 215     try
 216     {
 217       result = (Dali::Layer*)&(arg1)->operator=((Dali::Layer const&)*arg2);
 218     }
 219     CALL_CATCH_EXCEPTION(0);
 220   }
 221
 222   jresult = (void*)result;
 223   return jresult;
 224 }
 225
 226 // Method
 227
 228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void* jarg1)
 229 {
 230   unsigned int jresult;
 231   Dali::Layer* arg1 = (Dali::Layer*)0;
 232   unsigned int result;
 233
 234   arg1 = (Dali::Layer*)jarg1;
 235   {
 236     try
 237     {
 238       result = (unsigned int)((Dali::Layer const*)arg1)->GetProperty<int>(Layer::Property::DEPTH);
 239     }
 240     CALL_CATCH_EXCEPTION(0);
 241   }
 242
 243   jresult = result;
 244   return jresult;
 245 }
 246
 247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void* jarg1)
 248 {
 249   Dali::Layer* arg1 = (Dali::Layer*)0;
 250
 251   arg1 = (Dali::Layer*)jarg1;
 252   {
 253     try
 254     {
 255       (arg1)->Raise();
 256     }
 257     CALL_CATCH_EXCEPTION();
 258   }
 259 }
 260
 261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void* jarg1)
 262 {
 263   Dali::Layer* arg1 = (Dali::Layer*)0;
 264
 265   arg1 = (Dali::Layer*)jarg1;
 266   {
 267     try
 268     {
 269       (arg1)->Lower();
 270     }
 271     CALL_CATCH_EXCEPTION();
 272   }
 273 }
 274
 275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void* jarg1, void* jarg2)
 276 {
 277   Dali::Layer* arg1 = (Dali::Layer*)0;
 278   Dali::Layer  arg2;
 279   Dali::Layer* argp2;
 280
 281   arg1  = (Dali::Layer*)jarg1;
 282   argp2 = (Dali::Layer*)jarg2;
 283   if(!argp2)
 284   {
 285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
 286     return;
 287   }
 288   arg2 = *argp2;
 289   {
 290     try
 291     {
 292       (arg1)->RaiseAbove(arg2);
 293     }
 294     CALL_CATCH_EXCEPTION();
 295   }
 296 }
 297
 298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void* jarg1, void* jarg2)
 299 {
 300   Dali::Layer* arg1 = (Dali::Layer*)0;
 301   Dali::Layer  arg2;
 302   Dali::Layer* argp2;
 303
 304   arg1  = (Dali::Layer*)jarg1;
 305   argp2 = (Dali::Layer*)jarg2;
 306   if(!argp2)
 307   {
 308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
 309     return;
 310   }
 311   arg2 = *argp2;
 312   {
 313     try
 314     {
 315       (arg1)->LowerBelow(arg2);
 316     }
 317     CALL_CATCH_EXCEPTION();
 318   }
 319 }
 320
 321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void* jarg1)
 322 {
 323   Dali::Layer* arg1 = (Dali::Layer*)0;
 324
 325   arg1 = (Dali::Layer*)jarg1;
 326   {
 327     try
 328     {
 329       (arg1)->RaiseToTop();
 330     }
 331     CALL_CATCH_EXCEPTION();
 332   }
 333 }
 334
 335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void* jarg1)
 336 {
 337   Dali::Layer* arg1 = (Dali::Layer*)0;
 338
 339   arg1 = (Dali::Layer*)jarg1;
 340   {
 341     try
 342     {
 343       (arg1)->LowerToBottom();
 344     }
 345     CALL_CATCH_EXCEPTION();
 346   }
 347 }
 348
 349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void* jarg1, void* jarg2)
 350 {
 351   Dali::Layer* arg1 = (Dali::Layer*)0;
 352   Dali::Layer  arg2;
 353   Dali::Layer* argp2;
 354
 355   arg1  = (Dali::Layer*)jarg1;
 356   argp2 = (Dali::Layer*)jarg2;
 357   if(!argp2)
 358   {
 359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
 360     return;
 361   }
 362   arg2 = *argp2;
 363   {
 364     try
 365     {
 366       (arg1)->MoveAbove(arg2);
 367     }
 368     CALL_CATCH_EXCEPTION();
 369   }
 370 }
 371
 372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void* jarg1, void* jarg2)
 373 {
 374   Dali::Layer* arg1 = (Dali::Layer*)0;
 375   Dali::Layer  arg2;
 376   Dali::Layer* argp2;
 377
 378   arg1  = (Dali::Layer*)jarg1;
 379   argp2 = (Dali::Layer*)jarg2;
 380   if(!argp2)
 381   {
 382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
 383     return;
 384   }
 385   arg2 = *argp2;
 386   {
 387     try
 388     {
 389       (arg1)->MoveBelow(arg2);
 390     }
 391     CALL_CATCH_EXCEPTION();
 392   }
 393 }
 394
 395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void* jarg1, int jarg2)
 396 {
 397   Dali::Layer*          arg1 = (Dali::Layer*)0;
 398   Dali::Layer::Behavior arg2;
 399
 400   arg1 = (Dali::Layer*)jarg1;
 401   arg2 = (Dali::Layer::Behavior)jarg2;
 402   {
 403     try
 404     {
 405       (arg1)->SetProperty(Layer::Property::BEHAVIOR, arg2);
 406     }
 407     CALL_CATCH_EXCEPTION();
 408   }
 409 }
 410
 411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void* jarg1)
 412 {
 413   int                   jresult;
 414   Dali::Layer*          arg1 = (Dali::Layer*)0;
 415   Dali::Layer::Behavior result;
 416
 417   arg1 = (Dali::Layer*)jarg1;
 418   {
 419     try
 420     {
 421       result = (Dali::Layer::Behavior)((Dali::Layer const*)arg1)->GetProperty<Dali::Layer::Behavior>(Dali::Layer::Property::BEHAVIOR);
 422     }
 423     CALL_CATCH_EXCEPTION(0);
 424   }
 425
 426   jresult = (int)result;
 427   return jresult;
 428 }
 429
 430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void* jarg1, bool jarg2)
 431 {
 432   Dali::Layer* arg1 = (Dali::Layer*)0;
 433   bool         arg2;
 434
 435   arg1 = (Dali::Layer*)jarg1;
 436   arg2 = jarg2 ? true : false;
 437   {
 438     try
 439     {
 440       (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_ENABLE, arg2);
 441     }
 442     CALL_CATCH_EXCEPTION();
 443   }
 444 }
 445
 446 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void* jarg1)
 447 {
 448   bool         jresult;
 449   Dali::Layer* arg1 = (Dali::Layer*)0;
 450   bool         result;
 451
 452   arg1 = (Dali::Layer*)jarg1;
 453   {
 454     try
 455     {
 456       result = (bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Dali::Layer::Property::CLIPPING_ENABLE);
 457     }
 458     CALL_CATCH_EXCEPTION(0);
 459   }
 460
 461   jresult = result;
 462   return jresult;
 463 }
 464
 465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5)
 466 {
 467   Dali::Layer* arg1 = (Dali::Layer*)0;
 468   int          arg2;
 469   int          arg3;
 470   int          arg4;
 471   int          arg5;
 472
 473   arg1 = (Dali::Layer*)jarg1;
 474   arg2 = (int)jarg2;
 475   arg3 = (int)jarg3;
 476   arg4 = (int)jarg4;
 477   arg5 = (int)jarg5;
 478   {
 479     try
 480     {
 481       (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>(arg2, arg3, arg4, arg5));
 482     }
 483     CALL_CATCH_EXCEPTION();
 484   }
 485 }
 486
 487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void* jarg1, void* jarg2)
 488 {
 489   Dali::Layer*       arg1 = (Dali::Layer*)0;
 490   Dali::ClippingBox  arg2;
 491   Dali::ClippingBox* argp2;
 492
 493   arg1  = (Dali::Layer*)jarg1;
 494   argp2 = (Dali::ClippingBox*)jarg2;
 495   if(!argp2)
 496   {
 497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
 498     return;
 499   }
 500   arg2 = *argp2;
 501   {
 502     try
 503     {
 504       (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, arg2);
 505     }
 506     CALL_CATCH_EXCEPTION();
 507   }
 508 }
 509
 510 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void* jarg1)
 511 {
 512   void*             jresult;
 513   Dali::Layer*      arg1 = (Dali::Layer*)0;
 514   Dali::ClippingBox result;
 515
 516   arg1 = (Dali::Layer*)jarg1;
 517   {
 518     try
 519     {
 520       result = ((Dali::Layer const*)arg1)->GetProperty<Rect<int32_t> >(Layer::Property::CLIPPING_BOX);
 521     }
 522     CALL_CATCH_EXCEPTION(0);
 523   }
 524
 525   jresult = new Dali::ClippingBox((const Dali::ClippingBox&)result);
 526   return jresult;
 527 }
 528
 529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void* jarg1, bool jarg2)
 530 {
 531   Dali::Layer* arg1 = (Dali::Layer*)0;
 532   bool         arg2;
 533
 534   arg1 = (Dali::Layer*)jarg1;
 535   arg2 = jarg2 ? true : false;
 536   {
 537     try
 538     {
 539       (arg1)->SetProperty(Layer::Property::DEPTH_TEST, !arg2);
 540     }
 541     CALL_CATCH_EXCEPTION();
 542   }
 543 }
 544
 545 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void* jarg1)
 546 {
 547   bool         jresult;
 548   Dali::Layer* arg1 = (Dali::Layer*)0;
 549   bool         result;
 550
 551   arg1 = (Dali::Layer*)jarg1;
 552   {
 553     try
 554     {
 555       result = !(bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Layer::Property::DEPTH_TEST);
 556     }
 557     CALL_CATCH_EXCEPTION(0);
 558   }
 559
 560   jresult = result;
 561   return jresult;
 562 }
 563
 564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void* jarg1, void* jarg2)
 565 {
 566   Dali::Layer*                  arg1 = (Dali::Layer*)0;
 567   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType)0;
 568
 569   arg1 = (Dali::Layer*)jarg1;
 570   arg2 = (Dali::Layer::SortFunctionType)jarg2;
 571   {
 572     try
 573     {
 574       (arg1)->SetSortFunction(arg2);
 575     }
 576     CALL_CATCH_EXCEPTION();
 577   }
 578 }
 579
 580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void* jarg1, bool jarg2)
 581 {
 582   Dali::Layer* arg1 = (Dali::Layer*)0;
 583   bool         arg2;
 584
 585   arg1 = (Dali::Layer*)jarg1;
 586   arg2 = jarg2 ? true : false;
 587   {
 588     try
 589     {
 590       (arg1)->SetProperty(Layer::Property::CONSUMES_TOUCH, arg2);
 591     }
 592     CALL_CATCH_EXCEPTION();
 593   }
 594 }
 595
 596 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void* jarg1)
 597 {
 598   bool         jresult;
 599   Dali::Layer* arg1 = (Dali::Layer*)0;
 600   bool         result;
 601
 602   arg1 = (Dali::Layer*)jarg1;
 603   {
 604     try
 605     {
 606       result = (bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Layer::Property::CONSUMES_TOUCH);
 607     }
 608     CALL_CATCH_EXCEPTION(0);
 609   }
 610
 611   jresult = result;
 612   return jresult;
 613 }
 614
 615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void* jarg1, bool jarg2)
 616 {
 617   Dali::Layer* arg1 = (Dali::Layer*)0;
 618   bool         arg2;
 619
 620   arg1 = (Dali::Layer*)jarg1;
 621   arg2 = jarg2 ? true : false;
 622   {
 623     try
 624     {
 625       (arg1)->SetProperty(Layer::Property::CONSUMES_HOVER, arg2);
 626     }
 627     CALL_CATCH_EXCEPTION();
 628   }
 629 }
 630
 631 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void* jarg1)
 632 {
 633   bool         jresult;
 634   Dali::Layer* arg1 = (Dali::Layer*)0;
 635   bool         result;
 636
 637   arg1 = (Dali::Layer*)jarg1;
 638   {
 639     try
 640     {
 641       result = (bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Layer::Property::CONSUMES_HOVER);
 642     }
 643     CALL_CATCH_EXCEPTION(0);
 644   }
 645
 646   jresult = result;
 647   return jresult;
 648 }
 649
 650 #ifdef __cplusplus
 651 }
 652 #endif