src/Tizen.NUI/src/public/Accessibility/AccessibilityManager.cs

   1 /*
   2  * Copyright(c) 2020 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 using System;
  18 using System.ComponentModel;
  19 using Tizen.NUI.BaseComponents;
  20
  21 namespace Tizen.NUI.Accessibility
  22 {
  23     /// <summary>
  24     /// AccessibilityManager manages registration of views in an accessibility focus chain and changing the focused view within that chain.
  25     /// This class provides the functionality of registering the focus order and description of views and maintaining the focus chain.
  26     /// It provides functionality of setting the focus and moving the focus forward and backward.
  27     ///  It also draws a highlight for the focused view and emits a signal when the focus is changed.
  28     /// </summary>
  29     /// <since_tizen> 6 </since_tizen>
  30     /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  31     [EditorBrowsable(EditorBrowsableState.Never)]
  32     public partial class AccessibilityManager : BaseHandle
  33     {
  34         private static readonly AccessibilityManager instance = AccessibilityManager.Get();
  35
  36         internal AccessibilityManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(Interop.AccessibilityManager.Upcast(cPtr), cMemoryOwn)
  37         {
  38         }
  39
  40         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(AccessibilityManager obj)
  41         {
  42             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  43         }
  44
  45         /// This will not be public opened.
  46         [EditorBrowsable(EditorBrowsableState.Never)]
  47         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
  48         {
  49             Interop.AccessibilityManager.DeleteAccessibilityManager(swigCPtr);
  50         }
  51
  52         // Callback for AccessibilityManager StatusChangedSignal
  53         private bool OnStatusChanged(IntPtr data)
  54         {
  55             if (_accessibilityManagerStatusChangedEventHandler != null)
  56             {
  57                 //here we send all data to user event handlers
  58                 return _accessibilityManagerStatusChangedEventHandler(instance, null);
  59             }
  60             return false;
  61         }
  62
  63         // Callback for AccessibilityManager ActionNextSignal
  64         private bool OnActionNext(IntPtr data)
  65         {
  66             if (_accessibilityManagerActionNextEventHandler != null)
  67             {
  68                 //here we send all data to user event handlers
  69                 return _accessibilityManagerActionNextEventHandler(instance, null);
  70             }
  71             return false;
  72         }
  73
  74         // Callback for AccessibilityManager ActionPreviousSignal
  75         private bool OnActionPrevious(IntPtr data)
  76         {
  77             if (_accessibilityManagerActionPreviousEventHandler != null)
  78             {
  79                 //here we send all data to user event handlers
  80                 return _accessibilityManagerActionPreviousEventHandler(instance, null);
  81             }
  82             return false;
  83         }
  84
  85         // Callback for AccessibilityManager ActionActivateSignal
  86         private bool OnActionActivate(IntPtr data)
  87         {
  88             if (_accessibilityManagerActionActivateEventHandler != null)
  89             {
  90                 //here we send all data to user event handlers
  91                 return _accessibilityManagerActionActivateEventHandler(instance, null);
  92             }
  93             return false;
  94         }
  95
  96         // Callback for AccessibilityManager ActionReadSignal
  97         private bool OnActionRead(IntPtr data)
  98         {
  99
 100             if (_accessibilityManagerActionReadEventHandler != null)
 101             {
 102                 //here we send all data to user event handlers
 103                 return _accessibilityManagerActionReadEventHandler(instance, null);
 104             }
 105             return false;
 106         }
 107
 108         // Callback for AccessibilityManager ActionOverSignal
 109         private bool OnActionOver(IntPtr data)
 110         {
 111             if (_accessibilityManagerActionOverEventHandler != null)
 112             {
 113                 //here we send all data to user event handlers
 114                 return _accessibilityManagerActionOverEventHandler(instance, null);
 115             }
 116             return false;
 117         }
 118
 119         // Callback for AccessibilityManager ActionReadNextSignal
 120         private bool OnActionReadNext(IntPtr data)
 121         {
 122             if (_accessibilityManagerActionReadNextEventHandler != null)
 123             {
 124                 //here we send all data to user event handlers
 125                 return _accessibilityManagerActionReadNextEventHandler(instance, null);
 126             }
 127             return false;
 128         }
 129
 130         // Callback for AccessibilityManager ActionReadPreviousSignal
 131         private bool OnActionReadPrevious(IntPtr data)
 132         {
 133             if (_accessibilityManagerActionReadPreviousEventHandler != null)
 134             {
 135                 //here we send all data to user event handlers
 136                 return _accessibilityManagerActionReadPreviousEventHandler(instance, null);
 137             }
 138             return false;
 139         }
 140
 141         // Callback for AccessibilityManager ActionUpSignal
 142         private bool OnActionUp(IntPtr data)
 143         {
 144             if (_accessibilityManagerActionUpEventHandler != null)
 145             {
 146                 //here we send all data to user event handlers
 147                 return _accessibilityManagerActionUpEventHandler(instance, null);
 148             }
 149             return false;
 150         }
 151
 152         // Callback for AccessibilityManager ActionDownSignal
 153         private bool OnActionDown(IntPtr data)
 154         {
 155             if (_accessibilityManagerActionDownEventHandler != null)
 156             {
 157                 //here we send all data to user event handlers
 158                 return _accessibilityManagerActionDownEventHandler(instance, null);
 159             }
 160             return false;
 161         }
 162
 163         // Callback for AccessibilityManager ActionClearFocusSignal
 164         private bool OnActionClearFocus(IntPtr data)
 165         {
 166             if (_accessibilityManagerActionClearFocusEventHandler != null)
 167             {
 168                 //here we send all data to user event handlers
 169                 return _accessibilityManagerActionClearFocusEventHandler(instance, null);
 170             }
 171             return false;
 172         }
 173
 174         // Callback for AccessibilityManager ActionBackSignal
 175         private bool OnActionBack(IntPtr data)
 176         {
 177             if (_accessibilityManagerActionBackEventHandler != null)
 178             {
 179                 //here we send all data to user event handlers
 180                 return _accessibilityManagerActionBackEventHandler(instance, null);
 181             }
 182             return false;
 183         }
 184
 185         // Callback for AccessibilityManager ActionScrollUpSignal
 186         private bool OnActionScrollUp(IntPtr data)
 187         {
 188             if (_accessibilityManagerActionScrollUpEventHandler != null)
 189             {
 190                 //here we send all data to user event handlers
 191                 return _accessibilityManagerActionScrollUpEventHandler(instance, null);
 192             }
 193             return false;
 194         }
 195
 196         // Callback for AccessibilityManager ActionScrollDownSignal
 197         private bool OnActionScrollDown(IntPtr data)
 198         {
 199             if (_accessibilityManagerActionScrollDownEventHandler != null)
 200             {
 201                 //here we send all data to user event handlers
 202                 return _accessibilityManagerActionScrollDownEventHandler(instance, null);
 203             }
 204             return false;
 205         }
 206
 207         // Callback for AccessibilityManager ActionPageLeftSignal
 208         private bool OnActionPageLeft(IntPtr data)
 209         {
 210             if (_accessibilityManagerActionPageLeftEventHandler != null)
 211             {
 212                 //here we send all data to user event handlers
 213                 return _accessibilityManagerActionPageLeftEventHandler(instance, null);
 214             }
 215             return false;
 216         }
 217
 218         // Callback for AccessibilityManager ActionPageRightSignal
 219         private bool OnActionPageRight(IntPtr data)
 220         {
 221             if (_accessibilityManagerActionPageRightEventHandler != null)
 222             {
 223                 //here we send all data to user event handlers
 224                 return _accessibilityManagerActionPageRightEventHandler(instance, null);
 225             }
 226             return false;
 227         }
 228
 229         // Callback for AccessibilityManager ActionPageUpSignal
 230         private bool OnActionPageUp(IntPtr data)
 231         {
 232             if (_accessibilityManagerActionPageUpEventHandler != null)
 233             {
 234                 //here we send all data to user event handlers
 235                 return _accessibilityManagerActionPageUpEventHandler(instance, null);
 236             }
 237             return false;
 238         }
 239
 240
 241         // Callback for AccessibilityManager ActionPageDownSignal
 242         private bool OnActionPageDown(IntPtr data)
 243         {
 244             if (_accessibilityManagerActionPageDownEventHandler != null)
 245             {
 246                 //here we send all data to user event handlers
 247                 return _accessibilityManagerActionPageDownEventHandler(instance, null);
 248             }
 249             return false;
 250         }
 251
 252
 253         // Callback for AccessibilityManager ActionMoveToFirstSignal
 254         private bool OnActionMoveToFirst(IntPtr data)
 255         {
 256             if (_accessibilityManagerActionMoveToFirstEventHandler != null)
 257             {
 258                 //here we send all data to user event handlers
 259                 return _accessibilityManagerActionMoveToFirstEventHandler(instance, null);
 260             }
 261             return false;
 262         }
 263
 264         // Callback for AccessibilityManager ActionMoveToLastSignal
 265         private bool OnActionMoveToLast(IntPtr data)
 266         {
 267             if (_accessibilityManagerActionMoveToLastEventHandler != null)
 268             {
 269                 //here we send all data to user event handlers
 270                 return _accessibilityManagerActionMoveToLastEventHandler(instance, null);
 271             }
 272             return false;
 273         }
 274
 275         // Callback for AccessibilityManager ActionReadFromTopSignal
 276         private bool OnActionReadFromTop(IntPtr data)
 277         {
 278             if (_accessibilityManagerActionReadFromTopEventHandler != null)
 279             {
 280                 //here we send all data to user event handlers
 281                 return _accessibilityManagerActionReadFromTopEventHandler(instance, null);
 282             }
 283             return false;
 284         }
 285
 286         // Callback for AccessibilityManager ActionReadFromNextSignal
 287         private bool OnActionReadFromNext(IntPtr data)
 288         {
 289             if (_accessibilityManagerActionReadFromNextEventHandler != null)
 290             {
 291                 //here we send all data to user event handlers
 292                 return _accessibilityManagerActionReadFromNextEventHandler(instance, null);
 293             }
 294             return false;
 295         }
 296
 297         // Callback for AccessibilityManager ActionZoomSignal
 298         private bool OnActionZoom(IntPtr data)
 299         {
 300             if (_accessibilityManagerActionZoomEventHandler != null)
 301             {
 302                 //here we send all data to user event handlers
 303                 return _accessibilityManagerActionZoomEventHandler(instance, null);
 304             }
 305             return false;
 306         }
 307
 308         // Callback for AccessibilityManager ActionReadPauseResumeSignal
 309         private bool OnActionReadPauseResume(IntPtr data)
 310         {
 311             if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
 312             {
 313                 //here we send all data to user event handlers
 314                 return _accessibilityManagerActionReadPauseResumeEventHandler(instance, null);
 315             }
 316             return false;
 317         }
 318
 319         // Callback for AccessibilityManager ActionStartStopSignal
 320         private bool OnActionStartStop(IntPtr data)
 321         {
 322             if (_accessibilityManagerActionStartStopEventHandler != null)
 323             {
 324                 //here we send all data to user event handlers
 325                 return _accessibilityManagerActionStartStopEventHandler(instance, null);
 326             }
 327             return false;
 328         }
 329
 330         // Callback for AccessibilityManager FocusChangedSignal
 331         private void OnFocusChanged(IntPtr view1, IntPtr view2)
 332         {
 333             FocusChangedEventArgs e = new FocusChangedEventArgs();
 334
 335             // Populate all members of "e" (FocusChangedEventArgs) with real data
 336             e.ViewCurrent = Registry.GetManagedBaseHandleFromNativePtr(view1) as View;
 337             e.ViewNext = Registry.GetManagedBaseHandleFromNativePtr(view2) as View;
 338
 339             if (_accessibilityManagerFocusChangedEventHandler != null)
 340             {
 341                 //here we send all data to user event handlers
 342                 _accessibilityManagerFocusChangedEventHandler(this, e);
 343             }
 344         }
 345
 346         // Callback for AccessibilityManager FocusedViewActivatedSignal
 347         private void OnFocusedViewActivated(IntPtr view)
 348         {
 349             FocusedViewActivatedEventArgs e = new FocusedViewActivatedEventArgs();
 350
 351             // Populate all members of "e" (FocusedViewActivatedEventArgs) with real data
 352             e.View = Registry.GetManagedBaseHandleFromNativePtr(view) as View;
 353
 354             if (_accessibilityManagerFocusedViewActivatedEventHandler != null)
 355             {
 356                 //here we send all data to user event handlers
 357                 _accessibilityManagerFocusedViewActivatedEventHandler(this, e);
 358             }
 359         }
 360
 361         // Callback for AccessibilityManager FocusOvershotSignal
 362         private void OnFocusOvershot(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction)
 363         {
 364             FocusOvershotEventArgs e = new FocusOvershotEventArgs();
 365
 366             // Populate all members of "e" (FocusOvershotEventArgs) with real data
 367             e.CurrentFocusedView = Registry.GetManagedBaseHandleFromNativePtr(currentFocusedView) as View;
 368             e.FocusOvershotDirection = direction;
 369
 370             if (_accessibilityManagerFocusOvershotEventHandler != null)
 371             {
 372                 //here we send all data to user event handlers
 373                 _accessibilityManagerFocusOvershotEventHandler(this, e);
 374             }
 375         }
 376
 377         /// <summary>
 378         /// Enumeration for accessibility that needs four information which will be read by screen-reader.
 379         ///
 380         /// Reading order : Label -> Trait -> Optional (Value and Hint)
 381         /// </summary>
 382         /// <since_tizen> 6 </since_tizen>
 383         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 384         [EditorBrowsable(EditorBrowsableState.Never)]
 385         public enum AccessibilityAttribute
 386         {
 387             /// <summary>
 388             /// Simple text which contained in components, such as Ok or Cancel in case of a button
 389             /// </summary>
 390             /// <since_tizen> 6 </since_tizen>
 391             /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 392             [EditorBrowsable(EditorBrowsableState.Never)]
 393             Label = 0,
 394             /// <summary>
 395             /// Description of components trait, such as Button in case of a button
 396             /// </summary>
 397             /// <since_tizen> 6 </since_tizen>
 398             /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 399             [EditorBrowsable(EditorBrowsableState.Never)]
 400             Trait,
 401             /// <summary>
 402             /// Current value of components (Optional)
 403             /// </summary>
 404             /// <since_tizen> 6 </since_tizen>
 405             /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 406             [EditorBrowsable(EditorBrowsableState.Never)]
 407             Value,
 408             /// <summary>
 409             /// Hint for action (Optional)
 410             /// </summary>
 411             /// <since_tizen> 6 </since_tizen>
 412             /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 413             [EditorBrowsable(EditorBrowsableState.Never)]
 414             Hint,
 415             /// <summary>
 416             /// The number of attributes
 417             /// </summary>
 418             /// <since_tizen> 6 </since_tizen>
 419             /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 420             [EditorBrowsable(EditorBrowsableState.Never)]
 421             AttributeNumber
 422         }
 423
 424         /// <summary>
 425         /// Enumeration for overshoot direction.
 426         /// </summary>
 427         /// <since_tizen> 6 </since_tizen>
 428         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 429         [EditorBrowsable(EditorBrowsableState.Never)]
 430         public enum FocusOvershotDirection
 431         {
 432             /// <summary>
 433             /// Try to move previous of the first view
 434             /// </summary>
 435             /// <since_tizen> 6 </since_tizen>
 436             /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 437             [EditorBrowsable(EditorBrowsableState.Never)]
 438             Previous = -1,
 439             /// <summary>
 440             /// Try to move next of the last view
 441             /// </summary>
 442             /// <since_tizen> 6 </since_tizen>
 443             /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 444             [EditorBrowsable(EditorBrowsableState.Never)]
 445             Next = 1
 446         }
 447
 448
 449         /// <summary>
 450         /// Creates an AccessibilityManager handle.
 451         /// </summary>
 452         /// <since_tizen> 6 </since_tizen>
 453         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 454         [EditorBrowsable(EditorBrowsableState.Never)]
 455         public AccessibilityManager() : this(Interop.AccessibilityManager.NewAccessibilityManager(), true)
 456         {
 457             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 458         }
 459
 460         /// <summary>
 461         /// Gets the singleton of AccessibilityManager object.
 462         /// </summary>
 463         /// <returns> A handle to the AccessibilityManager </returns>
 464         /// <since_tizen> 6 </since_tizen>
 465         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 466         [EditorBrowsable(EditorBrowsableState.Never)]
 467         public static AccessibilityManager Instance
 468         {
 469             get
 470             {
 471                 return instance;
 472             }
 473         }
 474
 475         /// <summary>
 476         /// Sets the information of the specified view's accessibility attribute.
 477         /// </summary>
 478         /// <param name="view"> The view to be set with</param>
 479         /// <param name="type"> The attribute type the text to be set with</param>
 480         /// <param name="text"> The text for the view's accessibility information</param>
 481         /// <since_tizen> 6 </since_tizen>
 482         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 483         [EditorBrowsable(EditorBrowsableState.Never)]
 484         public void SetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type, string text)
 485         {
 486             Interop.AccessibilityManager.SetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type, text);
 487             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 488         }
 489
 490         /// <summary>
 491         /// Gets the text of the specified view's accessibility attribute.
 492         /// </summary>
 493         /// <param name="view"> The view to be queried</param>
 494         /// <param name="type"> The attribute type to be queried</param>
 495         /// <returns> The text of the view's accessibility information </returns>
 496         /// <since_tizen> 6 </since_tizen>
 497         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 498         [EditorBrowsable(EditorBrowsableState.Never)]
 499         public string GetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type)
 500         {
 501             string ret = Interop.AccessibilityManager.GetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type);
 502             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 503             return ret;
 504         }
 505
 506         /// <summary>
 507         /// Sets the focus order of the view.
 508         /// The focus order of each view in the focus chain is unique.
 509         /// If there is another view assigned with the same focus order already, the new view will be inserted to the focus chain with that focus order,
 510         /// and the focus order of the original view and all the views followed in the focus chain will be increased accordingly.
 511         /// If the focus order assigned to the view is 0, it means that view's focus order is undefined
 512         /// (e.g. the view has a  description but with no focus order being set yet) and therefore that view is not focusable.
 513         /// </summary>
 514         /// <param name="view"> the view to be set with</param>
 515         /// <param name="order"> the focus order to be set with</param>
 516         /// <since_tizen> 6 </since_tizen>
 517         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 518         [EditorBrowsable(EditorBrowsableState.Never)]
 519         public void SetFocusOrder(View view, uint order)
 520         {
 521             Interop.AccessibilityManager.SetFocusOrder(swigCPtr, View.getCPtr(view), order);
 522             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 523         }
 524
 525         /// <summary>
 526         /// Gets the focus order of the view.
 527         /// When the focus order is 0, it means the focus order of the view is undefined.
 528         /// </summary>
 529         /// <param name="view"> the view to be set with</param>
 530         /// <returns> The focus order of the view </returns>
 531         /// <since_tizen> 6 </since_tizen>
 532         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 533         [EditorBrowsable(EditorBrowsableState.Never)]
 534         public uint GetFocusOrder(View view)
 535         {
 536             uint ret = Interop.AccessibilityManager.GetFocusOrder(swigCPtr, View.getCPtr(view));
 537             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 538             return ret;
 539         }
 540
 541         /// <summary>
 542         /// Generates a new focus order number which can be used to assign to views
 543         /// which need to be appended to the end of the current focus order chain.
 544         /// The new number will be an increment over the very last focus order number in the focus chain.
 545         /// If the focus chain is empty then the function returns 1,
 546         /// else the number returned will be FOLast + 1 where FOLast is the focus order of the very last control in the focus chain.
 547         /// </summary>
 548         /// <returns> The focus order of the view </returns>
 549         /// <since_tizen> 6 </since_tizen>
 550         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 551         [EditorBrowsable(EditorBrowsableState.Never)]
 552         public uint GenerateNewFocusOrder()
 553         {
 554             uint ret = Interop.AccessibilityManager.GenerateNewFocusOrder(swigCPtr);
 555             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 556             return ret;
 557         }
 558
 559         /// <summary>
 560         /// Gets the view that has the specified focus order.
 561         /// It will return an empty handle if no view in the window has the specified focus order.
 562         /// </summary>
 563         /// <param name="order"> The focus order of the view</param>
 564         /// <returns> The view that has the specified focus order or an empty handle if no view in the stage has the specified focus order </returns>
 565         /// <since_tizen> 6 </since_tizen>
 566         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 567         [EditorBrowsable(EditorBrowsableState.Never)]
 568         public View GetViewByFocusOrder(uint order)
 569         {
 570             View ret = new View(Interop.AccessibilityManager.GetActorByFocusOrder(swigCPtr, order), true);
 571             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 572             return ret;
 573         }
 574
 575         /// <summary>
 576         /// Moves the focus to the specified view.
 577         /// Only one view can be focused at the same time. The view must have a defined focus order
 578         /// and must be focusable, visible and in the window.
 579         /// </summary>
 580         /// <param name="view"> the view to be set with</param>
 581         /// <returns> Whether the focus is successful or not </returns>
 582         /// <since_tizen> 6 </since_tizen>
 583         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 584         [EditorBrowsable(EditorBrowsableState.Never)]
 585         public bool SetCurrentFocusView(View view)
 586         {
 587             bool ret = Interop.AccessibilityManager.SetCurrentFocusActor(swigCPtr, View.getCPtr(view));
 588             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 589             return ret;
 590         }
 591
 592         /// <summary>
 593         /// Gets the current focused view.
 594         /// </summary>
 595         /// <returns> A handle to the current focused view or an empty handle if no view is focused </returns>
 596         /// <since_tizen> 6 </since_tizen>
 597         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 598         [EditorBrowsable(EditorBrowsableState.Never)]
 599         public View GetCurrentFocusView()
 600         {
 601             View ret = new View(Interop.AccessibilityManager.GetCurrentFocusActor(swigCPtr), true);
 602             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 603             return ret;
 604         }
 605
 606         /// <summary>
 607         /// Gets the focus group of current focused view.
 608         /// </summary>
 609         /// <returns> A handle to the immediate parent of the current focused view which is also a focus group, or an empty handle if no view is focused </returns>
 610         /// <since_tizen> 6 </since_tizen>
 611         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 612         [EditorBrowsable(EditorBrowsableState.Never)]
 613         public View GetCurrentFocusGroup()
 614         {
 615             View ret = new View(Interop.AccessibilityManager.GetCurrentFocusGroup(swigCPtr), true);
 616             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 617             return ret;
 618         }
 619
 620         /// <summary>
 621         /// Gets the focus order of currently focused view.
 622         /// </summary>
 623         /// <returns> The focus order of the currently focused view or 0 if no view is in focus </returns>
 624         /// <since_tizen> 6 </since_tizen>
 625         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 626         [EditorBrowsable(EditorBrowsableState.Never)]
 627         public uint GetCurrentFocusOrder()
 628         {
 629             uint ret = Interop.AccessibilityManager.GetCurrentFocusOrder(swigCPtr);
 630             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 631             return ret;
 632         }
 633
 634         /// <summary>
 635         /// Moves the focus to the next focusable view in the focus chain (according to the focus traversal order).
 636         /// When the focus movement is wrapped around, the focus will be moved to the first focusable view when it reaches the end of the focus chain.
 637         /// </summary>
 638         /// <returns> True if the moving was successful </returns>
 639         /// <since_tizen> 6 </since_tizen>
 640         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 641         [EditorBrowsable(EditorBrowsableState.Never)]
 642         public bool MoveFocusForward()
 643         {
 644             bool ret = Interop.AccessibilityManager.MoveFocusForward(swigCPtr);
 645             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 646             return ret;
 647         }
 648
 649         /// <summary>
 650         /// Moves the focus to the previous focusable view in the focus chain (according to the focus traversal order).
 651         /// When the focus movement is wrapped around, the focus will be moved to the last focusable view
 652         /// when it reaches the beginning of the focus chain.
 653         /// </summary>
 654         /// <returns> True if the moving was successful </returns>
 655         /// <since_tizen> 6 </since_tizen>
 656         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 657         [EditorBrowsable(EditorBrowsableState.Never)]
 658         public bool MoveFocusBackward()
 659         {
 660             bool ret = Interop.AccessibilityManager.MoveFocusBackward(swigCPtr);
 661             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 662             return ret;
 663         }
 664
 665         /// <summary>
 666         /// Clears the focus from the current focused view if any, so that no view is focused in the focus chain.
 667         /// It will emit focus changed signal without current focused view.
 668         /// </summary>
 669         /// <since_tizen> 6 </since_tizen>
 670         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 671         [EditorBrowsable(EditorBrowsableState.Never)]
 672         public void ClearFocus()
 673         {
 674             Interop.AccessibilityManager.ClearFocus(swigCPtr);
 675             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 676         }
 677
 678         /// <summary>
 679         /// Clears every registered focusable view from focus-manager.
 680         /// </summary>
 681         /// <since_tizen> 6 </since_tizen>
 682         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 683         [EditorBrowsable(EditorBrowsableState.Never)]
 684         public new void Reset()
 685         {
 686             Interop.AccessibilityManager.Reset(swigCPtr);
 687             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 688         }
 689
 690         /// <summary>
 691         /// Sets whether an view is a focus group that can limit the scope of focus movement to its child views in the focus chain.
 692         /// </summary>
 693         /// <param name="view"> the view to be set as a focus group</param>
 694         /// <param name="isFocusGroup"> Whether to set the view to be a focus group or not</param>
 695         /// <since_tizen> 6 </since_tizen>
 696         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 697         [EditorBrowsable(EditorBrowsableState.Never)]
 698         public void SetFocusGroup(View view, bool isFocusGroup)
 699         {
 700             Interop.AccessibilityManager.SetFocusGroup(swigCPtr, View.getCPtr(view), isFocusGroup);
 701             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 702         }
 703
 704         /// <summary>
 705         /// Checks whether the view is set as a focus group or not.
 706         /// </summary>
 707         /// <param name="view"> the view to be checked</param>
 708         /// <returns> Whether the view is set as a focus group </returns>
 709         /// <since_tizen> 6 </since_tizen>
 710         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 711         [EditorBrowsable(EditorBrowsableState.Never)]
 712         public bool IsFocusGroup(View view)
 713         {
 714             bool ret = Interop.AccessibilityManager.IsFocusGroup(swigCPtr, View.getCPtr(view));
 715             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 716             return ret;
 717         }
 718
 719         /// <summary>
 720         /// Sets whether the group mode is enabled or not.
 721         /// When the group mode is enabled, the focus movement will be limited to the child views  of the current focus group including the current focus group itself.
 722         /// The current focus group is the closest ancestor of the current focused view that is set as a focus group.
 723         /// </summary>
 724         /// <param name="enabled"> Whether the group mode is enabled or not</param>
 725         /// <since_tizen> 6 </since_tizen>
 726         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 727         [EditorBrowsable(EditorBrowsableState.Never)]
 728         public void SetGroupMode(bool enabled)
 729         {
 730             Interop.AccessibilityManager.SetGroupMode(swigCPtr, enabled);
 731             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 732         }
 733
 734         /// <summary>
 735         /// Gets whether the group mode is enabled or not.
 736         /// </summary>
 737         /// <since_tizen> 6 </since_tizen>
 738         /// <returns> Whether the group mode is enabled or not. </returns>
 739         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 740         [EditorBrowsable(EditorBrowsableState.Never)]
 741         public bool GetGroupMode()
 742         {
 743             bool ret = Interop.AccessibilityManager.GetGroupMode(swigCPtr);
 744             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 745             return ret;
 746         }
 747
 748         /// <summary>
 749         /// Sets whether focus will be moved to the beginning of the focus chain when it reaches the end or vice versa.
 750         /// When both the wrap mode and the group mode are enabled, focus will be wrapped within the current focus group.
 751         /// Focus will not be wrapped in default.
 752         /// </summary>
 753         /// <param name="wrapped"> Whether the focus movement is wrapped around or not</param>
 754         /// <since_tizen> 6 </since_tizen>
 755         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 756         [EditorBrowsable(EditorBrowsableState.Never)]
 757         public void SetWrapMode(bool wrapped)
 758         {
 759             Interop.AccessibilityManager.SetWrapMode(swigCPtr, wrapped);
 760             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 761         }
 762
 763         /// <summary>
 764         /// Gets whether the wrap mode is enabled or not.
 765         /// </summary>
 766         /// <returns> Whether the wrap mode is enabled or not. </returns>
 767         /// <since_tizen> 6 </since_tizen>
 768         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 769         [EditorBrowsable(EditorBrowsableState.Never)]
 770         public bool GetWrapMode()
 771         {
 772             bool ret = Interop.AccessibilityManager.GetWrapMode(swigCPtr);
 773             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 774             return ret;
 775         }
 776
 777         /// <summary>
 778         /// Sets the focus indicator view.
 779         /// This will replace the default focus indicator view in AccessibilityManager and
 780         /// will be added to the focused view as a highlight.
 781         /// </summary>
 782         /// <param name="indicator"> The indicator view to be added</param>
 783         /// <since_tizen> 6 </since_tizen>
 784         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 785         [EditorBrowsable(EditorBrowsableState.Never)]
 786         public void SetFocusIndicatorView(View indicator)
 787         {
 788             Interop.AccessibilityManager.SetFocusIndicatorActor(swigCPtr, View.getCPtr(indicator));
 789             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 790         }
 791
 792         /// <summary>
 793         /// Gets the focus indicator view.
 794         /// </summary>
 795         /// <returns> A handle to the focus indicator view </returns>
 796         /// <since_tizen> 6 </since_tizen>
 797         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 798         [EditorBrowsable(EditorBrowsableState.Never)]
 799         public View GetFocusIndicatorView()
 800         {
 801             View ret = new View(Interop.AccessibilityManager.GetFocusIndicatorActor(swigCPtr), true);
 802             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 803             return ret;
 804         }
 805
 806         /// <summary>
 807         /// Returns the closest ancestor of the given view that is a focus group.
 808         /// </summary>
 809         /// <param name="view"> The view to be checked for its focus group</param>
 810         /// <returns> The focus group the given view belongs to or an empty handle if the given view doesn't belong to any focus group </returns>
 811         /// <since_tizen> 6 </since_tizen>
 812         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 813         [EditorBrowsable(EditorBrowsableState.Never)]
 814         public View GetFocusGroup(View view)
 815         {
 816             View ret = new View(Interop.AccessibilityManager.GetFocusGroup(swigCPtr, View.getCPtr(view)), true);
 817             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 818             return ret;
 819         }
 820
 821         /// <summary>
 822         /// Returns the current position of the read action.
 823         /// </summary>
 824         /// <returns> The current event position </returns>
 825         /// <since_tizen> 6 </since_tizen>
 826         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 827         [EditorBrowsable(EditorBrowsableState.Never)]
 828         public Vector2 GetReadPosition()
 829         {
 830             Vector2 ret = new Vector2(Interop.AccessibilityManager.GetReadPosition(swigCPtr), true);
 831             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 832             return ret;
 833         }
 834
 835         internal static AccessibilityManager Get()
 836         {
 837             AccessibilityManager ret = new AccessibilityManager(Interop.AccessibilityManager.Get(), true);
 838             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 839             return ret;
 840         }
 841
 842         // Signals - AccessibilityManagerEvent.cs
 843         internal FocusChangedSignal FocusChangedSignal()
 844         {
 845             FocusChangedSignal ret = new FocusChangedSignal(Interop.AccessibilityManager.FocusChangedSignal(swigCPtr), false);
 846             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 847             return ret;
 848         }
 849
 850         internal AccessibilityFocusOvershotSignal FocusOvershotSignal()
 851         {
 852             AccessibilityFocusOvershotSignal ret = new AccessibilityFocusOvershotSignal(Interop.AccessibilityManager.FocusOvershotSignal(swigCPtr), false);
 853             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 854             return ret;
 855         }
 856
 857         internal ViewSignal FocusedViewActivatedSignal()
 858         {
 859             ViewSignal ret = new ViewSignal(Interop.AccessibilityManager.FocusedActorActivatedSignal(swigCPtr), false);
 860             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 861             return ret;
 862         }
 863
 864         internal AccessibilityActionSignal StatusChangedSignal()
 865         {
 866             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.StatusChangedSignal(swigCPtr), false);
 867             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 868             return ret;
 869         }
 870
 871         internal AccessibilityActionSignal ActionNextSignal()
 872         {
 873             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionNextSignal(swigCPtr), false);
 874             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 875             return ret;
 876         }
 877
 878         internal AccessibilityActionSignal ActionPreviousSignal()
 879         {
 880             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionPreviousSignal(swigCPtr), false);
 881             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 882             return ret;
 883         }
 884
 885         internal AccessibilityActionSignal ActionActivateSignal()
 886         {
 887             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionActivateSignal(swigCPtr), false);
 888             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 889             return ret;
 890         }
 891
 892         internal AccessibilityActionSignal ActionReadSignal()
 893         {
 894             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionReadSignal(swigCPtr), false);
 895             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 896             return ret;
 897         }
 898
 899         internal AccessibilityActionSignal ActionOverSignal()
 900         {
 901             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionOverSignal(swigCPtr), false);
 902             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 903             return ret;
 904         }
 905
 906         internal AccessibilityActionSignal ActionReadNextSignal()
 907         {
 908             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionReadNextSignal(swigCPtr), false);
 909             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 910             return ret;
 911         }
 912
 913         internal AccessibilityActionSignal ActionReadPreviousSignal()
 914         {
 915             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionReadPreviousSignal(swigCPtr), false);
 916             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 917             return ret;
 918         }
 919
 920         internal AccessibilityActionSignal ActionUpSignal()
 921         {
 922             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionUpSignal(swigCPtr), false);
 923             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 924             return ret;
 925         }
 926
 927         internal AccessibilityActionSignal ActionDownSignal()
 928         {
 929             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionDownSignal(swigCPtr), false);
 930             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 931             return ret;
 932         }
 933
 934         internal AccessibilityActionSignal ActionClearFocusSignal()
 935         {
 936             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionClearFocusSignal(swigCPtr), false);
 937             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 938             return ret;
 939         }
 940
 941         internal AccessibilityActionSignal ActionBackSignal()
 942         {
 943             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionBackSignal(swigCPtr), false);
 944             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 945             return ret;
 946         }
 947
 948         internal AccessibilityActionSignal ActionScrollUpSignal()
 949         {
 950             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionScrollUpSignal(swigCPtr), false);
 951             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 952             return ret;
 953         }
 954
 955         internal AccessibilityActionSignal ActionScrollDownSignal()
 956         {
 957             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionScrollDownSignal(swigCPtr), false);
 958             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 959             return ret;
 960         }
 961
 962         internal AccessibilityActionSignal ActionPageLeftSignal()
 963         {
 964             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionPageLeftSignal(swigCPtr), false);
 965             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 966             return ret;
 967         }
 968
 969         internal AccessibilityActionSignal ActionPageRightSignal()
 970         {
 971             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionPageRightSignal(swigCPtr), false);
 972             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 973             return ret;
 974         }
 975
 976         internal AccessibilityActionSignal ActionPageUpSignal()
 977         {
 978             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionPageUpSignal(swigCPtr), false);
 979             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 980             return ret;
 981         }
 982
 983         internal AccessibilityActionSignal ActionPageDownSignal()
 984         {
 985             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionPageDownSignal(swigCPtr), false);
 986             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 987             return ret;
 988         }
 989
 990         internal AccessibilityActionSignal ActionMoveToFirstSignal()
 991         {
 992             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionMoveToFirstSignal(swigCPtr), false);
 993             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 994             return ret;
 995         }
 996
 997         internal AccessibilityActionSignal ActionMoveToLastSignal()
 998         {
 999             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionMoveToLastSignal(swigCPtr), false);
1000             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1001             return ret;
1002         }
1003
1004         internal AccessibilityActionSignal ActionReadFromTopSignal()
1005         {
1006             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionReadFromTopSignal(swigCPtr), false);
1007             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1008             return ret;
1009         }
1010
1011         internal AccessibilityActionSignal ActionReadFromNextSignal()
1012         {
1013             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionReadFromNextSignal(swigCPtr), false);
1014             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1015             return ret;
1016         }
1017
1018         internal AccessibilityActionSignal ActionZoomSignal()
1019         {
1020             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionZoomSignal(swigCPtr), false);
1021             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1022             return ret;
1023         }
1024
1025         internal AccessibilityActionSignal ActionReadPauseResumeSignal()
1026         {
1027             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionReadPauseResumeSignal(swigCPtr), false);
1028             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1029             return ret;
1030         }
1031
1032         internal AccessibilityActionSignal ActionStartStopSignal()
1033         {
1034             AccessibilityActionSignal ret = new AccessibilityActionSignal(Interop.AccessibilityManager.ActionStartStopSignal(swigCPtr), false);
1035             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1036             return ret;
1037         }
1038
1039         internal SWIGTYPE_p_Dali__SignalT_bool_fDali__Toolkit__AccessibilityManager_R_Dali__TouchEvent_const_RF_t ActionScrollSignal()
1040         {
1041             SWIGTYPE_p_Dali__SignalT_bool_fDali__Toolkit__AccessibilityManager_R_Dali__TouchEvent_const_RF_t ret = new SWIGTYPE_p_Dali__SignalT_bool_fDali__Toolkit__AccessibilityManager_R_Dali__TouchEvent_const_RF_t(Interop.AccessibilityManager.ActionScrollSignal(swigCPtr));
1042             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1043             return ret;
1044         }
1045     }
1046 }