src/Tizen.NUI/src/public/BaseComponents/ViewAccessibilityEvent.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.Components;
  22 using Tizen.NUI;
  23
  24 namespace Tizen.NUI.BaseComponents
  25 {
  26     [EditorBrowsable(EditorBrowsableState.Never)]
  27     [StructLayout(LayoutKind.Sequential)]
  28     public struct GestureInfoType {
  29         [EditorBrowsable(EditorBrowsableState.Never)]
  30         public AccessibilityGesture type { get; set; }
  31
  32         [EditorBrowsable(EditorBrowsableState.Never)]
  33         public int xBeg { get; set; }
  34
  35         [EditorBrowsable(EditorBrowsableState.Never)]
  36         public int xEnd { get; set; }
  37
  38         [EditorBrowsable(EditorBrowsableState.Never)]
  39         public int yBeg { get; set; }
  40
  41         [EditorBrowsable(EditorBrowsableState.Never)]
  42         public int yEnd { get; set; }
  43
  44         [EditorBrowsable(EditorBrowsableState.Never)]
  45         public AccessibilityGestureState state { get; set; }
  46
  47         [EditorBrowsable(EditorBrowsableState.Never)]
  48         public uint eventTime { get; set; }
  49
  50         [EditorBrowsable(EditorBrowsableState.Never)]
  51         public override bool Equals(System.Object obj)
  52         {
  53             if ((obj == null) || !this.GetType().Equals(obj.GetType()))
  54                 return false;
  55
  56             GestureInfoType sec = (GestureInfoType)obj;
  57             return
  58               type == sec.type &&
  59               xBeg == sec.xBeg &&
  60               xEnd == sec.xEnd &&
  61               yBeg == sec.yBeg &&
  62               yEnd == sec.yEnd &&
  63               state == sec.state &&
  64               eventTime == sec.eventTime;
  65         }
  66
  67         [EditorBrowsable(EditorBrowsableState.Never)]
  68         public override int GetHashCode()
  69         {
  70             return Tuple.Create((int)type, xBeg, xEnd, yBeg, yEnd, (int)state, eventTime).GetHashCode();
  71         }
  72     }
  73
  74     /// <summary>
  75     /// View is the base class for all views.
  76     /// </summary>
  77     /// <since_tizen> 3 </since_tizen>
  78     public partial class View
  79     {
  80         internal class ControlHandle : SafeHandle {
  81             public ControlHandle() : base (IntPtr.Zero, true) {}
  82
  83             public ControlHandle(IntPtr ptr) : base(ptr, true) {}
  84
  85             public override bool IsInvalid {
  86                 get {
  87                     return this.handle == IntPtr.Zero;
  88                 }
  89             }
  90
  91             protected override bool ReleaseHandle() {
  92                 Interop.View.DeleteControlHandleView(handle);
  93                 this.SetHandle(IntPtr.Zero);
  94                 return true;
  95             }
  96         }
  97
  98         [EditorBrowsable(EditorBrowsableState.Never)]
  99         ControlHandle GetControl() {
 100             var ret = new ControlHandle(Interop.View.DownCast(SwigCPtr));
 101             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 102             return ret;
 103         }
 104
 105         ///////////////////////////////////////////////////////////////////
 106         // ***************** AccessiblityDoGestureSignal ****************//
 107         ///////////////////////////////////////////////////////////////////
 108
 109         private delegate void GestureInfoHandlerType(IntPtr data);
 110         private GestureInfoHandlerType gestureInfoCallback;
 111         private EventHandler<GestureInfoEventArgs> gestureInfoHandler;
 112
 113         [EditorBrowsable(EditorBrowsableState.Never)]
 114         public class GestureInfoEventArgs : EventArgs
 115         {
 116             public GestureInfoType gestureInfo { get; internal set; }
 117             public int boolValue { get; set; }
 118         }
 119
 120         private void OnGestureInfoEvent(IntPtr data) {
 121             if (data == IntPtr.Zero)
 122                 return;
 123
 124             if (Marshal.SizeOf<GestureInfoType>() != AccessibilityDoGestureSignal.GetSizeOfGestureInfo()) {
 125                 throw new global::System.ApplicationException("ABI mismatch SizeOf(C# GestureInfo) != SizeOf(c++ GestureInfo)");
 126             }
 127
 128             var arg = new GestureInfoEventArgs();
 129
 130             arg.boolValue = AccessibilityDoGestureSignal.GetResult(data);
 131             arg.gestureInfo = (GestureInfoType)Marshal.PtrToStructure(data, typeof(GestureInfoType));
 132
 133             gestureInfoHandler?.Invoke(this, arg);
 134
 135             AccessibilityDoGestureSignal.SetResult(data, Convert.ToInt32(arg.boolValue));
 136         }
 137
 138         // This uses DoGestureInfo signal from C++ API.
 139         [EditorBrowsable(EditorBrowsableState.Never)]
 140         public event EventHandler<GestureInfoEventArgs> GestureInfoReceived {
 141             add {
 142                 if (gestureInfoHandler == null) {
 143                     gestureInfoCallback = OnGestureInfoEvent;
 144                     GestureInfoSignal().Connect(gestureInfoCallback);
 145                 }
 146                 gestureInfoHandler += value;
 147             }
 148             remove {
 149                 gestureInfoHandler -= value;
 150                 if (gestureInfoHandler == null && GestureInfoSignal().Empty() == false)
 151                     GestureInfoSignal().Disconnect(gestureInfoCallback);
 152             }
 153         }
 154
 155         internal AccessibilityDoGestureSignal GestureInfoSignal() {
 156             var handle = GetControl();
 157             AccessibilityDoGestureSignal ret = new AccessibilityDoGestureSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityDoGestureSignal(handle), false);
 158             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 159             return ret;
 160         }
 161
 162         ///////////////////////////////////////////////////////////////////
 163         // ************** AccessiblityGetDescriptionSignal ************* //
 164         ///////////////////////////////////////////////////////////////////
 165
 166         private delegate void GetDescriptionHandlerType(IntPtr data);
 167         private GetDescriptionHandlerType getDescriptionCallback;
 168         private EventHandler<GetDescriptionEventArgs> getDescriptionHandler;
 169
 170         [EditorBrowsable(EditorBrowsableState.Never)]
 171         public class GetDescriptionEventArgs : EventArgs
 172         {
 173             public string description { get; internal set; }
 174         }
 175
 176         private void OnGetDescriptionEvent(IntPtr data) {
 177             if (data == IntPtr.Zero)
 178                 return;
 179
 180             var arg = new GetDescriptionEventArgs();
 181             arg.description = StringToVoidSignal.ConvertParam1(data);
 182
 183             getDescriptionHandler?.Invoke(this, arg);
 184         }
 185
 186         // This uses GetDescription signal from C++ API.
 187         [EditorBrowsable(EditorBrowsableState.Never)]
 188         public event EventHandler<GetDescriptionEventArgs> DescriptionRequested {
 189             add {
 190                 if (getDescriptionHandler == null) {
 191                     getDescriptionCallback = OnGetDescriptionEvent;
 192                     GetDescriptionSignal().Connect(getDescriptionCallback);
 193                 }
 194                 getDescriptionHandler += value;
 195             }
 196             remove {
 197                 getDescriptionHandler -= value;
 198                 if (getDescriptionHandler == null && GetDescriptionSignal().Empty() == false)
 199                     GetDescriptionSignal().Disconnect(getDescriptionCallback);
 200             }
 201         }
 202
 203         internal StringToVoidSignal GetDescriptionSignal() {
 204             var handle = GetControl();
 205             StringToVoidSignal ret = new StringToVoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityGetDescriptionSignal(handle), false);
 206             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 207             return ret;
 208         }
 209
 210         ///////////////////////////////////////////////////////////////////
 211         // ***************** AccessiblityGetNameSignal ***************** //
 212         ///////////////////////////////////////////////////////////////////
 213
 214         private delegate void GetNameHandlerType(IntPtr data);
 215         private GetNameHandlerType getNameCallback;
 216         private EventHandler<GetNameEventArgs> getNameHandler;
 217
 218         [EditorBrowsable(EditorBrowsableState.Never)]
 219         public class GetNameEventArgs : EventArgs
 220         {
 221             public string description { get; internal set; }
 222         }
 223
 224         private void OnGetNameEvent(IntPtr data) {
 225             if (data == IntPtr.Zero)
 226                 return;
 227
 228             var arg = new GetNameEventArgs();
 229             arg.description = StringToVoidSignal.ConvertParam1(data);
 230
 231             getNameHandler?.Invoke(this, arg);
 232         }
 233
 234         // This uses GetName signal from C++ API.
 235         [EditorBrowsable(EditorBrowsableState.Never)]
 236         public event EventHandler<GetNameEventArgs> NameRequested {
 237             add {
 238                 if (getNameHandler == null) {
 239                     getNameCallback = OnGetNameEvent;
 240                     GetNameSignal().Connect(getNameCallback);
 241                 }
 242                 getNameHandler += value;
 243             }
 244             remove {
 245                 getNameHandler -= value;
 246                 if (getNameHandler == null && GetNameSignal().Empty() == false)
 247                     GetNameSignal().Disconnect(getNameCallback);
 248             }
 249         }
 250
 251         internal StringToVoidSignal GetNameSignal() {
 252             var handle = GetControl();
 253             StringToVoidSignal ret = new StringToVoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityGetNameSignal(handle), false);
 254             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 255             return ret;
 256         }
 257
 258         ///////////////////////////////////////////////////////////////////
 259         // **************** AccessibilityActivateSignal **************** //
 260         ///////////////////////////////////////////////////////////////////
 261
 262         private delegate void VoidHandlerType();
 263         private VoidHandlerType activateCallback;
 264         private EventHandler activateHandler;
 265
 266         private void OnActivateEvent() {
 267             activateHandler?.Invoke(this, null);
 268         }
 269
 270         [EditorBrowsable(EditorBrowsableState.Never)]
 271         public event EventHandler Activate {
 272             add {
 273                 if (activateHandler == null) {
 274                     activateCallback = OnActivateEvent;
 275                     ActivateSignal().Connect(activateCallback);
 276                 }
 277                 activateHandler += value;
 278             }
 279             remove {
 280                 activateHandler -= value;
 281                 if (activateHandler == null && ActivateSignal().Empty() == false)
 282                     ActivateSignal().Disconnect(activateCallback);
 283             }
 284         }
 285
 286         internal VoidSignal ActivateSignal() {
 287             var handle = GetControl();
 288             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityActivateSignal(handle), false);
 289             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 290             return ret;
 291         }
 292
 293         ///////////////////////////////////////////////////////////////////
 294         // ************ AccessibilityReadingSkippedSignal ************** //
 295         ///////////////////////////////////////////////////////////////////
 296
 297         private VoidHandlerType readingSkippedCallback;
 298         private EventHandler readingSkippedHandler;
 299
 300         private void OnReadingSkippedEvent() {
 301             readingSkippedHandler?.Invoke(this, null);
 302         }
 303
 304         [EditorBrowsable(EditorBrowsableState.Never)]
 305         public event EventHandler ReadingSkipped {
 306             add {
 307                 if (readingSkippedHandler == null) {
 308                     readingSkippedCallback = OnReadingSkippedEvent;
 309                     ReadingSkippedSignal().Connect(readingSkippedCallback);
 310                 }
 311                 readingSkippedHandler += value;
 312             }
 313             remove {
 314                 readingSkippedHandler -= value;
 315                 if (readingSkippedHandler == null && ReadingSkippedSignal().Empty() == false)
 316                     ReadingSkippedSignal().Disconnect(readingSkippedCallback);
 317             }
 318         }
 319
 320         internal VoidSignal ReadingSkippedSignal() {
 321             var handle = GetControl();
 322             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingSkippedSignal(handle), false);
 323             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 324             return ret;
 325         }
 326
 327         ///////////////////////////////////////////////////////////////////
 328         // ************* AccessibilityReadingPausedSignal ************** //
 329         ///////////////////////////////////////////////////////////////////
 330
 331         private VoidHandlerType readingPausedCallback;
 332         private EventHandler readingPausedHandler;
 333
 334         private void OnReadingPausedEvent() {
 335             readingPausedHandler?.Invoke(this, null);
 336         }
 337
 338         [EditorBrowsable(EditorBrowsableState.Never)]
 339         public event EventHandler ReadingPaused {
 340             add {
 341                 if (readingPausedHandler == null) {
 342                     readingPausedCallback = OnReadingPausedEvent;
 343                     ReadingPausedSignal().Connect(readingPausedCallback);
 344                 }
 345                 readingPausedHandler += value;
 346             }
 347             remove {
 348                 readingPausedHandler -= value;
 349                 if (readingPausedHandler == null && ReadingPausedSignal().Empty() == false)
 350                     ReadingPausedSignal().Disconnect(readingPausedCallback);
 351             }
 352         }
 353
 354         internal VoidSignal ReadingPausedSignal() {
 355             var handle = GetControl();
 356             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingPausedSignal(handle), false);
 357             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 358             return ret;
 359         }
 360
 361         ///////////////////////////////////////////////////////////////////
 362         // ************* AccessibilityReadingResumedSignal ************* //
 363         ///////////////////////////////////////////////////////////////////
 364
 365         private VoidHandlerType readingResumedCallback;
 366         private EventHandler readingResumedHandler;
 367
 368         private void OnReadingResumedEvent() {
 369             readingResumedHandler?.Invoke(this, null);
 370         }
 371
 372         [EditorBrowsable(EditorBrowsableState.Never)]
 373         public event EventHandler ReadingResumed  {
 374             add {
 375                 if (readingResumedHandler == null) {
 376                     readingResumedCallback = OnReadingResumedEvent;
 377                     ReadingResumedSignal().Connect(readingResumedCallback);
 378                 }
 379                 readingResumedHandler += value;
 380             }
 381             remove {
 382                 readingResumedHandler -= value;
 383                 if (readingResumedHandler == null && ReadingResumedSignal().Empty() == false)
 384                     ReadingResumedSignal().Disconnect(readingResumedCallback);
 385             }
 386         }
 387
 388         internal VoidSignal ReadingResumedSignal() {
 389             var handle = GetControl();
 390             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingResumedSignal(handle), false);
 391             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 392             return ret;
 393         }
 394
 395         ///////////////////////////////////////////////////////////////////
 396         // ************ AccessibilityReadingCancelledSignal ************ //
 397         ///////////////////////////////////////////////////////////////////
 398
 399         private VoidHandlerType readingCancelledCallback;
 400         private EventHandler readingCancelledHandler;
 401
 402         private void OnReadingCancelledEvent() {
 403             readingCancelledHandler?.Invoke(this, null);
 404         }
 405
 406         [EditorBrowsable(EditorBrowsableState.Never)]
 407         public event EventHandler ReadingCancelled  {
 408             add {
 409                 if (readingCancelledHandler == null) {
 410                     readingCancelledCallback = OnReadingCancelledEvent;
 411                     ReadingCancelledSignal().Connect(readingCancelledCallback);
 412                 }
 413                 readingCancelledHandler += value;
 414             }
 415             remove {
 416                 readingCancelledHandler -= value;
 417                 if (readingCancelledHandler == null && ReadingCancelledSignal().Empty() == false)
 418                     ReadingCancelledSignal().Disconnect(readingCancelledCallback);
 419             }
 420         }
 421
 422         internal VoidSignal ReadingCancelledSignal() {
 423             var handle = GetControl();
 424             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingCancelledSignal(handle), false);
 425             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 426             return ret;
 427         }
 428
 429         ///////////////////////////////////////////////////////////////////
 430         // ************* AccessibilityReadingStoppedSignal ************* //
 431         ///////////////////////////////////////////////////////////////////
 432
 433         private VoidHandlerType readingStoppedCallback;
 434         private EventHandler readingStoppedHandler;
 435
 436         private void OnReadingStoppedEvent() {
 437             readingStoppedHandler?.Invoke(this, null);
 438         }
 439
 440         [EditorBrowsable(EditorBrowsableState.Never)]
 441         public event EventHandler ReadingStopped  {
 442             add {
 443                 if (readingStoppedHandler == null) {
 444                     readingStoppedCallback = OnReadingStoppedEvent;
 445                     ReadingStoppedSignal().Connect(readingStoppedCallback);
 446                 }
 447                 readingStoppedHandler += value;
 448             }
 449             remove {
 450                 readingStoppedHandler -= value;
 451                 if (readingStoppedHandler == null && ReadingStoppedSignal().Empty() == false)
 452                     ReadingStoppedSignal().Disconnect(readingStoppedCallback);
 453             }
 454         }
 455
 456         internal VoidSignal ReadingStoppedSignal() {
 457             var handle = GetControl();
 458             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingStoppedSignal(handle), false);
 459             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 460             return ret;
 461         }
 462     }
 463 }