src/Tizen.NUI/src/public/BaseComponents/ViewAccessibility.cs

   1 /*
   2  * Copyright(c) 2021 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 using System;
  19 using System.ComponentModel;
  20 using System.Runtime.InteropServices;
  21 using Tizen.NUI;
  22
  23 namespace Tizen.NUI.BaseComponents
  24 {
  25     /// <summary>
  26     /// Address represents an unique object address on accessibility bus.
  27     /// </summary>
  28     [EditorBrowsable(EditorBrowsableState.Never)]
  29     public class Address
  30     {
  31         /// <summary>
  32         /// Creates an initialized Address.
  33         /// </summary>
  34         /// <param name="bus">Accessibility bus</param>
  35         /// <param name="path">Accessibility path</param>
  36         [EditorBrowsable(EditorBrowsableState.Never)]
  37         public Address(string bus, string path)
  38         {
  39             Bus = bus;
  40             Path = path;
  41         }
  42
  43         /// <summary>
  44         /// Gets or sets accessibility bus.
  45         /// </summary>
  46         [EditorBrowsable(EditorBrowsableState.Never)]
  47         public string Bus { get; set; }
  48
  49         /// <summary>
  50         /// Gets or sets accessibility path.
  51         /// </summary>
  52         [EditorBrowsable(EditorBrowsableState.Never)]
  53         public string Path { get; set; }
  54     }
  55
  56     /// <summary>
  57     /// AddressCollection.
  58     /// </summary>
  59     [EditorBrowsable(EditorBrowsableState.Never)]
  60     public class AddressCollection : SafeHandle
  61     {
  62         /// <summary>
  63         /// Creates an initialized AddressCollection.
  64         /// </summary>
  65         /// <param name="collection">Initialized AddressCollection</param>
  66         [EditorBrowsable(EditorBrowsableState.Never)]
  67         public AddressCollection(IntPtr collection) : base(collection, true)
  68         {
  69         }
  70
  71         /// <summary>
  72         /// Checks whether this handle is invalid or not.
  73         /// </summary>
  74         [EditorBrowsable(EditorBrowsableState.Never)]
  75         public override bool IsInvalid
  76         {
  77             get
  78             {
  79                 return this.handle == IntPtr.Zero;
  80             }
  81         }
  82
  83         /// <summary>
  84         /// Gets the size of accessibility relation.
  85         /// </summary>
  86         /// <param name="relation">Accessibility relation</param>
  87         /// <returns>The size of relation, which means the number of elements</returns>
  88         [EditorBrowsable(EditorBrowsableState.Never)]
  89         public uint GetRelationSize(AccessibilityRelationType relation)
  90         {
  91             uint result = Interop.ControlDevel.DaliToolkitDevelControlAccessibilityRelationsRelationSize(this, Convert.ToInt32(relation));
  92             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  93             return result;
  94         }
  95
  96         /// <summary>
  97         /// Gets Address object using contained bus and path.
  98         /// </summary>
  99         /// <param name="relation">Accessibility relation</param>
 100         /// <param name="position">Position</param>
 101         /// <returns>Accessibility Adress</returns>
 102         [EditorBrowsable(EditorBrowsableState.Never)]
 103         public Address GetAddressAt(AccessibilityRelationType relation, int position)
 104         {
 105             var bus = Interop.ControlDevel.DaliToolkitDevelControlAccessibilityRelationsAt(this, Convert.ToInt32(relation), position, 0);
 106             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 107
 108             var path = Interop.ControlDevel.DaliToolkitDevelControlAccessibilityRelationsAt(this, Convert.ToInt32(relation), position, 1);
 109             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 110
 111             return new Address(bus, path);
 112         }
 113
 114         /// <summary>
 115         /// Releases handle itself.
 116         /// </summary>
 117         /// <returns>true when released successfully.</returns>
 118         [EditorBrowsable(EditorBrowsableState.Never)]
 119         protected override bool ReleaseHandle()
 120         {
 121             Interop.ControlDevel.DaliToolkitDevelControlDeleteAccessibilityRelations(handle);
 122             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 123             this.SetHandle(IntPtr.Zero);
 124             return true;
 125         }
 126     }
 127
 128     /// <summary>
 129     /// AccessibilityRange is used to store data related with Text.
 130     /// </summary>
 131     [EditorBrowsable(EditorBrowsableState.Never)]
 132     public class AccessibilityRange
 133     {
 134         /// <summary>
 135         /// Start position in stored text.
 136         /// </summary>
 137         public int StartOffset { get; set; } = 0;
 138
 139         /// <summary>
 140         /// End position in stored text.
 141         /// </summary>
 142         public int EndOffset { get; set; } = 0;
 143
 144         /// <summary>
 145         /// Text content in stored text.
 146         /// </summary>
 147         public string Content { get; set; } = "";
 148     }
 149
 150     /// <summary>
 151     /// View is the base class for all views.
 152     /// </summary>
 153     /// <since_tizen> 3 </since_tizen>
 154     public partial class View
 155     {
 156         ///////////////////////////////////////////////////////////////////
 157         // ****************** Accessibility Attributes ****************** //
 158         ///////////////////////////////////////////////////////////////////
 159
 160         /// <summary>
 161         /// Adds or modifies the value matched with given key.
 162         /// </summary>
 163         /// <remarks>
 164         /// Modification takes place if key was previously set.
 165         /// </remarks>
 166         /// <param name="key">The key to insert</param>
 167         /// <param name="value">The value to insert</param>
 168         [EditorBrowsable(EditorBrowsableState.Never)]
 169         public void AppendAccessibilityAttribute(string key, string value)
 170         {
 171             Interop.ControlDevel.DaliToolkitDevelControlAppendAccessibilityAttribute(SwigCPtr, key, value);
 172             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 173         }
 174
 175         /// <summary>
 176         /// Erases a key with its value from accessibility attributes.
 177         /// </summary>
 178         /// <param name="key">The key to remove</param>
 179         [EditorBrowsable(EditorBrowsableState.Never)]
 180         public void RemoveAccessibilityAttribute(string key)
 181         {
 182             Interop.ControlDevel.DaliToolkitDevelControlRemoveAccessibilityAttribute(SwigCPtr, key);
 183             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 184         }
 185
 186         /// <summary>
 187         /// Clears accessibility attributes.
 188         /// </summary>
 189         [EditorBrowsable(EditorBrowsableState.Never)]
 190         public void ClearAccessibilityAttributes()
 191         {
 192             Interop.ControlDevel.DaliToolkitDevelControlClearAccessibilityAttributes(SwigCPtr);
 193             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 194         }
 195
 196         ///////////////////////////////////////////////////////////////////
 197         // ************************** Highlight ************************ //
 198         ///////////////////////////////////////////////////////////////////
 199
 200         /// <summary>
 201         /// Clears accessibility highlight.
 202         /// </summary>
 203         /// <returns>True if cleared, otherwise false when it is not possible</returns>
 204         [EditorBrowsable(EditorBrowsableState.Never)]
 205         public bool ClearAccessibilityHighlight()
 206         {
 207             bool result = Interop.ControlDevel.DaliToolkitDevelControlClearAccessibilityHighlight(SwigCPtr);
 208             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 209             return result;
 210         }
 211
 212         /// <summary>
 213         /// Grabs accessibility highlight.
 214         /// </summary>
 215         /// <returns>True if cleared, otherwise false when it is not possible</returns>
 216         [EditorBrowsable(EditorBrowsableState.Never)]
 217         public bool GrabAccessibilityHighlight()
 218         {
 219             bool result = Interop.ControlDevel.DaliToolkitDevelControlGrabAccessibilityHighlight(SwigCPtr);
 220             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 221             return result;
 222         }
 223
 224         /// <summary>
 225         /// Flag to check whether this view is highlighted or not.
 226         /// </summary>
 227         [EditorBrowsable(EditorBrowsableState.Never)]
 228         protected bool IsHighlighted
 229         {
 230             get
 231             {
 232                 using (View view = Accessibility.Accessibility.Instance.GetCurrentlyHighlightedView())
 233                 {
 234                     return view == this;
 235                 }
 236             }
 237         }
 238
 239         ///////////////////////////////////////////////////////////////////
 240         // ****************** Accessibility Relations ******************* //
 241         ///////////////////////////////////////////////////////////////////
 242
 243         /// <summary>
 244         /// Creates relation between objects.
 245         /// </summary>
 246         /// <param name="second">Object which will be in relation.</param>
 247         /// <param name="relation">Relation type.</param>
 248         /// <exception cref="ArgumentNullException">You must pass valid object. NULL could not be in relation.</exception>
 249         [EditorBrowsable(EditorBrowsableState.Never)]
 250         public void AppendAccessibilityRelation(View second, AccessibilityRelationType relation)
 251         {
 252             if (second is null)
 253             {
 254                 throw new ArgumentNullException(nameof(second));
 255             }
 256
 257             Interop.ControlDevel.DaliToolkitDevelControlAppendAccessibilityRelation(SwigCPtr, second.SwigCPtr, (int)relation);
 258             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 259         }
 260
 261         /// <summary>
 262         /// Removes accessibility relation.
 263         /// </summary>
 264         /// <param name="second">Object which will be removed in relation</param>
 265         /// <param name="relation">Relation type</param>
 266         [EditorBrowsable(EditorBrowsableState.Never)]
 267         public void RemoveAccessibilityRelation(View second, AccessibilityRelationType relation)
 268         {
 269             if (second is null)
 270             {
 271                 throw new ArgumentNullException(nameof(second));
 272             }
 273
 274             Interop.ControlDevel.DaliToolkitDevelControlRemoveAccessibilityRelation(SwigCPtr, second.SwigCPtr, (int)relation);
 275             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 276         }
 277
 278         /// <summary>
 279         /// Removes all previously appended relations.
 280         /// </summary>
 281         [EditorBrowsable(EditorBrowsableState.Never)]
 282         public void ClearAccessibilityRelations()
 283         {
 284             Interop.ControlDevel.DaliToolkitDevelControlClearAccessibilityRelations(SwigCPtr);
 285             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 286         }
 287
 288         /// <summary>
 289         /// Gets accessibility collection connected with the current object.
 290         /// </summary>
 291         /// <returns>AddressCollection</returns>
 292         [EditorBrowsable(EditorBrowsableState.Never)]
 293         public AddressCollection GetAccessibilityRelations()
 294         {
 295             var result = new AddressCollection(Interop.ControlDevel.DaliToolkitDevelControlNewGetAccessibilityRelations(SwigCPtr));
 296             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 297             return result;
 298         }
 299
 300         ///////////////////////////////////////////////////////////////////
 301         // ********************* ReadingInfoType *********************** //
 302         ///////////////////////////////////////////////////////////////////
 303
 304         /// <summary>
 305         /// Sets accessibility reading information.
 306         /// </summary>
 307         /// <param name="type">Reading information type</param>
 308         [EditorBrowsable(EditorBrowsableState.Never)]
 309         public void SetAccessibilityReadingInfoTypes(AccessibilityReadingInfoTypes type)
 310         {
 311             Interop.ControlDevel.DaliToolkitDevelControlSetAccessibilityReadingInfoTypes(SwigCPtr, (int)type);
 312             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 313         }
 314
 315         /// <summary>
 316         /// Gets accessibility reading information.
 317         /// </summary>
 318         /// <returns>Reading information type</returns>
 319         [EditorBrowsable(EditorBrowsableState.Never)]
 320         public AccessibilityReadingInfoTypes GetAccessibilityReadingInfoTypes()
 321         {
 322             AccessibilityReadingInfoTypes result = (AccessibilityReadingInfoTypes)Interop.ControlDevel.DaliToolkitDevelControlGetAccessibilityReadingInfoTypes(SwigCPtr);
 323             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 324             return result;
 325         }
 326
 327         ///////////////////////////////////////////////////////////////////
 328         // ******************** Accessibility States ******************* //
 329         ///////////////////////////////////////////////////////////////////
 330
 331         /// <summary>
 332         /// Notifies sending notifications about the current states to accessibility clients.
 333         /// </summary>
 334         /// <remarks>
 335         /// If recursive is true, all children of the Accessibility object will also re-emit the states.
 336         /// </remarks>
 337         /// <param name="states">Accessibility States</param>
 338         /// <param name="recursive">Flag to point if notifications of children's state would be sent</param>
 339         [EditorBrowsable(EditorBrowsableState.Never)]
 340         public void NotifyAccessibilityStatesChange(AccessibilityStates states, bool recursive)
 341         {
 342             Interop.ControlDevel.DaliToolkitDevelControlNotifyAccessibilityStatesChange(SwigCPtr, (ulong)states, Convert.ToInt32(recursive));
 343             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 344         }
 345
 346         /// <summary>
 347         /// Gets Accessibility States.
 348         /// </summary>
 349         /// <returns>Accessibility States</returns>
 350         [EditorBrowsable(EditorBrowsableState.Never)]
 351         public AccessibilityStates GetAccessibilityStates()
 352         {
 353             AccessibilityStates result = (AccessibilityStates) Interop.ControlDevel.DaliToolkitDevelControlGetAccessibilityStates(SwigCPtr);
 354             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 355             return result;
 356         }
 357
 358         ///////////////////////////////////////////////////////////////////
 359         // ************************ Accessible ************************* //
 360         ///////////////////////////////////////////////////////////////////
 361
 362         /// <summary>
 363         /// Emits accessibility property changed event.
 364         /// </summary>
 365         /// <param name="changeEvent">Property changed event</param>
 366         [EditorBrowsable(EditorBrowsableState.Never)]
 367         public void EmitAccessibilityEvent(AccessibilityPropertyChangeEvent changeEvent)
 368         {
 369             Interop.ControlDevel.DaliAccessibilityEmitAccessibilityEvent(SwigCPtr, Convert.ToInt32(changeEvent));
 370             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 371         }
 372
 373         /// <summary>
 374         /// Emits accessibility states changed event.
 375         /// </summary>
 376         /// <param name="state">Accessibility state</param>
 377         /// <param name="equal">True if the state is set or enabled, otherwise false</param>
 378         [EditorBrowsable(EditorBrowsableState.Never)]
 379         public void EmitAccessibilityStatesChangedEvent(AccessibilityStates state, bool equal)
 380         {
 381             Interop.ControlDevel.DaliAccessibilityEmitAccessibilityStatesChangedEvent(SwigCPtr, (ulong)state, Convert.ToInt32(equal));
 382             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 383         }
 384
 385         /// <summary>
 386         /// Emits accessibility text inserted event.
 387         /// </summary>
 388         /// <param name="cursorPosition">Text cursor position</param>
 389         /// <param name="length">Text length</param>
 390         /// <param name="content">Inserted text content</param>
 391         [EditorBrowsable(EditorBrowsableState.Never)]
 392         public void EmitTextInsertedEvent(int cursorPosition, int length, string content)
 393         {
 394             Interop.ControlDevel.DaliAccessibilityEmitTextInsertedEvent(SwigCPtr, cursorPosition, length, content);
 395             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 396         }
 397
 398         /// <summary>
 399         /// Emits accessibility text deleted event.
 400         /// </summary>
 401         /// <param name="cursorPosition">Text cursor position</param>
 402         /// <param name="length">Text length</param>
 403         /// <param name="content">Inserted text content</param>
 404         [EditorBrowsable(EditorBrowsableState.Never)]
 405         public void EmitTextDeletedEvent(int cursorPosition, int length, string content)
 406         {
 407             Interop.ControlDevel.DaliAccessibilityEmitTextDeletedEvent(SwigCPtr, cursorPosition, length, content);
 408             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 409         }
 410
 411         /// <summary>
 412         /// Emits accessibility text cursor moved event.
 413         /// </summary>
 414         /// <param name="cursorPosition">The new cursor position</param>
 415         [EditorBrowsable(EditorBrowsableState.Never)]
 416         public void EmitTextCursorMovedEvent(int cursorPosition)
 417         {
 418             Interop.ControlDevel.DaliAccessibilityEmitTextCursorMovedEvent(SwigCPtr, cursorPosition);
 419             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 420         }
 421
 422         ///////////////////////////////////////////////////////////////////
 423         // ************************** Bridge *************************** //
 424         ///////////////////////////////////////////////////////////////////
 425
 426         /// <summary>
 427         /// Registers popup component to accessibility tree.
 428         /// </summary>
 429         [EditorBrowsable(EditorBrowsableState.Never)]
 430         public void RegisterPopup()
 431         {
 432             Interop.ControlDevel.DaliAccessibilityBridgeRegisterPopup(SwigCPtr);
 433             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 434         }
 435
 436         /// <summary>
 437         /// Removes the previously added popup to accessibility tree.
 438         /// </summary>
 439         [EditorBrowsable(EditorBrowsableState.Never)]
 440         public void RemovePopup()
 441         {
 442             Interop.ControlDevel.DaliAccessibilityBridgeRemovePopup(SwigCPtr);
 443             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 444         }
 445
 446         private IntPtr DuplicateString(string value)
 447         {
 448             return Interop.ControlDevel.DaliToolkitDevelControlAccessibleImplNUIDuplicateString(value ?? "");
 449         }
 450
 451         private IntPtr DuplicateStates(AccessibilityStates states)
 452         {
 453             return Interop.ControlDevel.DaliToolkitDevelControlConvertState((ulong)states);
 454         }
 455
 456         private IntPtr DuplicateRange(AccessibilityRange range)
 457         {
 458             return Interop.ControlDevel.DaliAccessibilityNewRange(range.StartOffset, range.EndOffset, range.Content);
 459         }
 460
 461         private Interop.ControlDevel.AccessibilityDelegate accessibilityDelegate = null;
 462         private IntPtr accessibilityDelegatePtr;
 463
 464         /// <summary>
 465         /// Sets the specific constructor for creating accessibility structure with its role and interface.
 466         /// </summary>
 467         /// <remarks>
 468         /// The method should be called inside OnInitialize method of all classes inheriting from View.
 469         /// </remarks>
 470         /// <param name="role">Accessibility role</param>
 471         /// <param name="accessibilityInterface">Accessibility interface</param>
 472         [EditorBrowsable(EditorBrowsableState.Never)]
 473         public void SetAccessibilityConstructor(Role role, AccessibilityInterface accessibilityInterface = AccessibilityInterface.None)
 474         {
 475             var size = Marshal.SizeOf<Interop.ControlDevel.AccessibilityDelegate>();
 476
 477             if (accessibilityDelegate == null)
 478             {
 479                 accessibilityDelegate = new Interop.ControlDevel.AccessibilityDelegate()
 480                 {
 481                     GetName = () => DuplicateString(AccessibilityGetName()),
 482                     GetDescription = () => DuplicateString(AccessibilityGetDescription()),
 483                     DoAction = (name) => AccessibilityDoAction(Marshal.PtrToStringAnsi(name)),
 484                     CalculateStates = () => DuplicateStates(AccessibilityCalculateStates()),
 485                     GetActionCount = () => AccessibilityGetActionCount(),
 486                     GetActionName = (index) => DuplicateString(AccessibilityGetActionName(index)),
 487                     ShouldReportZeroChildren = () => AccessibilityShouldReportZeroChildren(),
 488                     GetMinimum = () => AccessibilityGetMinimum(),
 489                     GetCurrent = () => AccessibilityGetCurrent(),
 490                     GetMaximum = () => AccessibilityGetMaximum(),
 491                     SetCurrent = (value) => AccessibilitySetCurrent(value),
 492                     GetMinimumIncrement = () => AccessibilityGetMinimumIncrement(),
 493                     IsScrollable = () => AccessibilityIsScrollable(),
 494                     GetText = (startOffset, endOffset) => DuplicateString(AccessibilityGetText(startOffset, endOffset)),
 495                     GetCharacterCount = () => AccessibilityGetCharacterCount(),
 496                     GetCursorOffset = () => AccessibilityGetCursorOffset(),
 497                     SetCursorOffset = (offset) => AccessibilitySetCursorOffset(offset),
 498                     GetTextAtOffset = (offset, boundary) => DuplicateRange(AccessibilityGetTextAtOffset(offset, (AccessibilityTextBoundary)boundary)),
 499                     GetSelection = (selectionNumber) => DuplicateRange(AccessibilityGetSelection(selectionNumber)),
 500                     RemoveSelection = (selectionNumber) => AccessibilityRemoveSelection(selectionNumber),
 501                     SetSelection = (selectionNumber, startOffset, endOffset) => AccessibilitySetSelection(selectionNumber, startOffset, endOffset),
 502                     CopyText = (startPosition, endPosition) => AccessibilityCopyText(startPosition, endPosition),
 503                     CutText = (startPosition, endPosition) => AccessibilityCutText(startPosition, endPosition),
 504                     InsertText = (startPosition, text) => AccessibilityInsertText(startPosition, Marshal.PtrToStringAnsi(text)),
 505                     SetTextContents = (newContents) => AccessibilitySetTextContents(Marshal.PtrToStringAnsi(newContents)),
 506                     DeleteText = (startPosition, endPosition) => AccessibilityDeleteText(startPosition, endPosition),
 507                     ScrollToChild = (child) => {
 508                         using (var view = new View(child, true))
 509                         {
 510                             return AccessibilityScrollToChild(view);
 511                         }
 512                     },
 513                     GetSelectedChildrenCount = () => AccessibilityGetSelectedChildrenCount(),
 514                     GetSelectedChild = (selectedChildIndex) => View.getCPtr(AccessibilityGetSelectedChild(selectedChildIndex)).Handle,
 515                     SelectChild = (childIndex) => AccessibilitySelectChild(childIndex),
 516                     DeselectSelectedChild = (selectedChildIndex) => AccessibilityDeselectSelectedChild(selectedChildIndex),
 517                     IsChildSelected = (childIndex) => AccessibilityIsChildSelected(childIndex),
 518                     SelectAll = () => AccessibilitySelectAll(),
 519                     ClearSelection = () => AccessibilityClearSelection(),
 520                     DeselectChild = (childIndex) => AccessibilityDeselectChild(childIndex),
 521                 };
 522
 523                 accessibilityDelegatePtr = Marshal.AllocHGlobal(size);
 524                 Marshal.StructureToPtr(accessibilityDelegate, accessibilityDelegatePtr, false);
 525             }
 526
 527             Interop.ControlDevel.DaliToolkitDevelControlSetAccessibilityConstructor(SwigCPtr, (int)role, (int)accessibilityInterface, accessibilityDelegatePtr, size);
 528
 529             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 530         }
 531
 532         /// <summary>
 533         /// A helper method to manipulate individual bit flags (e.g. turn them on or off)
 534         /// </summary>
 535         /// <param name="obj">An object that accumulates combination of bit flags</param>
 536         /// <param name="bit">A bit flag to be operated</param>
 537         /// <param name="state">A state of the bit flag to be set (0 == off, 1 == on)</param>
 538         [EditorBrowsable(EditorBrowsableState.Never)]
 539         static public void FlagSetter<T>(ref T obj ,T bit, bool state)
 540         {
 541             dynamic result = obj;
 542             dynamic param = bit;
 543             if (state)
 544             {
 545                 result |= param;
 546             }
 547             else
 548             {
 549                 result &= (~param);
 550             }
 551             obj = result;
 552         }
 553
 554         [EditorBrowsable(EditorBrowsableState.Never)]
 555         protected override void Dispose(bool disposing)
 556         {
 557             if (disposed)
 558             {
 559                 return;
 560             }
 561
 562             if (disposing)
 563             {
 564                 Unparent();
 565             }
 566
 567             if (accessibilityDelegate != null)
 568             {
 569                 Marshal.DestroyStructure<Interop.ControlDevel.AccessibilityDelegate>(accessibilityDelegatePtr);
 570                 Marshal.FreeHGlobal(accessibilityDelegatePtr);
 571                 accessibilityDelegate = null;
 572             }
 573
 574             base.Dispose(disposing);
 575         }
 576
 577         [EditorBrowsable(EditorBrowsableState.Never)]
 578         protected static readonly string AccessibilityActivateAction = "activate";
 579         [EditorBrowsable(EditorBrowsableState.Never)]
 580         protected static readonly string AccessibilityReadingSkippedAction = "ReadingSkipped";
 581         [EditorBrowsable(EditorBrowsableState.Never)]
 582         protected static readonly string AccessibilityReadingCancelledAction = "ReadingCancelled";
 583         [EditorBrowsable(EditorBrowsableState.Never)]
 584         protected static readonly string AccessibilityReadingStoppedAction = "ReadingStopped";
 585         [EditorBrowsable(EditorBrowsableState.Never)]
 586         protected static readonly string AccessibilityReadingPausedAction = "ReadingPaused";
 587         [EditorBrowsable(EditorBrowsableState.Never)]
 588         protected static readonly string AccessibilityReadingResumedAction = "ReadingResumed";
 589
 590         [EditorBrowsable(EditorBrowsableState.Never)]
 591         private static readonly string[] AccessibilityActions = {
 592             AccessibilityActivateAction,
 593             AccessibilityReadingSkippedAction,
 594             AccessibilityReadingCancelledAction,
 595             AccessibilityReadingStoppedAction,
 596             AccessibilityReadingPausedAction,
 597             AccessibilityReadingResumedAction,
 598         };
 599
 600         [EditorBrowsable(EditorBrowsableState.Never)]
 601         protected virtual string AccessibilityGetName()
 602         {
 603             return "";
 604         }
 605
 606         [EditorBrowsable(EditorBrowsableState.Never)]
 607         protected virtual string AccessibilityGetDescription()
 608         {
 609             return "";
 610         }
 611
 612         [EditorBrowsable(EditorBrowsableState.Never)]
 613         protected virtual bool AccessibilityDoAction(string name)
 614         {
 615             return false;
 616         }
 617
 618         [EditorBrowsable(EditorBrowsableState.Never)]
 619         protected virtual AccessibilityStates AccessibilityCalculateStates()
 620         {
 621             AccessibilityStates states = 0;
 622
 623             FlagSetter(ref states, AccessibilityStates.Highlightable, this.AccessibilityHighlightable);
 624             FlagSetter(ref states, AccessibilityStates.Focusable, this.Focusable);
 625             FlagSetter(ref states, AccessibilityStates.Focused, this.State == States.Focused);
 626             FlagSetter(ref states, AccessibilityStates.Highlighted, this.IsHighlighted);
 627             FlagSetter(ref states, AccessibilityStates.Enabled, this.State != States.Disabled);
 628             FlagSetter(ref states, AccessibilityStates.Sensitive, this.Sensitive);
 629             FlagSetter(ref states, AccessibilityStates.Visible, true);
 630             FlagSetter(ref states, AccessibilityStates.Showing, this.Visibility);
 631             FlagSetter(ref states, AccessibilityStates.Defunct, !this.IsOnWindow);
 632
 633             return states;
 634         }
 635
 636         [EditorBrowsable(EditorBrowsableState.Never)]
 637         protected virtual int AccessibilityGetActionCount()
 638         {
 639             return AccessibilityActions.Length;
 640         }
 641
 642         [EditorBrowsable(EditorBrowsableState.Never)]
 643         protected virtual string AccessibilityGetActionName(int index)
 644         {
 645             if (index >= 0 && index < AccessibilityActions.Length)
 646             {
 647                 return AccessibilityActions[index];
 648             }
 649             else
 650             {
 651                 return "";
 652             }
 653         }
 654
 655         [EditorBrowsable(EditorBrowsableState.Never)]
 656         protected virtual bool AccessibilityShouldReportZeroChildren()
 657         {
 658             return false;
 659         }
 660
 661         [EditorBrowsable(EditorBrowsableState.Never)]
 662         protected virtual double AccessibilityGetMinimum()
 663         {
 664             return 0.0;
 665         }
 666
 667         [EditorBrowsable(EditorBrowsableState.Never)]
 668         protected virtual double AccessibilityGetCurrent()
 669         {
 670             return 0.0;
 671         }
 672
 673         [EditorBrowsable(EditorBrowsableState.Never)]
 674         protected virtual double AccessibilityGetMaximum()
 675         {
 676             return 0.0;
 677         }
 678
 679         [EditorBrowsable(EditorBrowsableState.Never)]
 680         protected virtual bool AccessibilitySetCurrent(double value)
 681         {
 682             return false;
 683         }
 684
 685         [EditorBrowsable(EditorBrowsableState.Never)]
 686         protected virtual double AccessibilityGetMinimumIncrement()
 687         {
 688             return 0.0;
 689         }
 690
 691         [EditorBrowsable(EditorBrowsableState.Never)]
 692         protected virtual bool AccessibilityIsScrollable()
 693         {
 694             return false;
 695         }
 696
 697         [EditorBrowsable(EditorBrowsableState.Never)]
 698         protected virtual string AccessibilityGetText(int startOffset, int endOffset)
 699         {
 700             return "";
 701         }
 702
 703         [EditorBrowsable(EditorBrowsableState.Never)]
 704         protected virtual int AccessibilityGetCharacterCount()
 705         {
 706             return 0;
 707         }
 708
 709         [EditorBrowsable(EditorBrowsableState.Never)]
 710         protected virtual int AccessibilityGetCursorOffset()
 711         {
 712             return 0;
 713         }
 714
 715         [EditorBrowsable(EditorBrowsableState.Never)]
 716         protected virtual bool AccessibilitySetCursorOffset(int offset)
 717         {
 718             return false;
 719         }
 720
 721         [EditorBrowsable(EditorBrowsableState.Never)]
 722         protected virtual AccessibilityRange AccessibilityGetTextAtOffset(int offset, AccessibilityTextBoundary boundary)
 723         {
 724             return new AccessibilityRange();
 725         }
 726
 727         [EditorBrowsable(EditorBrowsableState.Never)]
 728         protected virtual AccessibilityRange AccessibilityGetSelection(int selectionNumber)
 729         {
 730             return new AccessibilityRange();
 731         }
 732
 733         [EditorBrowsable(EditorBrowsableState.Never)]
 734         protected virtual bool AccessibilityRemoveSelection(int selectionNumber)
 735         {
 736             return false;
 737         }
 738
 739         [EditorBrowsable(EditorBrowsableState.Never)]
 740         protected virtual bool AccessibilitySetSelection(int selectionNumber, int startOffset, int endOffset)
 741         {
 742             return false;
 743         }
 744
 745         [EditorBrowsable(EditorBrowsableState.Never)]
 746         protected virtual bool AccessibilityCopyText(int startPosition, int endPosition)
 747         {
 748             return false;
 749         }
 750
 751         [EditorBrowsable(EditorBrowsableState.Never)]
 752         protected virtual bool AccessibilityCutText(int startPosition, int endPosition)
 753         {
 754             return false;
 755         }
 756
 757         [EditorBrowsable(EditorBrowsableState.Never)]
 758         protected virtual bool AccessibilityInsertText(int startPosition, string text)
 759         {
 760             return false;
 761         }
 762
 763         [EditorBrowsable(EditorBrowsableState.Never)]
 764         protected virtual bool AccessibilitySetTextContents(string newContents)
 765         {
 766             return false;
 767         }
 768
 769         [EditorBrowsable(EditorBrowsableState.Never)]
 770         protected virtual bool AccessibilityDeleteText(int startPosition, int endPosition)
 771         {
 772             return false;
 773         }
 774
 775         [EditorBrowsable(EditorBrowsableState.Never)]
 776         protected virtual bool AccessibilityScrollToChild(View child)
 777         {
 778             return false;
 779         }
 780
 781         [EditorBrowsable(EditorBrowsableState.Never)]
 782         protected virtual int AccessibilityGetSelectedChildrenCount()
 783         {
 784             return 0;
 785         }
 786
 787         [EditorBrowsable(EditorBrowsableState.Never)]
 788         protected virtual View AccessibilityGetSelectedChild(int selectedChildIndex)
 789         {
 790             return null;
 791         }
 792
 793         [EditorBrowsable(EditorBrowsableState.Never)]
 794         protected virtual bool AccessibilitySelectChild(int childIndex)
 795         {
 796             return false;
 797         }
 798
 799         [EditorBrowsable(EditorBrowsableState.Never)]
 800         protected virtual bool AccessibilityDeselectSelectedChild(int selectedChildIndex)
 801         {
 802             return false;
 803         }
 804
 805         [EditorBrowsable(EditorBrowsableState.Never)]
 806         protected virtual bool AccessibilityIsChildSelected(int childIndex)
 807         {
 808             return false;
 809         }
 810
 811         [EditorBrowsable(EditorBrowsableState.Never)]
 812         protected virtual bool AccessibilitySelectAll()
 813         {
 814             return false;
 815         }
 816
 817         [EditorBrowsable(EditorBrowsableState.Never)]
 818         protected virtual bool AccessibilityClearSelection()
 819         {
 820             return false;
 821         }
 822
 823         [EditorBrowsable(EditorBrowsableState.Never)]
 824         protected virtual bool AccessibilityDeselectChild(int childIndex)
 825         {
 826             return false;
 827         }
 828     }
 829 }