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 : IEquatable<GestureInfoType>
  29     {
  30         [EditorBrowsable(EditorBrowsableState.Never)]
  31         public AccessibilityGesture type { get; set; }
  32
  33         [EditorBrowsable(EditorBrowsableState.Never)]
  34         public int xBeg { get; set; }
  35
  36         [EditorBrowsable(EditorBrowsableState.Never)]
  37         public int xEnd { get; set; }
  38
  39         [EditorBrowsable(EditorBrowsableState.Never)]
  40         public int yBeg { get; set; }
  41
  42         [EditorBrowsable(EditorBrowsableState.Never)]
  43         public int yEnd { get; set; }
  44
  45         [EditorBrowsable(EditorBrowsableState.Never)]
  46         public AccessibilityGestureState state { get; set; }
  47
  48         [EditorBrowsable(EditorBrowsableState.Never)]
  49         public uint eventTime { get; set; }
  50
  51         [EditorBrowsable(EditorBrowsableState.Never)]
  52         public override bool Equals(System.Object obj)
  53         {
  54             if (obj is GestureInfoType)
  55             {
  56                 return this.Equals((GestureInfoType)obj);
  57             }
  58             return false;
  59         }
  60
  61         public bool Equals(GestureInfoType other)
  62         {
  63             if ((other == null) || !this.GetType().Equals(other.GetType()))
  64                 return false;
  65
  66             GestureInfoType sec = (GestureInfoType)other;
  67             return
  68               type == sec.type &&
  69               xBeg == sec.xBeg &&
  70               xEnd == sec.xEnd &&
  71               yBeg == sec.yBeg &&
  72               yEnd == sec.yEnd &&
  73               state == sec.state &&
  74               eventTime == sec.eventTime;
  75         }
  76
  77         [EditorBrowsable(EditorBrowsableState.Never)]
  78         public static bool operator ==(GestureInfoType arg1, GestureInfoType arg2)
  79         {
  80             return arg1.Equals(arg2);
  81         }
  82
  83         /// <summary>
  84         /// The != operator.
  85         /// </summary>
  86         [EditorBrowsable(EditorBrowsableState.Never)]
  87         public static bool operator !=(GestureInfoType arg1, GestureInfoType arg2)
  88         {
  89             return !arg1.Equals(arg2);
  90         }
  91
  92         [EditorBrowsable(EditorBrowsableState.Never)]
  93         public override int GetHashCode()
  94         {
  95             return Tuple.Create((int)type, xBeg, xEnd, yBeg, yEnd, (int)state, eventTime).GetHashCode();
  96         }
  97     }
  98
  99     [EditorBrowsable(EditorBrowsableState.Never)]
 100     public class GestureInfoEventArgs : EventArgs
 101     {
 102         public GestureInfoType GestureInfo { get; internal set; }
 103         public int Consumed { get; set; }
 104     }
 105
 106     [EditorBrowsable(EditorBrowsableState.Never)]
 107     public class GetDescriptionEventArgs : EventArgs
 108     {
 109         public string Description { get; set; }
 110     }
 111
 112     [EditorBrowsable(EditorBrowsableState.Never)]
 113     public class GetNameEventArgs : EventArgs
 114     {
 115         public string Name { get; set; }
 116     }
 117
 118     /// <summary>
 119     /// View is the base class for all views.
 120     /// </summary>
 121     /// <since_tizen> 3 </since_tizen>
 122     public partial class View
 123     {
 124         internal class ControlHandle : SafeHandle
 125         {
 126             public ControlHandle() : base(IntPtr.Zero, true) { }
 127
 128             public ControlHandle(IntPtr ptr) : base(ptr, true) { }
 129
 130             public override bool IsInvalid
 131             {
 132                 get
 133                 {
 134                     return this.handle == IntPtr.Zero;
 135                 }
 136             }
 137
 138             protected override bool ReleaseHandle()
 139             {
 140                 Interop.View.DeleteControlHandleView(handle);
 141                 this.SetHandle(IntPtr.Zero);
 142                 return true;
 143             }
 144         }
 145
 146         [EditorBrowsable(EditorBrowsableState.Never)]
 147         ControlHandle GetControl()
 148         {
 149             var ret = new ControlHandle(Interop.View.DownCast(SwigCPtr));
 150             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 151             return ret;
 152         }
 153
 154         ///////////////////////////////////////////////////////////////////
 155         // ***************** AccessiblityDoGestureSignal ****************//
 156         ///////////////////////////////////////////////////////////////////
 157
 158         private delegate void GestureInfoHandlerType(IntPtr data);
 159         private GestureInfoHandlerType gestureInfoCallback;
 160         private EventHandler<GestureInfoEventArgs> gestureInfoHandler;
 161         private AccessibilityDoGestureSignal gestureInfoSignal;
 162
 163         private void OnAccessibilityGestureInfoEvent(IntPtr data)
 164         {
 165             if (data == IntPtr.Zero)
 166                 return;
 167
 168             if (Marshal.SizeOf<GestureInfoType>() != AccessibilityDoGestureSignal.GetSizeOfGestureInfo())
 169             {
 170                 throw new global::System.ApplicationException("ABI mismatch SizeOf(C# GestureInfo) != SizeOf(c++ GestureInfo)");
 171             }
 172
 173             var arg = new GestureInfoEventArgs();
 174
 175             arg.Consumed = AccessibilityDoGestureSignal.GetResult(data);
 176             arg.GestureInfo = (GestureInfoType)Marshal.PtrToStructure(data, typeof(GestureInfoType));
 177
 178             gestureInfoHandler?.Invoke(this, arg);
 179
 180             AccessibilityDoGestureSignal.SetResult(data, Convert.ToInt32(arg.Consumed));
 181         }
 182
 183         // This uses DoGestureInfo signal from C++ API.
 184         [EditorBrowsable(EditorBrowsableState.Never)]
 185         public event EventHandler<GestureInfoEventArgs> AccessibilityGestureInfoReceived
 186         {
 187             add
 188             {
 189                 if (gestureInfoHandler == null)
 190                 {
 191                     gestureInfoCallback = OnAccessibilityGestureInfoEvent;
 192                     gestureInfoSignal = this.AccessibilityGestureInfoSignal();
 193                     gestureInfoSignal?.Connect(gestureInfoCallback);
 194                 }
 195                 gestureInfoHandler += value;
 196             }
 197             remove
 198             {
 199                 gestureInfoHandler -= value;
 200                 if (gestureInfoHandler == null && gestureInfoCallback != null)
 201                 {
 202                     gestureInfoSignal?.Disconnect(gestureInfoCallback);
 203                     gestureInfoSignal?.Dispose();
 204                     gestureInfoSignal = null;
 205                 }
 206             }
 207         }
 208
 209         internal AccessibilityDoGestureSignal AccessibilityGestureInfoSignal()
 210         {
 211             var handle = GetControl();
 212             AccessibilityDoGestureSignal ret = new AccessibilityDoGestureSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityDoGestureSignal(handle), false);
 213             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 214             return ret;
 215         }
 216
 217         ///////////////////////////////////////////////////////////////////
 218         // ************** AccessiblityGetDescriptionSignal ************* //
 219         ///////////////////////////////////////////////////////////////////
 220
 221         private delegate void GetDescriptionHandlerType(IntPtr data);
 222         private GetDescriptionHandlerType getDescriptionCallback;
 223         private EventHandler<GetDescriptionEventArgs> getDescriptionHandler;
 224         private StringToVoidSignal getDescriptionSignal;
 225
 226         private void OnGetAccessibilityDescriptionEvent(IntPtr data)
 227         {
 228             if (data == IntPtr.Zero)
 229                 return;
 230
 231             var arg = new GetDescriptionEventArgs();
 232             arg.Description = StringToVoidSignal.GetResult(data);
 233
 234             getDescriptionHandler?.Invoke(this, arg);
 235
 236             StringToVoidSignal.SetResult(data, arg.Description);
 237         }
 238
 239         // This uses GetDescription signal from C++ API.
 240         [EditorBrowsable(EditorBrowsableState.Never)]
 241         public event EventHandler<GetDescriptionEventArgs> AccessibilityDescriptionRequested
 242         {
 243             add
 244             {
 245                 if (getDescriptionHandler == null)
 246                 {
 247                     getDescriptionCallback = OnGetAccessibilityDescriptionEvent;
 248                     getDescriptionSignal = this.GetAccessibilityDescriptionSignal();
 249                     getDescriptionSignal?.Connect(getDescriptionCallback);
 250                 }
 251                 getDescriptionHandler += value;
 252             }
 253             remove
 254             {
 255                 getDescriptionHandler -= value;
 256                 if (getDescriptionHandler == null && getDescriptionCallback != null)
 257                 {
 258                     getDescriptionSignal?.Disconnect(getDescriptionCallback);
 259                     getDescriptionSignal?.Dispose();
 260                     getDescriptionSignal = null;
 261                 }
 262             }
 263         }
 264
 265         internal StringToVoidSignal GetAccessibilityDescriptionSignal()
 266         {
 267             var handle = GetControl();
 268             StringToVoidSignal ret = new StringToVoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityGetDescriptionSignal(handle), false);
 269             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 270             return ret;
 271         }
 272
 273         ///////////////////////////////////////////////////////////////////
 274         // ***************** AccessiblityGetNameSignal ***************** //
 275         ///////////////////////////////////////////////////////////////////
 276
 277         private delegate void GetNameHandlerType(IntPtr data);
 278         private GetNameHandlerType getNameCallback;
 279         private EventHandler<GetNameEventArgs> getNameHandler;
 280         private StringToVoidSignal getNameSignal;
 281
 282         private void OnGetAccessibilityNameEvent(IntPtr data)
 283         {
 284             if (data == IntPtr.Zero)
 285                 return;
 286
 287             var arg = new GetNameEventArgs();
 288             arg.Name = StringToVoidSignal.GetResult(data);
 289
 290             getNameHandler?.Invoke(this, arg);
 291
 292             StringToVoidSignal.SetResult(data, arg.Name);
 293         }
 294
 295         // This uses GetName signal from C++ API.
 296         [EditorBrowsable(EditorBrowsableState.Never)]
 297         public event EventHandler<GetNameEventArgs> AccessibilityNameRequested
 298         {
 299             add
 300             {
 301                 if (getNameHandler == null)
 302                 {
 303                     getNameCallback = OnGetAccessibilityNameEvent;
 304                     getNameSignal = this.GetAccessibilityNameSignal();
 305                     getNameSignal?.Connect(getNameCallback);
 306                 }
 307                 getNameHandler += value;
 308             }
 309             remove
 310             {
 311                 getNameHandler -= value;
 312                 if (getNameHandler == null && getNameCallback != null)
 313                 {
 314                     getNameSignal?.Disconnect(getNameCallback);
 315                     getNameSignal?.Dispose();
 316                     getNameSignal = null;
 317                 }
 318             }
 319         }
 320
 321         internal StringToVoidSignal GetAccessibilityNameSignal()
 322         {
 323             var handle = GetControl();
 324             StringToVoidSignal ret = new StringToVoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityGetNameSignal(handle), false);
 325             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 326             return ret;
 327         }
 328
 329         ///////////////////////////////////////////////////////////////////
 330         // **************** AccessibilityActivatedSignal **************** //
 331         ///////////////////////////////////////////////////////////////////
 332
 333         private delegate void VoidHandlerType();
 334         private VoidHandlerType activateCallback;
 335         private EventHandler activateHandler;
 336         internal VoidSignal ActivateSignal;
 337
 338         private void OnAccessibilityActivatedEvent()
 339         {
 340             activateHandler?.Invoke(this, null);
 341         }
 342
 343         [EditorBrowsable(EditorBrowsableState.Never)]
 344         public event EventHandler AccessibilityActivated
 345         {
 346             add
 347             {
 348                 if (activateHandler == null)
 349                 {
 350                     activateCallback = OnAccessibilityActivatedEvent;
 351                     ActivateSignal = this.AccessibilityActivatedSignal();
 352                     ActivateSignal?.Connect(activateCallback);
 353                 }
 354                 activateHandler += value;
 355             }
 356             remove
 357             {
 358                 activateHandler -= value;
 359                 if (activateHandler == null && activateCallback != null)
 360                 {
 361                     ActivateSignal?.Disconnect(activateCallback);
 362                     ActivateSignal?.Dispose();
 363                     ActivateSignal = null;
 364                 }
 365             }
 366         }
 367
 368         internal VoidSignal AccessibilityActivatedSignal()
 369         {
 370             var handle = GetControl();
 371             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityActivateSignal(handle), false);
 372             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 373             return ret;
 374         }
 375
 376         ///////////////////////////////////////////////////////////////////
 377         // ************ AccessibilityReadingSkippedSignal ************** //
 378         ///////////////////////////////////////////////////////////////////
 379
 380         private VoidHandlerType readingSkippedCallback;
 381         private EventHandler readingSkippedHandler;
 382         internal VoidSignal ReadingSkippedSignal;
 383
 384         private void OnAccessibilityReadingSkippedEvent()
 385         {
 386             readingSkippedHandler?.Invoke(this, null);
 387         }
 388
 389         [EditorBrowsable(EditorBrowsableState.Never)]
 390         public event EventHandler AccessibilityReadingSkipped
 391         {
 392             add
 393             {
 394                 if (readingSkippedHandler == null)
 395                 {
 396                     readingSkippedCallback = OnAccessibilityReadingSkippedEvent;
 397                     ReadingSkippedSignal = this.AccessibilityReadingSkippedSignal();
 398                     ReadingSkippedSignal?.Connect(readingSkippedCallback);
 399                 }
 400                 readingSkippedHandler += value;
 401             }
 402             remove
 403             {
 404                 readingSkippedHandler -= value;
 405                 if (readingSkippedHandler == null && readingSkippedCallback != null)
 406                 {
 407                     ReadingSkippedSignal?.Disconnect(readingSkippedCallback);
 408                     ReadingSkippedSignal?.Dispose();
 409                     ReadingSkippedSignal = null;
 410                 }
 411             }
 412         }
 413
 414         internal VoidSignal AccessibilityReadingSkippedSignal()
 415         {
 416             var handle = GetControl();
 417             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingSkippedSignal(handle), false);
 418             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 419             return ret;
 420         }
 421
 422         ///////////////////////////////////////////////////////////////////
 423         // ************* AccessibilityReadingPausedSignal ************** //
 424         ///////////////////////////////////////////////////////////////////
 425
 426         private VoidHandlerType readingPausedCallback;
 427         private EventHandler readingPausedHandler;
 428         internal VoidSignal ReadingPausedSignal;
 429
 430         private void OnAccessibilityReadingPausedEvent()
 431         {
 432             readingPausedHandler?.Invoke(this, null);
 433         }
 434
 435         [EditorBrowsable(EditorBrowsableState.Never)]
 436         public event EventHandler AccessibilityReadingPaused
 437         {
 438             add
 439             {
 440                 if (readingPausedHandler == null)
 441                 {
 442                     readingPausedCallback = OnAccessibilityReadingPausedEvent;
 443                     ReadingPausedSignal = this.AccessibilityReadingPausedSignal();
 444                     ReadingPausedSignal?.Connect(readingPausedCallback);
 445                 }
 446                 readingPausedHandler += value;
 447             }
 448             remove
 449             {
 450                 readingPausedHandler -= value;
 451                 if (readingPausedHandler == null && readingPausedCallback != null)
 452                 {
 453                     ReadingPausedSignal?.Disconnect(readingPausedCallback);
 454                     ReadingPausedSignal?.Dispose();
 455                     ReadingPausedSignal = null;
 456                 }
 457             }
 458         }
 459
 460         internal VoidSignal AccessibilityReadingPausedSignal()
 461         {
 462             var handle = GetControl();
 463             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingPausedSignal(handle), false);
 464             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 465             return ret;
 466         }
 467
 468         ///////////////////////////////////////////////////////////////////
 469         // ************* AccessibilityReadingResumedSignal ************* //
 470         ///////////////////////////////////////////////////////////////////
 471
 472         private VoidHandlerType readingResumedCallback;
 473         private EventHandler readingResumedHandler;
 474         internal VoidSignal ReadingResumedSignal;
 475
 476         private void OnAccessibilityReadingResumedEvent()
 477         {
 478             readingResumedHandler?.Invoke(this, null);
 479         }
 480
 481         [EditorBrowsable(EditorBrowsableState.Never)]
 482         public event EventHandler AccessibilityReadingResumed
 483         {
 484             add
 485             {
 486                 if (readingResumedHandler == null)
 487                 {
 488                     readingResumedCallback = OnAccessibilityReadingResumedEvent;
 489                     ReadingResumedSignal = this.AccessibilityReadingResumedSignal();
 490                     ReadingResumedSignal?.Connect(readingResumedCallback);
 491                 }
 492                 readingResumedHandler += value;
 493             }
 494             remove
 495             {
 496                 readingResumedHandler -= value;
 497                 if (readingResumedHandler == null && readingResumedCallback != null)
 498                 {
 499                     ReadingResumedSignal?.Disconnect(readingResumedCallback);
 500                     ReadingResumedSignal?.Dispose();
 501                     ReadingResumedSignal = null;
 502                 }
 503             }
 504         }
 505
 506         internal VoidSignal AccessibilityReadingResumedSignal()
 507         {
 508             var handle = GetControl();
 509             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingResumedSignal(handle), false);
 510             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 511             return ret;
 512         }
 513
 514         ///////////////////////////////////////////////////////////////////
 515         // ************ AccessibilityReadingCancelledSignal ************ //
 516         ///////////////////////////////////////////////////////////////////
 517
 518         private VoidHandlerType readingCancelledCallback;
 519         private EventHandler readingCancelledHandler;
 520         internal VoidSignal ReadingCancelledSignal;
 521
 522         private void OnAccessibilityReadingCancelledEvent()
 523         {
 524             readingCancelledHandler?.Invoke(this, null);
 525         }
 526
 527         [EditorBrowsable(EditorBrowsableState.Never)]
 528         public event EventHandler AccessibilityReadingCancelled
 529         {
 530             add
 531             {
 532                 if (readingCancelledHandler == null)
 533                 {
 534                     readingCancelledCallback = OnAccessibilityReadingCancelledEvent;
 535                     ReadingCancelledSignal = this.AccessibilityReadingCancelledSignal();
 536                     ReadingCancelledSignal?.Connect(readingCancelledCallback);
 537                 }
 538                 readingCancelledHandler += value;
 539             }
 540             remove
 541             {
 542                 readingCancelledHandler -= value;
 543                 if (readingCancelledHandler == null && readingCancelledCallback != null)
 544                 {
 545                     ReadingCancelledSignal?.Disconnect(readingCancelledCallback);
 546                     ReadingCancelledSignal?.Dispose();
 547                     ReadingCancelledSignal = null;
 548                 }
 549             }
 550         }
 551
 552         internal VoidSignal AccessibilityReadingCancelledSignal()
 553         {
 554             var handle = GetControl();
 555             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingCancelledSignal(handle), false);
 556             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 557             return ret;
 558         }
 559
 560         ///////////////////////////////////////////////////////////////////
 561         // ************* AccessibilityReadingStoppedSignal ************* //
 562         ///////////////////////////////////////////////////////////////////
 563
 564         private VoidHandlerType readingStoppedCallback;
 565         private EventHandler readingStoppedHandler;
 566         internal VoidSignal ReadingStoppedSignal;
 567
 568         private void OnAccessibilityReadingStoppedEvent()
 569         {
 570             readingStoppedHandler?.Invoke(this, null);
 571         }
 572
 573         [EditorBrowsable(EditorBrowsableState.Never)]
 574         public event EventHandler AccessibilityReadingStopped
 575         {
 576             add
 577             {
 578                 if (readingStoppedHandler == null)
 579                 {
 580                     readingStoppedCallback = OnAccessibilityReadingStoppedEvent;
 581                     ReadingStoppedSignal = this.AccessibilityReadingStoppedSignal();
 582                     ReadingStoppedSignal?.Connect(readingStoppedCallback);
 583                 }
 584                 readingStoppedHandler += value;
 585             }
 586             remove
 587             {
 588                 readingStoppedHandler -= value;
 589                 if (readingStoppedHandler == null && readingStoppedCallback != null)
 590                 {
 591                     ReadingStoppedSignal?.Disconnect(readingStoppedCallback);
 592                     ReadingStoppedSignal?.Dispose();
 593                     ReadingStoppedSignal = null;
 594                 }
 595             }
 596         }
 597
 598         internal VoidSignal AccessibilityReadingStoppedSignal()
 599         {
 600             var handle = GetControl();
 601             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingStoppedSignal(handle), false);
 602             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 603             return ret;
 604         }
 605     }
 606 }