src/Tizen.NUI/src/public/Accessibility/AccessibilityManagerEvent.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
  22 namespace Tizen.NUI.Accessibility
  23 {
  24     public partial class AccessibilityManager
  25     {
  26         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  27         private delegate bool StatusChangedEventCallbackDelegate(IntPtr accessibilityManager);
  28         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerStatusChangedEventHandler;
  29         private StatusChangedEventCallbackDelegate accessibilityManagerStatusChangedEventCallbackDelegate;
  30
  31         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  32         private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
  33         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionNextEventHandler;
  34         private ActionNextEventCallbackDelegate accessibilityManagerActionNextEventCallbackDelegate;
  35
  36         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  37         private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
  38         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionPreviousEventHandler;
  39         private ActionPreviousEventCallbackDelegate accessibilityManagerActionPreviousEventCallbackDelegate;
  40
  41         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  42         private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
  43         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionActivateEventHandler;
  44         private ActionActivateEventCallbackDelegate accessibilityManagerActionActivateEventCallbackDelegate;
  45
  46         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  47         private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
  48         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionReadEventHandler;
  49         private ActionReadEventCallbackDelegate accessibilityManagerActionReadEventCallbackDelegate;
  50
  51         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  52         private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
  53         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionOverEventHandler;
  54         private ActionOverEventCallbackDelegate accessibilityManagerActionOverEventCallbackDelegate;
  55
  56         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  57         private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
  58         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionReadNextEventHandler;
  59         private ActionReadNextEventCallbackDelegate accessibilityManagerActionReadNextEventCallbackDelegate;
  60
  61         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  62         private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
  63         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionReadPreviousEventHandler;
  64         private ActionReadPreviousEventCallbackDelegate accessibilityManagerActionReadPreviousEventCallbackDelegate;
  65
  66         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  67         private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
  68         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionUpEventHandler;
  69         private ActionUpEventCallbackDelegate accessibilityManagerActionUpEventCallbackDelegate;
  70
  71         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  72         private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
  73         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionDownEventHandler;
  74         private ActionDownEventCallbackDelegate accessibilityManagerActionDownEventCallbackDelegate;
  75
  76         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  77         private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
  78         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionClearFocusEventHandler;
  79         private ActionClearFocusEventCallbackDelegate accessibilityManagerActionClearFocusEventCallbackDelegate;
  80
  81         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  82         private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
  83         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionBackEventHandler;
  84         private ActionBackEventCallbackDelegate accessibilityManagerActionBackEventCallbackDelegate;
  85
  86         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  87         private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
  88         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionScrollUpEventHandler;
  89         private ActionScrollUpEventCallbackDelegate accessibilityManagerActionScrollUpEventCallbackDelegate;
  90
  91         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  92         private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
  93         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionScrollDownEventHandler;
  94         private ActionScrollDownEventCallbackDelegate accessibilityManagerActionScrollDownEventCallbackDelegate;
  95
  96         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  97         private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
  98         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionPageLeftEventHandler;
  99         private ActionPageLeftEventCallbackDelegate accessibilityManagerActionPageLeftEventCallbackDelegate;
 100
 101         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 102         private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
 103         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionPageRightEventHandler;
 104         private ActionPageRightEventCallbackDelegate accessibilityManagerActionPageRightEventCallbackDelegate;
 105
 106         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 107         private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
 108         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionPageUpEventHandler;
 109         private ActionPageUpEventCallbackDelegate accessibilityManagerActionPageUpEventCallbackDelegate;
 110
 111         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 112         private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
 113         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionPageDownEventHandler;
 114         private ActionPageDownEventCallbackDelegate accessibilityManagerActionPageDownEventCallbackDelegate;
 115
 116         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 117         private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
 118         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionMoveToFirstEventHandler;
 119         private ActionMoveToFirstEventCallbackDelegate accessibilityManagerActionMoveToFirstEventCallbackDelegate;
 120
 121         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 122         private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
 123         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionMoveToLastEventHandler;
 124         private ActionMoveToLastEventCallbackDelegate accessibilityManagerActionMoveToLastEventCallbackDelegate;
 125
 126         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 127         private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
 128         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionReadFromTopEventHandler;
 129         private ActionReadFromTopEventCallbackDelegate accessibilityManagerActionReadFromTopEventCallbackDelegate;
 130
 131         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 132         private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
 133         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionReadFromNextEventHandler;
 134         private ActionReadFromNextEventCallbackDelegate accessibilityManagerActionReadFromNextEventCallbackDelegate;
 135
 136         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 137         private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
 138         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionZoomEventHandler;
 139         private ActionZoomEventCallbackDelegate accessibilityManagerActionZoomEventCallbackDelegate;
 140
 141         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 142         private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
 143         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionReadPauseResumeEventHandler;
 144         private ActionReadPauseResumeEventCallbackDelegate accessibilityManagerActionReadPauseResumeEventCallbackDelegate;
 145
 146         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 147         private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
 148         private ReturnTypeEventHandler<object, EventArgs, bool> accessibilityManagerActionStartStopEventHandler;
 149         private ActionStartStopEventCallbackDelegate accessibilityManagerActionStartStopEventCallbackDelegate;
 150
 151         /*
 152             // To be replaced by a new event that takes Touch
 153             [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 154             private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
 155             private EventHandlerWithReturnType<object,ActionScrollEventArgs,bool> _accessibilityManagerActionScrollEventHandler;
 156             private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;
 157         */
 158
 159         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 160         private delegate void FocusChangedEventCallbackDelegate(IntPtr view1, IntPtr view2);
 161         private EventHandler<FocusChangedEventArgs> accessibilityManagerFocusChangedEventHandler;
 162         private FocusChangedEventCallbackDelegate accessibilityManagerFocusChangedEventCallbackDelegate;
 163
 164         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 165         private delegate void FocusedViewActivatedEventCallbackDelegate(IntPtr view);
 166         private EventHandler<FocusedViewActivatedEventArgs> accessibilityManagerFocusedViewActivatedEventHandler;
 167         private FocusedViewActivatedEventCallbackDelegate accessibilityManagerFocusedViewActivatedEventCallbackDelegate;
 168
 169         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 170         private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction);
 171         private EventHandler<FocusOvershotEventArgs> accessibilityManagerFocusOvershotEventHandler;
 172         private FocusOvershotEventCallbackDelegate accessibilityManagerFocusOvershotEventCallbackDelegate;
 173
 174         // Accessibility action signals
 175
 176         /// <summary>
 177         /// This is emitted when accessibility(screen-reader) feature turned on or off.
 178         /// </summary>
 179         /// <returns> The signal to connect to </returns>
 180         /// <since_tizen> 6 </since_tizen>
 181         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 182         [EditorBrowsable(EditorBrowsableState.Never)]
 183         public event ReturnTypeEventHandler<object, EventArgs, bool> StatusChanged
 184         {
 185             add
 186             {
 187                 // Restricted to only one listener
 188                 if (accessibilityManagerStatusChangedEventHandler == null)
 189                 {
 190                     accessibilityManagerStatusChangedEventCallbackDelegate = new StatusChangedEventCallbackDelegate(OnStatusChanged);
 191                     this.StatusChangedSignal().Connect(accessibilityManagerStatusChangedEventCallbackDelegate);
 192                 }
 193
 194                 accessibilityManagerStatusChangedEventHandler += value;
 195             }
 196
 197             remove
 198             {
 199                 accessibilityManagerStatusChangedEventHandler -= value;
 200
 201                 if (accessibilityManagerStatusChangedEventHandler == null && StatusChangedSignal().Empty() == false)
 202                 {
 203                     this.StatusChangedSignal().Disconnect(accessibilityManagerStatusChangedEventCallbackDelegate);
 204                 }
 205
 206             }
 207         }
 208
 209         /// <summary>
 210         /// This is emitted when accessibility action is received to move focus to the next focusable view (by one finger flick down).
 211         /// </summary>
 212         /// <returns> The signal to connect to </returns>
 213         /// <since_tizen> 6 </since_tizen>
 214         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 215         [EditorBrowsable(EditorBrowsableState.Never)]
 216         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionNext
 217         {
 218             add
 219             {
 220                 // Restricted to only one listener
 221                 if (accessibilityManagerActionNextEventHandler == null)
 222                 {
 223                     accessibilityManagerActionNextEventCallbackDelegate = new ActionNextEventCallbackDelegate(OnActionNext);
 224                     this.ActionNextSignal().Connect(accessibilityManagerActionNextEventCallbackDelegate);
 225                 }
 226
 227                 accessibilityManagerActionNextEventHandler += value;
 228             }
 229
 230             remove
 231             {
 232                 accessibilityManagerActionNextEventHandler -= value;
 233
 234                 if (accessibilityManagerActionNextEventHandler == null && ActionNextSignal().Empty() == false)
 235                 {
 236                     this.ActionNextSignal().Disconnect(accessibilityManagerActionNextEventCallbackDelegate);
 237                 }
 238             }
 239         }
 240
 241         /// <summary>
 242         /// This is emitted when accessibility action is received to move focus to the previous focusable view (by one finger flick up).
 243         /// </summary>
 244         /// <returns> The signal to connect to </returns>
 245         /// <since_tizen> 6 </since_tizen>
 246         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 247         [EditorBrowsable(EditorBrowsableState.Never)]
 248         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionPrevious
 249         {
 250             add
 251             {
 252                 // Restricted to only one listener
 253                 if (accessibilityManagerActionPreviousEventHandler == null)
 254                 {
 255                     accessibilityManagerActionPreviousEventCallbackDelegate = new ActionPreviousEventCallbackDelegate(OnActionPrevious);
 256                     this.ActionPreviousSignal().Connect(accessibilityManagerActionPreviousEventCallbackDelegate);
 257                 }
 258
 259                 accessibilityManagerActionPreviousEventHandler += value;
 260             }
 261
 262             remove
 263             {
 264                 accessibilityManagerActionPreviousEventHandler -= value;
 265
 266                 if (accessibilityManagerActionPreviousEventHandler == null && ActionPreviousSignal().Empty() == false)
 267                 {
 268                     this.ActionPreviousSignal().Disconnect(accessibilityManagerActionPreviousEventCallbackDelegate);
 269                 }
 270             }
 271         }
 272
 273         /// <summary>
 274         /// This is emitted when accessibility action is received to activate the current focused view (by one finger double tap).
 275         /// </summary>
 276         /// <returns> The signal to connect to </returns>
 277         /// <since_tizen> 6 </since_tizen>
 278         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 279         [EditorBrowsable(EditorBrowsableState.Never)]
 280         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionActivate
 281         {
 282             add
 283             {
 284                 // Restricted to only one listener
 285                 if (accessibilityManagerActionActivateEventHandler == null)
 286                 {
 287                     accessibilityManagerActionActivateEventCallbackDelegate = new ActionActivateEventCallbackDelegate(OnActionActivate);
 288                     this.ActionActivateSignal().Connect(accessibilityManagerActionActivateEventCallbackDelegate);
 289                 }
 290
 291                 accessibilityManagerActionActivateEventHandler += value;
 292             }
 293
 294             remove
 295             {
 296                 accessibilityManagerActionActivateEventHandler -= value;
 297
 298                 if (accessibilityManagerActionActivateEventHandler == null && ActionActivateSignal().Empty() == false)
 299                 {
 300                     this.ActionActivateSignal().Disconnect(accessibilityManagerActionActivateEventCallbackDelegate);
 301                 }
 302             }
 303         }
 304
 305         /// <summary>
 306         /// This is emitted when accessibility action is received to focus and read the view (by one finger tap).
 307         /// </summary>
 308         /// <returns> The signal to connect to </returns>
 309         /// <since_tizen> 6 </since_tizen>
 310         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 311         [EditorBrowsable(EditorBrowsableState.Never)]
 312         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionRead
 313         {
 314             add
 315             {
 316                 // Restricted to only one listener
 317                 if (accessibilityManagerActionReadEventHandler == null)
 318                 {
 319                     accessibilityManagerActionReadEventCallbackDelegate = new ActionReadEventCallbackDelegate(OnActionRead);
 320                     this.ActionReadSignal().Connect(accessibilityManagerActionReadEventCallbackDelegate);
 321                 }
 322
 323                 accessibilityManagerActionReadEventHandler += value;
 324             }
 325
 326             remove
 327             {
 328                 accessibilityManagerActionReadEventHandler -= value;
 329
 330                 if (accessibilityManagerActionReadEventHandler == null && ActionReadSignal().Empty() == false)
 331                 {
 332                     this.ActionReadSignal().Disconnect(accessibilityManagerActionReadEventCallbackDelegate);
 333                 }
 334             }
 335         }
 336
 337         /// <summary>
 338         /// This is emitted when accessibility action is received to focus and read the view  (by one finger move).
 339         /// </summary>
 340         /// <returns> The signal to connect to </returns>
 341         /// <since_tizen> 6 </since_tizen>
 342         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 343         [EditorBrowsable(EditorBrowsableState.Never)]
 344         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionOver
 345         {
 346             add
 347             {
 348                 // Restricted to only one listener
 349                 if (accessibilityManagerActionOverEventHandler == null)
 350                 {
 351                     accessibilityManagerActionOverEventCallbackDelegate = new ActionOverEventCallbackDelegate(OnActionOver);
 352                     this.ActionOverSignal().Connect(accessibilityManagerActionOverEventCallbackDelegate);
 353                 }
 354
 355                 accessibilityManagerActionOverEventHandler += value;
 356             }
 357
 358             remove
 359             {
 360                 accessibilityManagerActionOverEventHandler -= value;
 361
 362                 if (accessibilityManagerActionOverEventHandler == null && ActionOverSignal().Empty() == false)
 363                 {
 364                     this.ActionOverSignal().Disconnect(accessibilityManagerActionOverEventCallbackDelegate);
 365                 }
 366
 367             }
 368         }
 369
 370         /// <summary>
 371         /// This is emitted when accessibility action is received to move focus to the next focusable view (by one finger flick right).
 372         /// </summary>
 373         /// <returns> The signal to connect to </returns>
 374         /// <since_tizen> 6 </since_tizen>
 375         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 376         [EditorBrowsable(EditorBrowsableState.Never)]
 377         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionReadNext
 378         {
 379             add
 380             {
 381                 // Restricted to only one listener
 382                 if (accessibilityManagerActionReadNextEventHandler == null)
 383                 {
 384                     accessibilityManagerActionReadNextEventCallbackDelegate = new ActionReadNextEventCallbackDelegate(OnActionReadNext);
 385                     this.ActionReadNextSignal().Connect(accessibilityManagerActionReadNextEventCallbackDelegate);
 386                 }
 387
 388                 accessibilityManagerActionReadNextEventHandler += value;
 389             }
 390
 391             remove
 392             {
 393                 accessibilityManagerActionReadNextEventHandler -= value;
 394
 395                 if (accessibilityManagerActionReadNextEventHandler == null && ActionReadNextSignal().Empty() == false)
 396                 {
 397                     this.ActionReadNextSignal().Disconnect(accessibilityManagerActionReadNextEventCallbackDelegate);
 398                 }
 399             }
 400         }
 401
 402         /// <summary>
 403         /// This is emitted when accessibility action is received to move focus to the previous focusable view (by one finger flick left).
 404         /// </summary>
 405         /// <returns> The signal to connect to </returns>
 406         /// <since_tizen> 6 </since_tizen>
 407         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 408         [EditorBrowsable(EditorBrowsableState.Never)]
 409         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionReadPrevious
 410         {
 411             add
 412             {
 413                 // Restricted to only one listener
 414                 if (accessibilityManagerActionReadPreviousEventHandler == null)
 415                 {
 416                     accessibilityManagerActionReadPreviousEventCallbackDelegate = new ActionReadPreviousEventCallbackDelegate(OnActionReadPrevious);
 417                     this.ActionReadPreviousSignal().Connect(accessibilityManagerActionReadPreviousEventCallbackDelegate);
 418                 }
 419
 420                 accessibilityManagerActionReadPreviousEventHandler += value;
 421             }
 422
 423             remove
 424             {
 425                 accessibilityManagerActionReadPreviousEventHandler -= value;
 426
 427                 if (accessibilityManagerActionReadPreviousEventHandler == null && ActionReadPreviousSignal().Empty() == false)
 428                 {
 429                     this.ActionReadPreviousSignal().Disconnect(accessibilityManagerActionReadPreviousEventCallbackDelegate);
 430                 }
 431             }
 432         }
 433
 434         /// <summary>
 435         /// This is emitted when accessibility action is received to change the value when the current focused view is a slider
 436         /// (by double finger down and move up and right).
 437         /// </summary>
 438         /// <returns> The signal to connect to </returns>
 439         /// <since_tizen> 6 </since_tizen>
 440         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 441         [EditorBrowsable(EditorBrowsableState.Never)]
 442         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionUp
 443         {
 444             add
 445             {
 446                 // Restricted to only one listener
 447                 if (accessibilityManagerActionUpEventHandler == null)
 448                 {
 449                     accessibilityManagerActionUpEventCallbackDelegate = new ActionUpEventCallbackDelegate(OnActionUp);
 450                     this.ActionUpSignal().Connect(accessibilityManagerActionUpEventCallbackDelegate);
 451                 }
 452
 453                 accessibilityManagerActionUpEventHandler += value;
 454             }
 455
 456             remove
 457             {
 458                 accessibilityManagerActionUpEventHandler -= value;
 459
 460                 if (accessibilityManagerActionUpEventHandler == null && ActionUpSignal().Empty() == false)
 461                 {
 462                     this.ActionUpSignal().Disconnect(accessibilityManagerActionUpEventCallbackDelegate);
 463                 }
 464             }
 465         }
 466
 467         /// <summary>
 468         /// This is emitted when accessibility action is received to change the value when the current focused view is a slider
 469         /// (by double finger down and move down and left).
 470         /// </summary>
 471         /// <returns> The signal to connect to </returns>
 472         /// <since_tizen> 6 </since_tizen>
 473         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 474         [EditorBrowsable(EditorBrowsableState.Never)]
 475         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionDown
 476         {
 477             add
 478             {
 479                 // Restricted to only one listener
 480                 if (accessibilityManagerActionDownEventHandler == null)
 481                 {
 482                     accessibilityManagerActionDownEventCallbackDelegate = new ActionDownEventCallbackDelegate(OnActionDown);
 483                     this.ActionDownSignal().Connect(accessibilityManagerActionDownEventCallbackDelegate);
 484                 }
 485
 486                 accessibilityManagerActionDownEventHandler += value;
 487             }
 488
 489             remove
 490             {
 491                 accessibilityManagerActionDownEventHandler -= value;
 492
 493                 if (accessibilityManagerActionDownEventHandler == null && ActionDownSignal().Empty() == false)
 494                 {
 495                     this.ActionDownSignal().Disconnect(accessibilityManagerActionDownEventCallbackDelegate);
 496                 }
 497             }
 498         }
 499
 500         /// <summary>
 501         /// This is emitted when accessibility action is received to clear the focus from the current focused view
 502         /// if any, so that no view is focused in the focus chain.
 503         /// </summary>
 504         /// <returns> The signal to connect to </returns>
 505         /// <since_tizen> 6 </since_tizen>
 506         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 507         [EditorBrowsable(EditorBrowsableState.Never)]
 508         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionClearFocus
 509         {
 510             add
 511             {
 512                 // Restricted to only one listener
 513                 if (accessibilityManagerActionClearFocusEventHandler == null)
 514                 {
 515                     accessibilityManagerActionClearFocusEventCallbackDelegate = new ActionClearFocusEventCallbackDelegate(OnActionClearFocus);
 516                     this.ActionClearFocusSignal().Connect(accessibilityManagerActionClearFocusEventCallbackDelegate);
 517                 }
 518
 519                 accessibilityManagerActionClearFocusEventHandler += value;
 520             }
 521
 522             remove
 523             {
 524                 accessibilityManagerActionClearFocusEventHandler -= value;
 525
 526                 if (accessibilityManagerActionClearFocusEventHandler == null && ActionClearFocusSignal().Empty() == false)
 527                 {
 528                     this.ActionClearFocusSignal().Disconnect(accessibilityManagerActionClearFocusEventCallbackDelegate);
 529                 }
 530             }
 531         }
 532
 533         /// <summary>
 534         /// This is emitted when accessibility action is received to navigate back (by two fingers circle draw).
 535         /// </summary>
 536         /// <returns> The signal to connect to </returns>
 537         /// <since_tizen> 6 </since_tizen>
 538         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 539         [EditorBrowsable(EditorBrowsableState.Never)]
 540         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionBack
 541         {
 542             add
 543             {
 544                 // Restricted to only one listener
 545                 if (accessibilityManagerActionBackEventHandler == null)
 546                 {
 547                     accessibilityManagerActionBackEventCallbackDelegate = new ActionBackEventCallbackDelegate(OnActionBack);
 548                     this.ActionBackSignal().Connect(accessibilityManagerActionBackEventCallbackDelegate);
 549                 }
 550
 551                 accessibilityManagerActionBackEventHandler += value;
 552             }
 553
 554             remove
 555             {
 556                 accessibilityManagerActionBackEventHandler -= value;
 557
 558                 if (accessibilityManagerActionBackEventHandler == null && ActionBackSignal().Empty() == false)
 559                 {
 560                     this.ActionBackSignal().Disconnect(accessibilityManagerActionBackEventCallbackDelegate);
 561                 }
 562             }
 563         }
 564
 565         /// <summary>
 566         /// This is emitted when accessibility action is received to scroll up the list (by two finger swipe up).
 567         /// </summary>
 568         /// <returns> The signal to connect to </returns>
 569         /// <since_tizen> 6 </since_tizen>
 570         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 571         [EditorBrowsable(EditorBrowsableState.Never)]
 572         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionScrollUp
 573         {
 574             add
 575             {
 576                 // Restricted to only one listener
 577                 if (accessibilityManagerActionScrollUpEventHandler == null)
 578                 {
 579                     accessibilityManagerActionScrollUpEventCallbackDelegate = new ActionScrollUpEventCallbackDelegate(OnActionScrollUp);
 580                     this.ActionScrollUpSignal().Connect(accessibilityManagerActionScrollUpEventCallbackDelegate);
 581                 }
 582
 583                 accessibilityManagerActionScrollUpEventHandler += value;
 584             }
 585
 586             remove
 587             {
 588                 accessibilityManagerActionScrollUpEventHandler -= value;
 589
 590                 if (accessibilityManagerActionScrollUpEventHandler == null && ActionScrollUpSignal().Empty() == false)
 591                 {
 592                     this.ActionScrollUpSignal().Disconnect(accessibilityManagerActionScrollUpEventCallbackDelegate);
 593                 }
 594             }
 595         }
 596
 597         /// <summary>
 598         /// This is emitted when accessibility action is received to scroll down the list (by two finger swipe down).
 599         /// </summary>
 600         /// <returns> The signal to connect to </returns>
 601         /// <since_tizen> 6 </since_tizen>
 602         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 603         [EditorBrowsable(EditorBrowsableState.Never)]
 604         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionScrollDown
 605         {
 606             add
 607             {
 608                 // Restricted to only one listener
 609                 if (accessibilityManagerActionScrollDownEventHandler == null)
 610                 {
 611                     accessibilityManagerActionScrollDownEventCallbackDelegate = new ActionScrollDownEventCallbackDelegate(OnActionScrollDown);
 612                     this.ActionScrollDownSignal().Connect(accessibilityManagerActionScrollDownEventCallbackDelegate);
 613                 }
 614
 615                 accessibilityManagerActionScrollDownEventHandler += value;
 616             }
 617
 618             remove
 619             {
 620                 accessibilityManagerActionScrollDownEventHandler -= value;
 621
 622                 if (accessibilityManagerActionScrollDownEventHandler == null && ActionScrollDownSignal().Empty() == false)
 623                 {
 624                     this.ActionScrollDownSignal().Disconnect(accessibilityManagerActionScrollDownEventCallbackDelegate);
 625                 }
 626             }
 627         }
 628
 629         /// <summary>
 630         /// This is emitted when accessibility action is received to scroll left to the previous page (by two finger swipe left).
 631         /// </summary>
 632         /// <returns> The signal to connect to </returns>
 633         /// <since_tizen> 6 </since_tizen>
 634         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 635         [EditorBrowsable(EditorBrowsableState.Never)]
 636         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionPageLeft
 637         {
 638             add
 639             {
 640                 // Restricted to only one listener
 641                 if (accessibilityManagerActionPageLeftEventHandler == null)
 642                 {
 643                     accessibilityManagerActionPageLeftEventCallbackDelegate = new ActionPageLeftEventCallbackDelegate(OnActionPageLeft);
 644                     this.ActionPageLeftSignal().Connect(accessibilityManagerActionPageLeftEventCallbackDelegate);
 645                 }
 646
 647                 accessibilityManagerActionPageLeftEventHandler += value;
 648             }
 649
 650             remove
 651             {
 652                 accessibilityManagerActionPageLeftEventHandler -= value;
 653
 654                 if (accessibilityManagerActionPageLeftEventHandler == null && ActionPageLeftSignal().Empty() == false)
 655                 {
 656                     this.ActionPageLeftSignal().Disconnect(accessibilityManagerActionPageLeftEventCallbackDelegate);
 657                 }
 658             }
 659         }
 660
 661         /// <summary>
 662         /// This is emitted when accessibility action is received to scroll right to the next page (by two finger swipe right).
 663         /// </summary>
 664         /// <returns> The signal to connect to </returns>
 665         /// <since_tizen> 6 </since_tizen>
 666         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 667         [EditorBrowsable(EditorBrowsableState.Never)]
 668         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionPageRight
 669         {
 670             add
 671             {
 672                 // Restricted to only one listener
 673                 if (accessibilityManagerActionPageRightEventHandler == null)
 674                 {
 675                     accessibilityManagerActionPageRightEventCallbackDelegate = new ActionPageRightEventCallbackDelegate(OnActionPageRight);
 676                     this.ActionPageRightSignal().Connect(accessibilityManagerActionPageRightEventCallbackDelegate);
 677                 }
 678
 679                 accessibilityManagerActionPageRightEventHandler += value;
 680             }
 681
 682             remove
 683             {
 684                 accessibilityManagerActionPageRightEventHandler -= value;
 685
 686                 if (accessibilityManagerActionPageRightEventHandler == null && ActionPageRightSignal().Empty() == false)
 687                 {
 688                     this.ActionPageRightSignal().Disconnect(accessibilityManagerActionPageRightEventCallbackDelegate);
 689                 }
 690             }
 691         }
 692
 693         /// <summary>
 694         /// This is emitted when accessibility action is received to scroll up to the previous page (by one finger swipe left and right).
 695         /// </summary>
 696         /// <returns> The signal to connect to </returns>
 697         /// <since_tizen> 6 </since_tizen>
 698         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 699         [EditorBrowsable(EditorBrowsableState.Never)]
 700         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionPageUp
 701         {
 702             add
 703             {
 704                 // Restricted to only one listener
 705                 if (accessibilityManagerActionPageUpEventHandler == null)
 706                 {
 707                     accessibilityManagerActionPageUpEventCallbackDelegate = new ActionPageUpEventCallbackDelegate(OnActionPageUp);
 708                     this.ActionPageUpSignal().Connect(accessibilityManagerActionPageUpEventCallbackDelegate);
 709                 }
 710
 711                 accessibilityManagerActionPageUpEventHandler += value;
 712             }
 713
 714             remove
 715             {
 716                 accessibilityManagerActionPageUpEventHandler -= value;
 717
 718                 if (accessibilityManagerActionPageUpEventHandler == null && ActionPageUpSignal().Empty() == false)
 719                 {
 720                     this.ActionPageUpSignal().Disconnect(accessibilityManagerActionPageUpEventCallbackDelegate);
 721                 }
 722             }
 723         }
 724
 725         /// <summary>
 726         /// This is emitted when accessibility action is received to scroll down to the next page (by one finger swipe right and left).
 727         /// </summary>
 728         /// <returns> The signal to connect to </returns>
 729         /// <since_tizen> 6 </since_tizen>
 730         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 731         [EditorBrowsable(EditorBrowsableState.Never)]
 732         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionPageDown
 733         {
 734             add
 735             {
 736                 // Restricted to only one listener
 737                 if (accessibilityManagerActionPageDownEventHandler == null)
 738                 {
 739                     accessibilityManagerActionPageDownEventCallbackDelegate = new ActionPageDownEventCallbackDelegate(OnActionPageDown);
 740                     this.ActionPageDownSignal().Connect(accessibilityManagerActionPageDownEventCallbackDelegate);
 741                 }
 742
 743                 accessibilityManagerActionPageDownEventHandler += value;
 744             }
 745
 746             remove
 747             {
 748                 accessibilityManagerActionPageDownEventHandler -= value;
 749
 750                 if (accessibilityManagerActionPageDownEventHandler == null && ActionPageDownSignal().Empty() == false)
 751                 {
 752                     this.ActionPageDownSignal().Disconnect(accessibilityManagerActionPageDownEventCallbackDelegate);
 753                 }
 754             }
 755         }
 756
 757         /// <summary>
 758         /// This is emitted when accessibility action is received to move the focus to the first item on the screen
 759         /// (by one finger swipe up and down).
 760         /// </summary>
 761         /// <returns> The signal to connect to </returns>
 762         /// <since_tizen> 6 </since_tizen>
 763         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 764         [EditorBrowsable(EditorBrowsableState.Never)]
 765         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionMoveToFirst
 766         {
 767             add
 768             {
 769                 // Restricted to only one listener
 770                 if (accessibilityManagerActionMoveToFirstEventHandler == null)
 771                 {
 772                     accessibilityManagerActionMoveToFirstEventCallbackDelegate = new ActionMoveToFirstEventCallbackDelegate(OnActionMoveToFirst);
 773                     this.ActionMoveToFirstSignal().Connect(accessibilityManagerActionMoveToFirstEventCallbackDelegate);
 774                 }
 775
 776                 accessibilityManagerActionMoveToFirstEventHandler += value;
 777             }
 778
 779             remove
 780             {
 781                 accessibilityManagerActionMoveToFirstEventHandler -= value;
 782
 783                 if (accessibilityManagerActionMoveToFirstEventHandler == null && ActionMoveToFirstSignal().Empty() == false)
 784                 {
 785                     this.ActionMoveToFirstSignal().Disconnect(accessibilityManagerActionMoveToFirstEventCallbackDelegate);
 786                 }
 787             }
 788         }
 789
 790         /// <summary>
 791         /// This is emitted when accessibility action is received to move the focus to the last item on the screen
 792         /// (by one finger swipe down and up).
 793         /// </summary>
 794         /// <returns> The signal to connect to </returns>
 795         /// <since_tizen> 6 </since_tizen>
 796         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 797         [EditorBrowsable(EditorBrowsableState.Never)]
 798         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionMoveToLast
 799         {
 800             add
 801             {
 802                 // Restricted to only one listener
 803                 if (accessibilityManagerActionMoveToLastEventHandler == null)
 804                 {
 805                     accessibilityManagerActionMoveToLastEventCallbackDelegate = new ActionMoveToLastEventCallbackDelegate(OnActionMoveToLast);
 806                     this.ActionMoveToLastSignal().Connect(accessibilityManagerActionMoveToLastEventCallbackDelegate);
 807                 }
 808
 809                 accessibilityManagerActionMoveToLastEventHandler += value;
 810             }
 811
 812             remove
 813             {
 814                 accessibilityManagerActionMoveToLastEventHandler -= value;
 815
 816                 if (accessibilityManagerActionMoveToLastEventHandler == null && ActionMoveToLastSignal().Empty() == false)
 817                 {
 818                     this.ActionMoveToLastSignal().Disconnect(accessibilityManagerActionMoveToLastEventCallbackDelegate);
 819                 }
 820             }
 821         }
 822
 823         /// <summary>
 824         /// This is emitted when accessibility action is received to focus and read from the first item on the top continuously
 825         /// (by three fingers single tap).
 826         /// </summary>
 827         /// <returns> The signal to connect to </returns>
 828         /// <since_tizen> 6 </since_tizen>
 829         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 830         [EditorBrowsable(EditorBrowsableState.Never)]
 831         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionReadFromTop
 832         {
 833             add
 834             {
 835                 // Restricted to only one listener
 836                 if (accessibilityManagerActionReadFromTopEventHandler == null)
 837                 {
 838                     accessibilityManagerActionReadFromTopEventCallbackDelegate = new ActionReadFromTopEventCallbackDelegate(OnActionReadFromTop);
 839                     this.ActionReadFromTopSignal().Connect(accessibilityManagerActionReadFromTopEventCallbackDelegate);
 840                 }
 841
 842                 accessibilityManagerActionReadFromTopEventHandler += value;
 843             }
 844
 845             remove
 846             {
 847                 accessibilityManagerActionReadFromTopEventHandler -= value;
 848
 849                 if (accessibilityManagerActionReadFromTopEventHandler == null && ActionReadFromTopSignal().Empty() == false)
 850                 {
 851                     this.ActionReadFromTopSignal().Disconnect(accessibilityManagerActionReadFromTopEventCallbackDelegate);
 852                 }
 853             }
 854         }
 855
 856         /// <summary>
 857         /// This is emitted when accessibility action is received to move the focus to and read from the next item continuously
 858         /// (by three fingers double tap).
 859         /// </summary>
 860         /// <returns> The signal to connect to </returns>
 861         /// <since_tizen> 6 </since_tizen>
 862         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 863         [EditorBrowsable(EditorBrowsableState.Never)]
 864         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionReadFromNext
 865         {
 866             add
 867             {
 868                 // Restricted to only one listener
 869                 if (accessibilityManagerActionReadFromNextEventHandler == null)
 870                 {
 871                     accessibilityManagerActionReadFromNextEventCallbackDelegate = new ActionReadFromNextEventCallbackDelegate(OnActionReadFromNext);
 872                     this.ActionReadFromNextSignal().Connect(accessibilityManagerActionReadFromNextEventCallbackDelegate);
 873                 }
 874
 875                 accessibilityManagerActionReadFromNextEventHandler += value;
 876             }
 877
 878             remove
 879             {
 880                 accessibilityManagerActionReadFromNextEventHandler -= value;
 881
 882                 if (accessibilityManagerActionReadFromNextEventHandler == null && ActionReadFromNextSignal().Empty() == false)
 883                 {
 884                     this.ActionReadFromNextSignal().Disconnect(accessibilityManagerActionReadFromNextEventCallbackDelegate);
 885                 }
 886             }
 887         }
 888
 889         /// <summary>
 890         /// This is emitted when accessibility action is received to zoom (by one finger triple tap)
 891         /// </summary>
 892         /// <returns> The signal to connect to </returns>
 893         /// <since_tizen> 6 </since_tizen>
 894         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 895         [EditorBrowsable(EditorBrowsableState.Never)]
 896         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionZoom
 897         {
 898             add
 899             {
 900                 // Restricted to only one listener
 901                 if (accessibilityManagerActionZoomEventHandler == null)
 902                 {
 903                     accessibilityManagerActionZoomEventCallbackDelegate = new ActionZoomEventCallbackDelegate(OnActionZoom);
 904                     this.ActionZoomSignal().Connect(accessibilityManagerActionZoomEventCallbackDelegate);
 905                 }
 906
 907                 accessibilityManagerActionZoomEventHandler += value;
 908             }
 909
 910             remove
 911             {
 912                 accessibilityManagerActionZoomEventHandler -= value;
 913
 914                 if (accessibilityManagerActionZoomEventHandler == null && ActionZoomSignal().Empty() == false)
 915                 {
 916                     this.ActionZoomSignal().Disconnect(accessibilityManagerActionZoomEventCallbackDelegate);
 917                 }
 918             }
 919         }
 920
 921         /// <summary>
 922         /// This is emitted when accessibility action is received to pause/resume the current speech (by two fingers single tap).
 923         /// </summary>
 924         /// <returns> The signal to connect to </returns>
 925         /// <since_tizen> 6 </since_tizen>
 926         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 927         [EditorBrowsable(EditorBrowsableState.Never)]
 928         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionReadPauseResume
 929         {
 930             add
 931             {
 932                 // Restricted to only one listener
 933                 if (accessibilityManagerActionReadPauseResumeEventHandler == null)
 934                 {
 935                     accessibilityManagerActionReadPauseResumeEventCallbackDelegate = new ActionReadPauseResumeEventCallbackDelegate(OnActionReadPauseResume);
 936                     this.ActionReadPauseResumeSignal().Connect(accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
 937                 }
 938
 939                 accessibilityManagerActionReadPauseResumeEventHandler += value;
 940             }
 941
 942             remove
 943             {
 944                 accessibilityManagerActionReadPauseResumeEventHandler -= value;
 945
 946                 if (accessibilityManagerActionReadPauseResumeEventHandler == null && ActionReadPauseResumeSignal().Empty() == false)
 947                 {
 948                     this.ActionReadPauseResumeSignal().Disconnect(accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
 949                 }
 950             }
 951         }
 952
 953         /// <summary>
 954         /// This is emitted when accessibility action is received to start/stop the current action (by two fingers double tap).
 955         /// </summary>
 956         /// <returns> The signal to connect to </returns>
 957         /// <since_tizen> 6 </since_tizen>
 958         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 959         [EditorBrowsable(EditorBrowsableState.Never)]
 960         public event ReturnTypeEventHandler<object, EventArgs, bool> ActionStartStop
 961         {
 962             add
 963             {
 964                 // Restricted to only one listener
 965                 if (accessibilityManagerActionStartStopEventHandler == null)
 966                 {
 967                     accessibilityManagerActionStartStopEventCallbackDelegate = new ActionStartStopEventCallbackDelegate(OnActionStartStop);
 968                     this.ActionStartStopSignal().Connect(accessibilityManagerActionStartStopEventCallbackDelegate);
 969                 }
 970
 971                 accessibilityManagerActionStartStopEventHandler += value;
 972             }
 973
 974             remove
 975             {
 976                 accessibilityManagerActionStartStopEventHandler -= value;
 977
 978                 if (accessibilityManagerActionStartStopEventHandler == null && ActionStartStopSignal().Empty() == false)
 979                 {
 980                     this.ActionStartStopSignal().Disconnect(accessibilityManagerActionStartStopEventCallbackDelegate);
 981                 }
 982             }
 983         }
 984
 985         /*
 986             // To be replaced by a new event that takes Touch
 987             public event DaliEventHandlerWithReturnType<object,ActionScrollEventArgs,bool> ActionScroll
 988             {
 989               add
 990               {
 991                 lock(this)
 992                 {
 993                   // Restricted to only one listener
 994                   if (_accessibilityManagerActionScrollEventHandler == null)
 995                   {
 996                     _accessibilityManagerActionScrollEventHandler += value;
 997
 998                     _accessibilityManagerActionScrollEventCallbackDelegate = new ActionScrollEventCallbackDelegate(OnActionScroll);
 999                     this.ActionScrollSignal().Connect(_accessibilityManagerActionScrollEventCallbackDelegate);
1000                   }
1001                 }
1002               }
1003
1004               remove
1005               {
1006                 lock(this)
1007                 {
1008                   if (_accessibilityManagerActionScrollEventHandler != null)
1009                   {
1010                     this.ActionScrollSignal().Disconnect(_accessibilityManagerActionScrollEventCallbackDelegate);
1011                   }
1012
1013                   _accessibilityManagerActionScrollEventHandler -= value;
1014                 }
1015               }
1016             }
1017
1018             // Callback for AccessibilityManager ActionScrollSignal
1019             private bool OnActionScroll(IntPtr accessibilityManager, IntPtr touchEvent)
1020             {
1021               ActionScrollEventArgs e = new ActionScrollEventArgs();
1022
1023               // Populate all members of "e" (ActionScrollEventArgs) with real data
1024               e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(accessibilityManager);
1025               e.TouchEvent = TouchEvent.GetTouchEventFromPtr(touchEvent);
1026
1027               if (_accessibilityManagerActionScrollEventHandler != null)
1028               {
1029                 //here we send all data to user event handlers
1030                 return _accessibilityManagerActionScrollEventHandler(this, e);
1031               }
1032               return false;
1033             }
1034         */
1035
1036         // Common Signals
1037
1038         /// <summary>
1039         /// This signal is emitted when the current focused view is changed.
1040         /// </summary>
1041         /// <returns> The signal to connect to </returns>
1042         /// <since_tizen> 6 </since_tizen>
1043         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1044         [EditorBrowsable(EditorBrowsableState.Never)]
1045         public event EventHandler<FocusChangedEventArgs> FocusChanged
1046         {
1047             add
1048             {
1049                 // Restricted to only one listener
1050                 if (accessibilityManagerFocusChangedEventHandler == null)
1051                 {
1052                     accessibilityManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
1053                     this.FocusChangedSignal().Connect(accessibilityManagerFocusChangedEventCallbackDelegate);
1054                 }
1055
1056                 accessibilityManagerFocusChangedEventHandler += value;
1057             }
1058
1059             remove
1060             {
1061                 accessibilityManagerFocusChangedEventHandler -= value;
1062
1063                 if (accessibilityManagerFocusChangedEventHandler == null && FocusChangedSignal().Empty() == false)
1064                 {
1065                     this.FocusChangedSignal().Disconnect(accessibilityManagerFocusChangedEventCallbackDelegate);
1066                 }
1067             }
1068         }
1069
1070         /// <summary>
1071         /// This signal is emitted when the current focused view is activated.
1072         /// </summary>
1073         /// <returns> The signal to connect to </returns>
1074         /// <since_tizen> 6 </since_tizen>
1075         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1076         [EditorBrowsable(EditorBrowsableState.Never)]
1077         public event EventHandler<FocusedViewActivatedEventArgs> FocusedViewActivated
1078         {
1079             add
1080             {
1081                 // Restricted to only one listener
1082                 if (accessibilityManagerFocusedViewActivatedEventHandler == null)
1083                 {
1084                     accessibilityManagerFocusedViewActivatedEventCallbackDelegate = new FocusedViewActivatedEventCallbackDelegate(OnFocusedViewActivated);
1085                     this.FocusedViewActivatedSignal().Connect(accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
1086                 }
1087
1088                 accessibilityManagerFocusedViewActivatedEventHandler += value;
1089             }
1090
1091             remove
1092             {
1093                 accessibilityManagerFocusedViewActivatedEventHandler -= value;
1094
1095                 if (accessibilityManagerFocusedViewActivatedEventHandler == null && FocusedViewActivatedSignal().Empty() == false)
1096                 {
1097                     this.FocusedViewActivatedSignal().Disconnect(accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
1098                 }
1099             }
1100         }
1101
1102         /// <summary>
1103         /// This signal is emitted when there is no way to move focus further.
1104         /// </summary>
1105         /// <returns> The signal to connect to </returns>
1106         /// <since_tizen> 6 </since_tizen>
1107         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1108         [EditorBrowsable(EditorBrowsableState.Never)]
1109         public event EventHandler<FocusOvershotEventArgs> FocusOvershot
1110         {
1111             add
1112             {
1113                 // Restricted to only one listener
1114                 if (accessibilityManagerFocusOvershotEventHandler == null)
1115                 {
1116                     accessibilityManagerFocusOvershotEventCallbackDelegate = new FocusOvershotEventCallbackDelegate(OnFocusOvershot);
1117                     this.FocusOvershotSignal().Connect(accessibilityManagerFocusOvershotEventCallbackDelegate);
1118                 }
1119
1120                 accessibilityManagerFocusOvershotEventHandler += value;
1121             }
1122
1123             remove
1124             {
1125                 accessibilityManagerFocusOvershotEventHandler -= value;
1126
1127                 if (accessibilityManagerFocusOvershotEventHandler == null && FocusOvershotSignal().Empty() == false)
1128                 {
1129                     this.FocusOvershotSignal().Disconnect(accessibilityManagerFocusOvershotEventCallbackDelegate);
1130                 }
1131             }
1132         }
1133     }
1134 }