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; internal set; }
 110     }
 111
 112     [EditorBrowsable(EditorBrowsableState.Never)]
 113     public class GetNameEventArgs : EventArgs
 114     {
 115         public string Description { get; internal 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.ConvertParam1(data);
 233
 234             getDescriptionHandler?.Invoke(this, arg);
 235         }
 236
 237         // This uses GetDescription signal from C++ API.
 238         [EditorBrowsable(EditorBrowsableState.Never)]
 239         public event EventHandler<GetDescriptionEventArgs> AccessibilityDescriptionRequested
 240         {
 241             add
 242             {
 243                 if (getDescriptionHandler == null)
 244                 {
 245                     getDescriptionCallback = OnGetAccessibilityDescriptionEvent;
 246                     getDescriptionSignal = this.GetAccessibilityDescriptionSignal();
 247                     getDescriptionSignal?.Connect(getDescriptionCallback);
 248                 }
 249                 getDescriptionHandler += value;
 250             }
 251             remove
 252             {
 253                 getDescriptionHandler -= value;
 254                 if (getDescriptionHandler == null && getDescriptionCallback != null)
 255                 {
 256                     getDescriptionSignal?.Disconnect(getDescriptionCallback);
 257                     getDescriptionSignal?.Dispose();
 258                     getDescriptionSignal = null;
 259                 }
 260             }
 261         }
 262
 263         internal StringToVoidSignal GetAccessibilityDescriptionSignal()
 264         {
 265             var handle = GetControl();
 266             StringToVoidSignal ret = new StringToVoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityGetDescriptionSignal(handle), false);
 267             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 268             return ret;
 269         }
 270
 271         ///////////////////////////////////////////////////////////////////
 272         // ***************** AccessiblityGetNameSignal ***************** //
 273         ///////////////////////////////////////////////////////////////////
 274
 275         private delegate void GetNameHandlerType(IntPtr data);
 276         private GetNameHandlerType getNameCallback;
 277         private EventHandler<GetNameEventArgs> getNameHandler;
 278         private StringToVoidSignal getNameSignal;
 279
 280         private void OnGetAccessibilityNameEvent(IntPtr data)
 281         {
 282             if (data == IntPtr.Zero)
 283                 return;
 284
 285             var arg = new GetNameEventArgs();
 286             arg.Description = StringToVoidSignal.ConvertParam1(data);
 287
 288             getNameHandler?.Invoke(this, arg);
 289         }
 290
 291         // This uses GetName signal from C++ API.
 292         [EditorBrowsable(EditorBrowsableState.Never)]
 293         public event EventHandler<GetNameEventArgs> AccessibilityNameRequested
 294         {
 295             add
 296             {
 297                 if (getNameHandler == null)
 298                 {
 299                     getNameCallback = OnGetAccessibilityNameEvent;
 300                     getNameSignal = this.GetAccessibilityNameSignal();
 301                     getNameSignal?.Connect(getNameCallback);
 302                 }
 303                 getNameHandler += value;
 304             }
 305             remove
 306             {
 307                 getNameHandler -= value;
 308                 if (getNameHandler == null && getNameCallback != null)
 309                 {
 310                     getNameSignal?.Disconnect(getNameCallback);
 311                     getNameSignal?.Dispose();
 312                     getNameSignal = null;
 313                 }
 314             }
 315         }
 316
 317         internal StringToVoidSignal GetAccessibilityNameSignal()
 318         {
 319             var handle = GetControl();
 320             StringToVoidSignal ret = new StringToVoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityGetNameSignal(handle), false);
 321             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 322             return ret;
 323         }
 324
 325         ///////////////////////////////////////////////////////////////////
 326         // **************** AccessibilityActivatedSignal **************** //
 327         ///////////////////////////////////////////////////////////////////
 328
 329         private delegate void VoidHandlerType();
 330         private VoidHandlerType activateCallback;
 331         private EventHandler activateHandler;
 332         internal VoidSignal ActivateSignal;
 333
 334         private void OnAccessibilityActivatedEvent()
 335         {
 336             activateHandler?.Invoke(this, null);
 337         }
 338
 339         [EditorBrowsable(EditorBrowsableState.Never)]
 340         public event EventHandler AccessibilityActivated
 341         {
 342             add
 343             {
 344                 if (activateHandler == null)
 345                 {
 346                     activateCallback = OnAccessibilityActivatedEvent;
 347                     ActivateSignal = this.AccessibilityActivatedSignal();
 348                     ActivateSignal?.Connect(activateCallback);
 349                 }
 350                 activateHandler += value;
 351             }
 352             remove
 353             {
 354                 activateHandler -= value;
 355                 if (activateHandler == null && activateCallback != null)
 356                 {
 357                     ActivateSignal?.Disconnect(activateCallback);
 358                     ActivateSignal?.Dispose();
 359                     ActivateSignal = null;
 360                 }
 361             }
 362         }
 363
 364         internal VoidSignal AccessibilityActivatedSignal()
 365         {
 366             var handle = GetControl();
 367             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityActivateSignal(handle), false);
 368             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 369             return ret;
 370         }
 371
 372         ///////////////////////////////////////////////////////////////////
 373         // ************ AccessibilityReadingSkippedSignal ************** //
 374         ///////////////////////////////////////////////////////////////////
 375
 376         private VoidHandlerType readingSkippedCallback;
 377         private EventHandler readingSkippedHandler;
 378         internal VoidSignal ReadingSkippedSignal;
 379
 380         private void OnAccessibilityReadingSkippedEvent()
 381         {
 382             readingSkippedHandler?.Invoke(this, null);
 383         }
 384
 385         [EditorBrowsable(EditorBrowsableState.Never)]
 386         public event EventHandler AccessibilityReadingSkipped
 387         {
 388             add
 389             {
 390                 if (readingSkippedHandler == null)
 391                 {
 392                     readingSkippedCallback = OnAccessibilityReadingSkippedEvent;
 393                     ReadingSkippedSignal = this.AccessibilityReadingSkippedSignal();
 394                     ReadingSkippedSignal?.Connect(readingSkippedCallback);
 395                 }
 396                 readingSkippedHandler += value;
 397             }
 398             remove
 399             {
 400                 readingSkippedHandler -= value;
 401                 if (readingSkippedHandler == null && readingSkippedCallback != null)
 402                 {
 403                     ReadingSkippedSignal?.Disconnect(readingSkippedCallback);
 404                     ReadingSkippedSignal?.Dispose();
 405                     ReadingSkippedSignal = null;
 406                 }
 407             }
 408         }
 409
 410         internal VoidSignal AccessibilityReadingSkippedSignal()
 411         {
 412             var handle = GetControl();
 413             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingSkippedSignal(handle), false);
 414             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 415             return ret;
 416         }
 417
 418         ///////////////////////////////////////////////////////////////////
 419         // ************* AccessibilityReadingPausedSignal ************** //
 420         ///////////////////////////////////////////////////////////////////
 421
 422         private VoidHandlerType readingPausedCallback;
 423         private EventHandler readingPausedHandler;
 424         internal VoidSignal ReadingPausedSignal;
 425
 426         private void OnAccessibilityReadingPausedEvent()
 427         {
 428             readingPausedHandler?.Invoke(this, null);
 429         }
 430
 431         [EditorBrowsable(EditorBrowsableState.Never)]
 432         public event EventHandler AccessibilityReadingPaused
 433         {
 434             add
 435             {
 436                 if (readingPausedHandler == null)
 437                 {
 438                     readingPausedCallback = OnAccessibilityReadingPausedEvent;
 439                     ReadingPausedSignal = this.AccessibilityReadingPausedSignal();
 440                     ReadingPausedSignal?.Connect(readingPausedCallback);
 441                 }
 442                 readingPausedHandler += value;
 443             }
 444             remove
 445             {
 446                 readingPausedHandler -= value;
 447                 if (readingPausedHandler == null && readingPausedCallback != null)
 448                 {
 449                     ReadingPausedSignal?.Disconnect(readingPausedCallback);
 450                     ReadingPausedSignal?.Dispose();
 451                     ReadingPausedSignal = null;
 452                 }
 453             }
 454         }
 455
 456         internal VoidSignal AccessibilityReadingPausedSignal()
 457         {
 458             var handle = GetControl();
 459             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingPausedSignal(handle), false);
 460             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 461             return ret;
 462         }
 463
 464         ///////////////////////////////////////////////////////////////////
 465         // ************* AccessibilityReadingResumedSignal ************* //
 466         ///////////////////////////////////////////////////////////////////
 467
 468         private VoidHandlerType readingResumedCallback;
 469         private EventHandler readingResumedHandler;
 470         internal VoidSignal ReadingResumedSignal;
 471
 472         private void OnAccessibilityReadingResumedEvent()
 473         {
 474             readingResumedHandler?.Invoke(this, null);
 475         }
 476
 477         [EditorBrowsable(EditorBrowsableState.Never)]
 478         public event EventHandler AccessibilityReadingResumed
 479         {
 480             add
 481             {
 482                 if (readingResumedHandler == null)
 483                 {
 484                     readingResumedCallback = OnAccessibilityReadingResumedEvent;
 485                     ReadingResumedSignal = this.AccessibilityReadingResumedSignal();
 486                     ReadingResumedSignal?.Connect(readingResumedCallback);
 487                 }
 488                 readingResumedHandler += value;
 489             }
 490             remove
 491             {
 492                 readingResumedHandler -= value;
 493                 if (readingResumedHandler == null && readingResumedCallback != null)
 494                 {
 495                     ReadingResumedSignal?.Disconnect(readingResumedCallback);
 496                     ReadingResumedSignal?.Dispose();
 497                     ReadingResumedSignal = null;
 498                 }
 499             }
 500         }
 501
 502         internal VoidSignal AccessibilityReadingResumedSignal()
 503         {
 504             var handle = GetControl();
 505             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingResumedSignal(handle), false);
 506             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 507             return ret;
 508         }
 509
 510         ///////////////////////////////////////////////////////////////////
 511         // ************ AccessibilityReadingCancelledSignal ************ //
 512         ///////////////////////////////////////////////////////////////////
 513
 514         private VoidHandlerType readingCancelledCallback;
 515         private EventHandler readingCancelledHandler;
 516         internal VoidSignal ReadingCancelledSignal;
 517
 518         private void OnAccessibilityReadingCancelledEvent()
 519         {
 520             readingCancelledHandler?.Invoke(this, null);
 521         }
 522
 523         [EditorBrowsable(EditorBrowsableState.Never)]
 524         public event EventHandler AccessibilityReadingCancelled
 525         {
 526             add
 527             {
 528                 if (readingCancelledHandler == null)
 529                 {
 530                     readingCancelledCallback = OnAccessibilityReadingCancelledEvent;
 531                     ReadingCancelledSignal = this.AccessibilityReadingCancelledSignal();
 532                     ReadingCancelledSignal?.Connect(readingCancelledCallback);
 533                 }
 534                 readingCancelledHandler += value;
 535             }
 536             remove
 537             {
 538                 readingCancelledHandler -= value;
 539                 if (readingCancelledHandler == null && readingCancelledCallback != null)
 540                 {
 541                     ReadingCancelledSignal?.Disconnect(readingCancelledCallback);
 542                     ReadingCancelledSignal?.Dispose();
 543                     ReadingCancelledSignal = null;
 544                 }
 545             }
 546         }
 547
 548         internal VoidSignal AccessibilityReadingCancelledSignal()
 549         {
 550             var handle = GetControl();
 551             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingCancelledSignal(handle), false);
 552             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 553             return ret;
 554         }
 555
 556         ///////////////////////////////////////////////////////////////////
 557         // ************* AccessibilityReadingStoppedSignal ************* //
 558         ///////////////////////////////////////////////////////////////////
 559
 560         private VoidHandlerType readingStoppedCallback;
 561         private EventHandler readingStoppedHandler;
 562         internal VoidSignal ReadingStoppedSignal;
 563
 564         private void OnAccessibilityReadingStoppedEvent()
 565         {
 566             readingStoppedHandler?.Invoke(this, null);
 567         }
 568
 569         [EditorBrowsable(EditorBrowsableState.Never)]
 570         public event EventHandler AccessibilityReadingStopped
 571         {
 572             add
 573             {
 574                 if (readingStoppedHandler == null)
 575                 {
 576                     readingStoppedCallback = OnAccessibilityReadingStoppedEvent;
 577                     ReadingStoppedSignal = this.AccessibilityReadingStoppedSignal();
 578                     ReadingStoppedSignal?.Connect(readingStoppedCallback);
 579                 }
 580                 readingStoppedHandler += value;
 581             }
 582             remove
 583             {
 584                 readingStoppedHandler -= value;
 585                 if (readingStoppedHandler == null && readingStoppedCallback != null)
 586                 {
 587                     ReadingStoppedSignal?.Disconnect(readingStoppedCallback);
 588                     ReadingStoppedSignal?.Dispose();
 589                     ReadingStoppedSignal = null;
 590                 }
 591             }
 592         }
 593
 594         internal VoidSignal AccessibilityReadingStoppedSignal()
 595         {
 596             var handle = GetControl();
 597             VoidSignal ret = new VoidSignal(Interop.ControlDevel.DaliToolkitDevelControlAccessibilityReadingStoppedSignal(handle), false);
 598             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 599             return ret;
 600         }
 601     }
 602 }