dali-csharp-binder/src/control-devel-wrap.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // EXTERNAL INCLUDES
  19 #include <dali/devel-api/adaptor-framework/accessibility-bridge.h>
  20 #include <dali/devel-api/adaptor-framework/accessibility.h>
  21 #include <vector>
  22
  23 // INTERNAL INCLUDES
  24 #include "control-devel-wrap.h"
  25
  26 using namespace Dali::Toolkit::DevelControl;
  27
  28 #ifdef __cplusplus
  29 extern "C" {
  30 #endif
  31
  32 // property
  33 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_DISPATCH_KEY_EVENTS_get()
  34 {
  35   return (int)Dali::Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS;
  36 }
  37
  38 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityActivateSignal(void* arg1)
  39 {
  40   Dali::Toolkit::DevelControl::AccessibilityActivateSignalType* result = nullptr;
  41   GUARD_ON_NULL_RET0(arg1);
  42   try_catch(([&]() {
  43     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
  44     result                          = &(AccessibilityActivateSignal(*control));
  45   }));
  46   return (void*)result;
  47 }
  48
  49 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingSkippedSignal(void* arg1)
  50 {
  51   Dali::Toolkit::DevelControl::AccessibilityReadingSkippedSignalType* result = nullptr;
  52   GUARD_ON_NULL_RET0(arg1);
  53   try_catch(([&]() {
  54     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
  55     result                          = &(AccessibilityReadingSkippedSignal(*control));
  56   }));
  57   return (void*)result;
  58 }
  59
  60 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingPausedSignal(void* arg1)
  61 {
  62   Dali::Toolkit::DevelControl::AccessibilityReadingPausedSignalType* result = nullptr;
  63   GUARD_ON_NULL_RET0(arg1);
  64   try_catch(([&]() {
  65     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
  66     result                          = &(AccessibilityReadingPausedSignal(*control));
  67   }));
  68   return (void*)result;
  69 }
  70
  71 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingResumedSignal(void* arg1)
  72 {
  73   Dali::Toolkit::DevelControl::AccessibilityReadingResumedSignalType* result = nullptr;
  74   GUARD_ON_NULL_RET0(arg1);
  75   try_catch(([&]() {
  76     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
  77     result                          = &(AccessibilityReadingResumedSignal(*control));
  78   }));
  79   return (void*)result;
  80 }
  81
  82 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingCancelledSignal(void* arg1)
  83 {
  84   Dali::Toolkit::DevelControl::AccessibilityReadingCancelledSignalType* result = nullptr;
  85   GUARD_ON_NULL_RET0(arg1);
  86   try_catch(([&]() {
  87     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
  88     result                          = &(AccessibilityReadingCancelledSignal(*control));
  89   }));
  90   return (void*)result;
  91 }
  92
  93 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityReadingStoppedSignal(void* arg1)
  94 {
  95   Dali::Toolkit::DevelControl::AccessibilityReadingStoppedSignalType* result = nullptr;
  96   GUARD_ON_NULL_RET0(arg1);
  97   try_catch(([&]() {
  98     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
  99     result                          = &(AccessibilityReadingStoppedSignal(*control));
 100   }));
 101   return (void*)result;
 102 }
 103
 104 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityGetNameSignal(void* arg1)
 105 {
 106   Dali::Toolkit::DevelControl::AccessibilityGetNameSignalType* result = nullptr;
 107   GUARD_ON_NULL_RET0(arg1);
 108   try_catch(([&]() {
 109     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
 110     result                          = &(AccessibilityGetNameSignal(*control));
 111   }));
 112   return (void*)result;
 113 }
 114
 115 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityGetDescriptionSignal(void* arg1)
 116 {
 117   Dali::Toolkit::DevelControl::AccessibilityGetDescriptionSignalType* result = nullptr;
 118   GUARD_ON_NULL_RET0(arg1);
 119   try_catch(([&]() {
 120     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
 121     result                          = &(AccessibilityGetDescriptionSignal(*control));
 122   }));
 123   return (void*)result;
 124 }
 125
 126 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AccessibilityDoGestureSignal(void* arg1)
 127 {
 128   Dali::Toolkit::DevelControl::AccessibilityDoGestureSignalType* result = nullptr;
 129   GUARD_ON_NULL_RET0(arg1);
 130   try_catch(([&]() {
 131     Dali::Toolkit::Control* control = (Dali::Toolkit::Control*)arg1;
 132     result                          = &(AccessibilityDoGestureSignal(*control));
 133   }));
 134   return (void*)result;
 135 }
 136
 137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AppendAccessibilityRelation(void* arg1, void* arg2, int arg3)
 138 {
 139   GUARD_ON_NULL_RET(arg1);
 140   GUARD_ON_NULL_RET(arg2);
 141   try_catch(([&]() {
 142     auto* control     = (Dali::Toolkit::Control*)arg1;
 143     auto* destination = (Dali::Actor*)arg2;
 144     auto  relation    = (Dali::Accessibility::RelationType)arg3;
 145     AppendAccessibilityRelation(*control, *destination, relation);
 146   }));
 147 }
 148
 149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_RemoveAccessibilityRelation(void* arg1, void* arg2, int arg3)
 150 {
 151   GUARD_ON_NULL_RET(arg1);
 152   GUARD_ON_NULL_RET(arg2);
 153   try_catch(([&]() {
 154     auto* control     = (Dali::Toolkit::Control*)arg1;
 155     auto* destination = (Dali::Actor*)arg2;
 156     auto  relation    = (Dali::Accessibility::RelationType)arg3;
 157     RemoveAccessibilityRelation(*control, *destination, relation);
 158   }));
 159 }
 160
 161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityRelations(void* arg1_control,
 162                                                                                        void (*arg2_callback)(int, void*, void*),
 163                                                                                        void* arg3_userData)
 164 {
 165   using namespace Dali::Accessibility;
 166
 167   GUARD_ON_NULL_RET(arg1_control);
 168   GUARD_ON_NULL_RET(arg2_callback);
 169
 170   try_catch(([&]() {
 171     auto*                 control   = static_cast<Dali::Toolkit::Control*>(arg1_control);
 172     std::vector<Relation> relations = GetAccessibilityRelations(*control);
 173
 174     for(Relation& relation : relations)
 175     {
 176       for(Accessible* target : relation.mTargets)
 177       {
 178         // NUI is unaware of Accessible objects, so we only report those
 179         // convertible to Control. Note that it is currently impossible to make
 180         // a relation with anything other than Control (View) using NUI API, so
 181         // there should not be any loss of information for typical NUI
 182         // applications.
 183         auto targetControl = Dali::Toolkit::Control::DownCast(target->GetInternalActor());
 184
 185         if(targetControl)
 186         {
 187           arg2_callback(static_cast<int>(relation.mRelationType),
 188                         static_cast<void*>(new Dali::Actor(targetControl)),
 189                         arg3_userData);
 190         }
 191       }
 192     }
 193   }));
 194 }
 195
 196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_ClearAccessibilityRelations(void* arg1)
 197 {
 198   GUARD_ON_NULL_RET(arg1);
 199   try_catch(([&]() {
 200     auto* control = (Dali::Toolkit::Control*)arg1;
 201     ClearAccessibilityRelations(*control);
 202   }));
 203 }
 204
 205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_AppendAccessibilityAttribute(void* arg1, char* arg2, char* arg3)
 206 {
 207   GUARD_ON_NULL_RET(arg1);
 208   GUARD_ON_NULL_RET(arg2);
 209   GUARD_ON_NULL_RET(arg3);
 210   try_catch(([&]() {
 211     auto*             control = (Dali::Toolkit::Control*)arg1;
 212     const std::string key(arg2);
 213     const std::string value(arg3);
 214     AppendAccessibilityAttribute(*control, key, value);
 215   }));
 216 }
 217
 218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_RemoveAccessibilityAttribute(void* arg1, char* arg2)
 219 {
 220   GUARD_ON_NULL_RET(arg1);
 221   GUARD_ON_NULL_RET(arg2);
 222   try_catch(([&]() {
 223     auto*             control = (Dali::Toolkit::Control*)arg1;
 224     const std::string key(arg2);
 225     RemoveAccessibilityAttribute(*control, key);
 226   }));
 227 }
 228
 229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_ClearAccessibilityAttributes(void* arg1)
 230 {
 231   GUARD_ON_NULL_RET(arg1);
 232   try_catch(([&]() {
 233     auto* control = (Dali::Toolkit::Control*)arg1;
 234     ClearAccessibilityAttributes(*control);
 235   }));
 236 }
 237
 238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_SetAccessibilityReadingInfoType2(void* arg1, int arg2)
 239 {
 240   using namespace Dali::Accessibility;
 241   static_assert(static_cast<int>(ReadingInfoType::NAME) == 0 &&
 242                   static_cast<int>(ReadingInfoType::ROLE) == 1 &&
 243                   static_cast<int>(ReadingInfoType::DESCRIPTION) == 2 &&
 244                   static_cast<int>(ReadingInfoType::STATE) == 3,
 245                 "C++ and C# bindings does not match");
 246
 247   GUARD_ON_NULL_RET(arg1);
 248   try_catch(([&]() {
 249     auto* control = (Dali::Toolkit::Control*)arg1;
 250     SetAccessibilityReadingInfoType(*control, ReadingInfoTypes{static_cast<std::uint32_t>(arg2)});
 251   }));
 252 }
 253
 254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityReadingInfoType2(void* arg1)
 255 {
 256   int result = 0;
 257   GUARD_ON_NULL_RET0(arg1);
 258   try_catch(([&]() {
 259     auto* control     = (Dali::Toolkit::Control*)arg1;
 260     auto  readingInfo = GetAccessibilityReadingInfoType(*control);
 261     result            = readingInfo.GetRawData()[0];
 262   }));
 263   return result;
 264 }
 265
 266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_ClearAccessibilityHighlight(void* arg1)
 267 {
 268   bool result = false;
 269   GUARD_ON_NULL_RET0(arg1);
 270   try_catch(([&]() {
 271     auto* control = (Dali::Toolkit::Control*)arg1;
 272     result        = ClearAccessibilityHighlight(*control);
 273   }));
 274   return result;
 275 }
 276
 277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GrabAccessibilityHighlight(void* arg1)
 278 {
 279   bool result = false;
 280   GUARD_ON_NULL_RET0(arg1);
 281   try_catch(([&]() {
 282     auto* control = (Dali::Toolkit::Control*)arg1;
 283     result        = GrabAccessibilityHighlight(*control);
 284   }));
 285   return result;
 286 }
 287
 288 SWIGEXPORT uint64_t SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_GetAccessibilityStates(void* arg1)
 289 {
 290   uint64_t result = 0;
 291   GUARD_ON_NULL_RET0(arg1);
 292   try_catch(([&]() {
 293     auto* control = (Dali::Toolkit::Control*)arg1;
 294     auto  states  = GetAccessibilityStates(*control);
 295     result        = states.GetRawData64();
 296   }));
 297   return result;
 298 }
 299
 300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Toolkit_DevelControl_NotifyAccessibilityStateChange(void* arg1, uint64_t arg2, int arg3)
 301 {
 302   GUARD_ON_NULL_RET(arg1);
 303   try_catch(([&]() {
 304     Dali::Accessibility::States states(arg2);
 305     auto*                       control = (Dali::Toolkit::Control*)arg1;
 306     NotifyAccessibilityStateChange(*control, states, static_cast<bool>(arg3));
 307   }));
 308 }
 309
 310 /***********************************************
 311  **************** Accessibility ****************
 312  ***********************************************/
 313
 314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitAccessibilityEvent(void* arg1, int arg2_event)
 315 {
 316   GUARD_ON_NULL_RET(arg1);
 317   try_catch(([&]() {
 318     Dali::Actor* control    = (Dali::Actor*)arg1;
 319     auto         accessible = Dali::Accessibility::Accessible::Get(*control);
 320     if(accessible)
 321     {
 322       accessible->Emit((Dali::Accessibility::ObjectPropertyChangeEvent)arg2_event);
 323     }
 324     else
 325     {
 326       SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object.");
 327     }
 328   }));
 329 }
 330
 331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitAccessibilityStateChangedEvent(void* arg1, int arg2_state, int arg3)
 332 {
 333   GUARD_ON_NULL_RET(arg1);
 334   try_catch(([&]() {
 335     auto state = static_cast<Dali::Accessibility::State>(arg2_state);
 336
 337     Dali::Actor* control    = (Dali::Actor*)arg1;
 338     auto         accessible = Dali::Accessibility::Accessible::Get(*control);
 339     if(accessible)
 340     {
 341       accessible->EmitStateChanged(state, arg3);
 342     }
 343     else
 344     {
 345       SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object.");
 346     }
 347   }));
 348 }
 349
 350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextInsertedEvent(
 351   void* arg1, int arg2_position, int arg3_length, char* arg4_content)
 352 {
 353   GUARD_ON_NULL_RET(arg1);
 354   try_catch(([&]() {
 355     Dali::Actor* control    = (Dali::Actor*)arg1;
 356     auto         accessible = Dali::Accessibility::Accessible::Get(*control);
 357     std::string  content(arg4_content ? arg4_content : "");
 358     if(accessible)
 359     {
 360       accessible->EmitTextInserted(arg2_position, arg3_length, content);
 361     }
 362     else
 363     {
 364       SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object.");
 365     }
 366   }));
 367 }
 368
 369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextDeletedEvent(
 370   void* arg1, int arg2_position, int arg3_length, char* arg4_content)
 371 {
 372   GUARD_ON_NULL_RET(arg1);
 373   try_catch(([&]() {
 374     Dali::Actor* control    = (Dali::Actor*)arg1;
 375     auto         accessible = Dali::Accessibility::Accessible::Get(*control);
 376     std::string  content(arg4_content ? arg4_content : "");
 377     if(accessible)
 378     {
 379       accessible->EmitTextDeleted(arg2_position, arg3_length, content);
 380     }
 381     else
 382     {
 383       SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object.");
 384     }
 385   }));
 386 }
 387
 388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_EmitTextCursorMovedEvent(
 389   void* arg1, int arg2_position)
 390 {
 391   GUARD_ON_NULL_RET(arg1);
 392   try_catch(([&]() {
 393     Dali::Actor* control    = (Dali::Actor*)arg1;
 394     auto         accessible = Dali::Accessibility::Accessible::Get(*control);
 395     if(accessible)
 396     {
 397       accessible->EmitTextCursorMoved(arg2_position);
 398     }
 399     else
 400     {
 401       SWIG_CSharpException(SWIG_RuntimeError, "Actor does not have accessible object.");
 402     }
 403   }));
 404 }
 405
 406 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Accessibility_IsSuppressedEvent(void* arg1, int32_t atspiEvent)
 407 {
 408   bool result = false;
 409   GUARD_ON_NULL_RET0(arg1);
 410   try_catch(([&]() {
 411     Dali::Actor* control    = (Dali::Actor*)arg1;
 412     auto         accessible = Dali::Accessibility::Accessible::Get(*control);
 413     if(accessible)
 414     {
 415       result = accessible->GetSuppressedEvents()[static_cast<Dali::Accessibility::AtspiEvent>(atspiEvent)];
 416     }
 417   }));
 418   return result;
 419 }
 420
 421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_SetSuppressedEvent(void* arg1, int32_t atspiEvent, bool isSuppressed)
 422 {
 423   GUARD_ON_NULL_RET(arg1);
 424   try_catch(([&]() {
 425     Dali::Actor* control    = (Dali::Actor*)arg1;
 426     auto         accessible = Dali::Accessibility::Accessible::Get(*control);
 427     if(accessible)
 428     {
 429       accessible->GetSuppressedEvents()[static_cast<Dali::Accessibility::AtspiEvent>(atspiEvent)] = isSuppressed;
 430     }
 431   }));
 432 }
 433
 434 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_new_Range(
 435   int arg1_start, int arg2_end, char* arg3_content)
 436 {
 437   Dali::Accessibility::Range* result = nullptr;
 438   try_catch(([&]() {
 439     result = new Dali::Accessibility::Range(arg1_start, arg2_end, arg3_content);
 440   }));
 441   return (void*)result;
 442 }
 443
 444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_delete_Range(void* arg1_range)
 445 {
 446   try_catch(([&]() {
 447     delete static_cast<Dali::Accessibility::Range*>(arg1_range);
 448   }));
 449 }
 450
 451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Bridge_RegisterDefaultLabel(void* arg1_actor)
 452 {
 453   GUARD_ON_NULL_RET(arg1_actor);
 454   try_catch(([&]() {
 455     Dali::Actor* actor      = (Dali::Actor*)arg1_actor;
 456     auto         accessible = Dali::Accessibility::Accessible::Get(*actor);
 457     auto         bridge     = Dali::Accessibility::Bridge::GetCurrentBridge();
 458
 459     if(!accessible)
 460     {
 461       SWIG_CSharpException(SWIG_RuntimeError, "No accessible object bind with actor.");
 462       return;
 463     }
 464
 465     bridge->RegisterDefaultLabel(accessible);
 466   }));
 467 }
 468
 469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Bridge_UnregisterDefaultLabel(void* arg1_actor)
 470 {
 471   GUARD_ON_NULL_RET(arg1_actor);
 472   try_catch(([&]() {
 473     Dali::Actor* actor      = (Dali::Actor*)arg1_actor;
 474     auto         accessible = Dali::Accessibility::Accessible::Get(*actor);
 475     auto         bridge     = Dali::Accessibility::Bridge::GetCurrentBridge();
 476
 477     if(!accessible)
 478     {
 479       SWIG_CSharpException(SWIG_RuntimeError, "No accessible object bind with actor.");
 480       return;
 481     }
 482
 483     bridge->UnregisterDefaultLabel(accessible);
 484   }));
 485 }
 486
 487 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_GetCurrentlyHighlightedActor()
 488 {
 489   Dali::Actor* result = NULL;
 490   try_catch(([&]() {
 491     Dali::Actor actor = Dali::Accessibility::Accessible::GetCurrentlyHighlightedActor();
 492     if(actor)
 493     {
 494       result = new Dali::Actor(actor);
 495     }
 496   }));
 497   return result;
 498 }
 499
 500 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_GetHighlightActor()
 501 {
 502   Dali::Actor* result = NULL;
 503   try_catch(([&]() {
 504     Dali::Actor actor = Dali::Accessibility::Accessible::GetHighlightActor();
 505     if(actor)
 506     {
 507       result = new Dali::Actor(actor);
 508     }
 509   }));
 510   return result;
 511 }
 512
 513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Accessibility_Accessible_SetHighlightActor(void* arg1_actor)
 514 {
 515   // Passing nullptr as actor is used to remove custom highlight,
 516   // what leads to the restoration of default highlight starting
 517   // from next call to GrabHighlight()
 518   try_catch(([&]() {
 519     Dali::Actor actor = arg1_actor ? *((Dali::Actor*)arg1_actor) : Dali::Actor();
 520     Dali::Accessibility::Accessible::SetHighlightActor(actor);
 521   }));
 522 }
 523
 524 #ifdef __cplusplus
 525 } // extern "C"
 526 #endif