src/Tizen.NUI/src/internal/AccessibilityManager.cs

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16
  17 namespace Tizen.NUI
  18 {
  19
  20     using System;
  21     using System.Runtime.InteropServices;
  22     using Tizen.NUI.BaseComponents;
  23
  24     internal class AccessibilityManager : BaseHandle
  25     {
  26         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  27
  28         internal AccessibilityManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.AccessibilityManager_SWIGUpcast(cPtr), cMemoryOwn)
  29         {
  30             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  31         }
  32
  33         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(AccessibilityManager obj)
  34         {
  35             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  36         }
  37
  38         protected override void Dispose(DisposeTypes type)
  39         {
  40             if (disposed)
  41             {
  42                 return;
  43             }
  44
  45             if (type == DisposeTypes.Explicit)
  46             {
  47                 //Called by User
  48                 //Release your own managed resources here.
  49                 //You should release all of your own disposable objects here.
  50
  51             }
  52
  53             //Release your own unmanaged resources here.
  54             //You should not access any managed member here except static instance.
  55             //because the execution order of Finalizes is non-deterministic.
  56
  57             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  58             {
  59                 if (swigCMemOwn)
  60                 {
  61                     swigCMemOwn = false;
  62                     NDalicPINVOKE.delete_AccessibilityManager(swigCPtr);
  63                 }
  64                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  65             }
  66
  67             base.Dispose(type);
  68         }
  69
  70         /**
  71             * @brief Event arguments that passed via StatusChanged signal
  72             *
  73         */
  74         public class StatusChangedEventArgs : EventArgs
  75         {
  76             private AccessibilityManager _accessibilityManager;
  77
  78             public AccessibilityManager AccessibilityManager
  79             {
  80                 get
  81                 {
  82                     return _accessibilityManager;
  83                 }
  84                 set
  85                 {
  86                     _accessibilityManager = value;
  87                 }
  88             }
  89         }
  90
  91         /**
  92           * @brief Event arguments that passed via ActionNext signal
  93           *
  94           */
  95         public class ActionNextEventArgs : EventArgs
  96         {
  97             private AccessibilityManager _accessibilityManager;
  98
  99             public AccessibilityManager AccessibilityManager
 100             {
 101                 get
 102                 {
 103                     return _accessibilityManager;
 104                 }
 105                 set
 106                 {
 107                     _accessibilityManager = value;
 108                 }
 109             }
 110         }
 111
 112         /**
 113           * @brief Event arguments that passed via ActionPrevious signal
 114           *
 115           */
 116         public class ActionPreviousEventArgs : EventArgs
 117         {
 118             private AccessibilityManager _accessibilityManager;
 119
 120             public AccessibilityManager AccessibilityManager
 121             {
 122                 get
 123                 {
 124                     return _accessibilityManager;
 125                 }
 126                 set
 127                 {
 128                     _accessibilityManager = value;
 129                 }
 130             }
 131         }
 132
 133         /**
 134           * @brief Event arguments that passed via ActionActivate signal
 135           *
 136           */
 137         public class ActionActivateEventArgs : EventArgs
 138         {
 139             private AccessibilityManager _accessibilityManager;
 140
 141             public AccessibilityManager AccessibilityManager
 142             {
 143                 get
 144                 {
 145                     return _accessibilityManager;
 146                 }
 147                 set
 148                 {
 149                     _accessibilityManager = value;
 150                 }
 151             }
 152         }
 153
 154         /**
 155           * @brief Event arguments that passed via ActionRead signal
 156           *
 157           */
 158         public class ActionReadEventArgs : EventArgs
 159         {
 160             private AccessibilityManager _accessibilityManager;
 161
 162             public AccessibilityManager AccessibilityManager
 163             {
 164                 get
 165                 {
 166                     return _accessibilityManager;
 167                 }
 168                 set
 169                 {
 170                     _accessibilityManager = value;
 171                 }
 172             }
 173         }
 174
 175         /**
 176           * @brief Event arguments that passed via ActionOver signal
 177           *
 178           */
 179         public class ActionOverEventArgs : EventArgs
 180         {
 181             private AccessibilityManager _accessibilityManager;
 182
 183             public AccessibilityManager AccessibilityManager
 184             {
 185                 get
 186                 {
 187                     return _accessibilityManager;
 188                 }
 189                 set
 190                 {
 191                     _accessibilityManager = value;
 192                 }
 193             }
 194         }
 195
 196         /**
 197           * @brief Event arguments that passed via ActionReadNext signal
 198           *
 199           */
 200         public class ActionReadNextEventArgs : EventArgs
 201         {
 202             private AccessibilityManager _accessibilityManager;
 203
 204             public AccessibilityManager AccessibilityManager
 205             {
 206                 get
 207                 {
 208                     return _accessibilityManager;
 209                 }
 210                 set
 211                 {
 212                     _accessibilityManager = value;
 213                 }
 214             }
 215         }
 216
 217         /**
 218           * @brief Event arguments that passed via ActionReadPrevious signal
 219           *
 220           */
 221         public class ActionReadPreviousEventArgs : EventArgs
 222         {
 223             private AccessibilityManager _accessibilityManager;
 224
 225             public AccessibilityManager AccessibilityManager
 226             {
 227                 get
 228                 {
 229                     return _accessibilityManager;
 230                 }
 231                 set
 232                 {
 233                     _accessibilityManager = value;
 234                 }
 235             }
 236         }
 237
 238         /**
 239           * @brief Event arguments that passed via ActionUp signal
 240           *
 241           */
 242         public class ActionUpEventArgs : EventArgs
 243         {
 244             private AccessibilityManager _accessibilityManager;
 245
 246             public AccessibilityManager AccessibilityManager
 247             {
 248                 get
 249                 {
 250                     return _accessibilityManager;
 251                 }
 252                 set
 253                 {
 254                     _accessibilityManager = value;
 255                 }
 256             }
 257         }
 258
 259         /**
 260           * @brief Event arguments that passed via ActionDown signal
 261           *
 262           */
 263         public class ActionDownEventArgs : EventArgs
 264         {
 265             private AccessibilityManager _accessibilityManager;
 266
 267             public AccessibilityManager AccessibilityManager
 268             {
 269                 get
 270                 {
 271                     return _accessibilityManager;
 272                 }
 273                 set
 274                 {
 275                     _accessibilityManager = value;
 276                 }
 277             }
 278         }
 279
 280         /**
 281           * @brief Event arguments that passed via ActionClearFocus signal
 282           *
 283           */
 284         public class ActionClearFocusEventArgs : EventArgs
 285         {
 286             private AccessibilityManager _accessibilityManager;
 287
 288             public AccessibilityManager AccessibilityManager
 289             {
 290                 get
 291                 {
 292                     return _accessibilityManager;
 293                 }
 294                 set
 295                 {
 296                     _accessibilityManager = value;
 297                 }
 298             }
 299         }
 300
 301         /**
 302           * @brief Event arguments that passed via ActionBack signal
 303           *
 304           */
 305         public class ActionBackEventArgs : EventArgs
 306         {
 307             private AccessibilityManager _accessibilityManager;
 308
 309             public AccessibilityManager AccessibilityManager
 310             {
 311                 get
 312                 {
 313                     return _accessibilityManager;
 314                 }
 315                 set
 316                 {
 317                     _accessibilityManager = value;
 318                 }
 319             }
 320         }
 321
 322         /**
 323           * @brief Event arguments that passed via ActionScrollUp signal
 324           *
 325           */
 326         public class ActionScrollUpEventArgs : EventArgs
 327         {
 328             private AccessibilityManager _accessibilityManager;
 329
 330             public AccessibilityManager AccessibilityManager
 331             {
 332                 get
 333                 {
 334                     return _accessibilityManager;
 335                 }
 336                 set
 337                 {
 338                     _accessibilityManager = value;
 339                 }
 340             }
 341         }
 342
 343         /**
 344           * @brief Event arguments that passed via ActionScrollDown signal
 345           *
 346           */
 347         public class ActionScrollDownEventArgs : EventArgs
 348         {
 349             private AccessibilityManager _accessibilityManager;
 350
 351             public AccessibilityManager AccessibilityManager
 352             {
 353                 get
 354                 {
 355                     return _accessibilityManager;
 356                 }
 357                 set
 358                 {
 359                     _accessibilityManager = value;
 360                 }
 361             }
 362         }
 363
 364         /**
 365           * @brief Event arguments that passed via ActionPageLeft signal
 366           *
 367           */
 368         public class ActionPageLeftEventArgs : EventArgs
 369         {
 370             private AccessibilityManager _accessibilityManager;
 371
 372             public AccessibilityManager AccessibilityManager
 373             {
 374                 get
 375                 {
 376                     return _accessibilityManager;
 377                 }
 378                 set
 379                 {
 380                     _accessibilityManager = value;
 381                 }
 382             }
 383         }
 384
 385         /**
 386           * @brief Event arguments that passed via ActionPageRight signal
 387           *
 388           */
 389         public class ActionPageRightEventArgs : EventArgs
 390         {
 391             private AccessibilityManager _accessibilityManager;
 392
 393             public AccessibilityManager AccessibilityManager
 394             {
 395                 get
 396                 {
 397                     return _accessibilityManager;
 398                 }
 399                 set
 400                 {
 401                     _accessibilityManager = value;
 402                 }
 403             }
 404         }
 405
 406         /**
 407           * @brief Event arguments that passed via ActionPageUp signal
 408           *
 409           */
 410         public class ActionPageUpEventArgs : EventArgs
 411         {
 412             private AccessibilityManager _accessibilityManager;
 413
 414             public AccessibilityManager AccessibilityManager
 415             {
 416                 get
 417                 {
 418                     return _accessibilityManager;
 419                 }
 420                 set
 421                 {
 422                     _accessibilityManager = value;
 423                 }
 424             }
 425         }
 426
 427         /**
 428           * @brief Event arguments that passed via ActionPageDown signal
 429           *
 430           */
 431         public class ActionPageDownEventArgs : EventArgs
 432         {
 433             private AccessibilityManager _accessibilityManager;
 434
 435             public AccessibilityManager AccessibilityManager
 436             {
 437                 get
 438                 {
 439                     return _accessibilityManager;
 440                 }
 441                 set
 442                 {
 443                     _accessibilityManager = value;
 444                 }
 445             }
 446         }
 447
 448         /**
 449           * @brief Event arguments that passed via ActionMoveToFirst signal
 450           *
 451           */
 452         public class ActionMoveToFirstEventArgs : EventArgs
 453         {
 454             private AccessibilityManager _accessibilityManager;
 455
 456             public AccessibilityManager AccessibilityManager
 457             {
 458                 get
 459                 {
 460                     return _accessibilityManager;
 461                 }
 462                 set
 463                 {
 464                     _accessibilityManager = value;
 465                 }
 466             }
 467         }
 468
 469         /**
 470           * @brief Event arguments that passed via ActionMoveToLast signal
 471           *
 472           */
 473         public class ActionMoveToLastEventArgs : EventArgs
 474         {
 475             private AccessibilityManager _accessibilityManager;
 476
 477             public AccessibilityManager AccessibilityManager
 478             {
 479                 get
 480                 {
 481                     return _accessibilityManager;
 482                 }
 483                 set
 484                 {
 485                     _accessibilityManager = value;
 486                 }
 487             }
 488         }
 489
 490         /**
 491           * @brief Event arguments that passed via ActionReadFromTop signal
 492           *
 493           */
 494         public class ActionReadFromTopEventArgs : EventArgs
 495         {
 496             private AccessibilityManager _accessibilityManager;
 497
 498             public AccessibilityManager AccessibilityManager
 499             {
 500                 get
 501                 {
 502                     return _accessibilityManager;
 503                 }
 504                 set
 505                 {
 506                     _accessibilityManager = value;
 507                 }
 508             }
 509         }
 510
 511         /**
 512           * @brief Event arguments that passed via ActionReadFromNext signal
 513           *
 514           */
 515         public class ActionReadFromNextEventArgs : EventArgs
 516         {
 517             private AccessibilityManager _accessibilityManager;
 518
 519             public AccessibilityManager AccessibilityManager
 520             {
 521                 get
 522                 {
 523                     return _accessibilityManager;
 524                 }
 525                 set
 526                 {
 527                     _accessibilityManager = value;
 528                 }
 529             }
 530         }
 531
 532         /**
 533           * @brief Event arguments that passed via ActionZoom signal
 534           *
 535           */
 536         public class ActionZoomEventArgs : EventArgs
 537         {
 538             private AccessibilityManager _accessibilityManager;
 539
 540             public AccessibilityManager AccessibilityManager
 541             {
 542                 get
 543                 {
 544                     return _accessibilityManager;
 545                 }
 546                 set
 547                 {
 548                     _accessibilityManager = value;
 549                 }
 550             }
 551         }
 552
 553         /**
 554           * @brief Event arguments that passed via ActionReadIndicatorInformation signal
 555           *
 556           */
 557         public class ActionReadIndicatorInformationEventArgs : EventArgs
 558         {
 559             private AccessibilityManager _accessibilityManager;
 560
 561             public AccessibilityManager AccessibilityManager
 562             {
 563                 get
 564                 {
 565                     return _accessibilityManager;
 566                 }
 567                 set
 568                 {
 569                     _accessibilityManager = value;
 570                 }
 571             }
 572         }
 573
 574         /**
 575           * @brief Event arguments that passed via ActionReadPauseResume signal
 576           *
 577           */
 578         public class ActionReadPauseResumeEventArgs : EventArgs
 579         {
 580             private AccessibilityManager _accessibilityManager;
 581
 582             public AccessibilityManager AccessibilityManager
 583             {
 584                 get
 585                 {
 586                     return _accessibilityManager;
 587                 }
 588                 set
 589                 {
 590                     _accessibilityManager = value;
 591                 }
 592             }
 593         }
 594
 595         /**
 596           * @brief Event arguments that passed via ActionStartStop signal
 597           *
 598           */
 599         public class ActionStartStopEventArgs : EventArgs
 600         {
 601             private AccessibilityManager _accessibilityManager;
 602
 603             public AccessibilityManager AccessibilityManager
 604             {
 605                 get
 606                 {
 607                     return _accessibilityManager;
 608                 }
 609                 set
 610                 {
 611                     _accessibilityManager = value;
 612                 }
 613             }
 614         }
 615
 616         /**
 617           * @brief Event arguments that passed via ActionScroll signal
 618           *
 619           */
 620         /*
 621             // To be replaced by a new event that takes Touch
 622             public class ActionScrollEventArgs : EventArgs
 623             {
 624               private AccessibilityManager _accessibilityManager;
 625               private TouchEvent _touchEvent;
 626
 627               public AccessibilityManager AccessibilityManager
 628               {
 629                 get
 630                 {
 631                   return _accessibilityManager;
 632                 }
 633                 set
 634                 {
 635                   _accessibilityManager = value;
 636                 }
 637               }
 638
 639               public TouchEvent TouchEvent
 640               {
 641                 get
 642                 {
 643                   return _touchEvent;
 644                 }
 645                 set
 646                 {
 647                   _touchEvent = value;
 648                 }
 649               }
 650             }
 651         */
 652
 653         /**
 654           * @brief Event arguments that passed via ActionPageUp signal
 655           *
 656           */
 657         public class FocusChangedEventArgs : EventArgs
 658         {
 659             private View _viewCurrent;
 660             private View _viewNext;
 661
 662             public View ViewCurrent
 663             {
 664                 get
 665                 {
 666                     return _viewCurrent;
 667                 }
 668                 set
 669                 {
 670                     _viewCurrent = value;
 671                 }
 672             }
 673
 674             public View ViewNext
 675             {
 676                 get
 677                 {
 678                     return _viewNext;
 679                 }
 680                 set
 681                 {
 682                     _viewNext = value;
 683                 }
 684             }
 685         }
 686
 687         /**
 688           * @brief Event arguments that passed via FocusedViewActivated signal
 689           *
 690           */
 691         public class FocusedViewActivatedEventArgs : EventArgs
 692         {
 693             private View _view;
 694
 695
 696             public View View
 697             {
 698                 get
 699                 {
 700                     return _view;
 701                 }
 702                 set
 703                 {
 704                     _view = value;
 705                 }
 706             }
 707         }
 708
 709         /**
 710           * @brief Event arguments that passed via FocusOvershot signal
 711           *
 712           */
 713         public class FocusOvershotEventArgs : EventArgs
 714         {
 715             private View _currentFocusedView;
 716             private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
 717
 718             public View CurrentFocusedView
 719             {
 720                 get
 721                 {
 722                     return _currentFocusedView;
 723                 }
 724                 set
 725                 {
 726                     _currentFocusedView = value;
 727                 }
 728             }
 729
 730             public AccessibilityManager.FocusOvershotDirection FocusOvershotDirection
 731             {
 732                 get
 733                 {
 734                     return _focusOvershotDirection;
 735                 }
 736                 set
 737                 {
 738                     _focusOvershotDirection = value;
 739                 }
 740             }
 741         }
 742
 743
 744         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 745         private delegate bool StatusChangedEventCallbackDelegate(IntPtr accessibilityManager);
 746         private DaliEventHandlerWithReturnType<object, StatusChangedEventArgs, bool> _accessibilityManagerStatusChangedEventHandler;
 747         private StatusChangedEventCallbackDelegate _accessibilityManagerStatusChangedEventCallbackDelegate;
 748
 749         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 750         private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
 751         private DaliEventHandlerWithReturnType<object, ActionNextEventArgs, bool> _accessibilityManagerActionNextEventHandler;
 752         private ActionNextEventCallbackDelegate _accessibilityManagerActionNextEventCallbackDelegate;
 753
 754         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 755         private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
 756         private DaliEventHandlerWithReturnType<object, ActionPreviousEventArgs, bool> _accessibilityManagerActionPreviousEventHandler;
 757         private ActionPreviousEventCallbackDelegate _accessibilityManagerActionPreviousEventCallbackDelegate;
 758
 759         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 760         private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
 761         private DaliEventHandlerWithReturnType<object, ActionActivateEventArgs, bool> _accessibilityManagerActionActivateEventHandler;
 762         private ActionActivateEventCallbackDelegate _accessibilityManagerActionActivateEventCallbackDelegate;
 763
 764         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 765         private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
 766         private DaliEventHandlerWithReturnType<object, ActionReadEventArgs, bool> _accessibilityManagerActionReadEventHandler;
 767         private ActionReadEventCallbackDelegate _accessibilityManagerActionReadEventCallbackDelegate;
 768
 769         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 770         private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
 771         private DaliEventHandlerWithReturnType<object, ActionOverEventArgs, bool> _accessibilityManagerActionOverEventHandler;
 772         private ActionOverEventCallbackDelegate _accessibilityManagerActionOverEventCallbackDelegate;
 773
 774         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 775         private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
 776         private DaliEventHandlerWithReturnType<object, ActionReadNextEventArgs, bool> _accessibilityManagerActionReadNextEventHandler;
 777         private ActionReadNextEventCallbackDelegate _accessibilityManagerActionReadNextEventCallbackDelegate;
 778
 779         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 780         private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
 781         private DaliEventHandlerWithReturnType<object, ActionReadPreviousEventArgs, bool> _accessibilityManagerActionReadPreviousEventHandler;
 782         private ActionReadPreviousEventCallbackDelegate _accessibilityManagerActionReadPreviousEventCallbackDelegate;
 783
 784         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 785         private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
 786         private DaliEventHandlerWithReturnType<object, ActionUpEventArgs, bool> _accessibilityManagerActionUpEventHandler;
 787         private ActionUpEventCallbackDelegate _accessibilityManagerActionUpEventCallbackDelegate;
 788
 789         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 790         private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
 791         private DaliEventHandlerWithReturnType<object, ActionDownEventArgs, bool> _accessibilityManagerActionDownEventHandler;
 792         private ActionDownEventCallbackDelegate _accessibilityManagerActionDownEventCallbackDelegate;
 793
 794         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 795         private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
 796         private DaliEventHandlerWithReturnType<object, ActionClearFocusEventArgs, bool> _accessibilityManagerActionClearFocusEventHandler;
 797         private ActionClearFocusEventCallbackDelegate _accessibilityManagerActionClearFocusEventCallbackDelegate;
 798
 799         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 800         private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
 801         private DaliEventHandlerWithReturnType<object, ActionBackEventArgs, bool> _accessibilityManagerActionBackEventHandler;
 802         private ActionBackEventCallbackDelegate _accessibilityManagerActionBackEventCallbackDelegate;
 803
 804         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 805         private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
 806         private DaliEventHandlerWithReturnType<object, ActionScrollUpEventArgs, bool> _accessibilityManagerActionScrollUpEventHandler;
 807         private ActionScrollUpEventCallbackDelegate _accessibilityManagerActionScrollUpEventCallbackDelegate;
 808
 809         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 810         private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
 811         private DaliEventHandlerWithReturnType<object, ActionScrollDownEventArgs, bool> _accessibilityManagerActionScrollDownEventHandler;
 812         private ActionScrollDownEventCallbackDelegate _accessibilityManagerActionScrollDownEventCallbackDelegate;
 813
 814         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 815         private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
 816         private DaliEventHandlerWithReturnType<object, ActionPageLeftEventArgs, bool> _accessibilityManagerActionPageLeftEventHandler;
 817         private ActionPageLeftEventCallbackDelegate _accessibilityManagerActionPageLeftEventCallbackDelegate;
 818
 819         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 820         private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
 821         private DaliEventHandlerWithReturnType<object, ActionPageRightEventArgs, bool> _accessibilityManagerActionPageRightEventHandler;
 822         private ActionPageRightEventCallbackDelegate _accessibilityManagerActionPageRightEventCallbackDelegate;
 823
 824         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 825         private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
 826         private DaliEventHandlerWithReturnType<object, ActionPageUpEventArgs, bool> _accessibilityManagerActionPageUpEventHandler;
 827         private ActionPageUpEventCallbackDelegate _accessibilityManagerActionPageUpEventCallbackDelegate;
 828
 829         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 830         private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
 831         private DaliEventHandlerWithReturnType<object, ActionPageDownEventArgs, bool> _accessibilityManagerActionPageDownEventHandler;
 832         private ActionPageDownEventCallbackDelegate _accessibilityManagerActionPageDownEventCallbackDelegate;
 833
 834         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 835         private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
 836         private DaliEventHandlerWithReturnType<object, ActionMoveToFirstEventArgs, bool> _accessibilityManagerActionMoveToFirstEventHandler;
 837         private ActionMoveToFirstEventCallbackDelegate _accessibilityManagerActionMoveToFirstEventCallbackDelegate;
 838
 839         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 840         private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
 841         private DaliEventHandlerWithReturnType<object, ActionMoveToLastEventArgs, bool> _accessibilityManagerActionMoveToLastEventHandler;
 842         private ActionMoveToLastEventCallbackDelegate _accessibilityManagerActionMoveToLastEventCallbackDelegate;
 843
 844         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 845         private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
 846         private DaliEventHandlerWithReturnType<object, ActionReadFromTopEventArgs, bool> _accessibilityManagerActionReadFromTopEventHandler;
 847         private ActionReadFromTopEventCallbackDelegate _accessibilityManagerActionReadFromTopEventCallbackDelegate;
 848
 849         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 850         private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
 851         private DaliEventHandlerWithReturnType<object, ActionReadFromNextEventArgs, bool> _accessibilityManagerActionReadFromNextEventHandler;
 852         private ActionReadFromNextEventCallbackDelegate _accessibilityManagerActionReadFromNextEventCallbackDelegate;
 853
 854         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 855         private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
 856         private DaliEventHandlerWithReturnType<object, ActionZoomEventArgs, bool> _accessibilityManagerActionZoomEventHandler;
 857         private ActionZoomEventCallbackDelegate _accessibilityManagerActionZoomEventCallbackDelegate;
 858
 859         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 860         private delegate bool ActionReadIndicatorInformationEventCallbackDelegate(IntPtr accessibilityManager);
 861         private DaliEventHandlerWithReturnType<object, ActionReadIndicatorInformationEventArgs, bool> _accessibilityManagerActionReadIndicatorInformationEventHandler;
 862         private ActionReadIndicatorInformationEventCallbackDelegate _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate;
 863
 864         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 865         private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
 866         private DaliEventHandlerWithReturnType<object, ActionReadPauseResumeEventArgs, bool> _accessibilityManagerActionReadPauseResumeEventHandler;
 867         private ActionReadPauseResumeEventCallbackDelegate _accessibilityManagerActionReadPauseResumeEventCallbackDelegate;
 868
 869         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 870         private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
 871         private DaliEventHandlerWithReturnType<object, ActionStartStopEventArgs, bool> _accessibilityManagerActionStartStopEventHandler;
 872         private ActionStartStopEventCallbackDelegate _accessibilityManagerActionStartStopEventCallbackDelegate;
 873
 874         /*
 875             // To be replaced by a new event that takes Touch
 876             [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 877             private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
 878             private DaliEventHandlerWithReturnType<object,ActionScrollEventArgs,bool> _accessibilityManagerActionScrollEventHandler;
 879             private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;
 880         */
 881
 882         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 883         private delegate void FocusChangedEventCallbackDelegate(IntPtr view1, IntPtr view2);
 884         private DaliEventHandler<object, FocusChangedEventArgs> _accessibilityManagerFocusChangedEventHandler;
 885         private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
 886
 887         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 888         private delegate void FocusedViewActivatedEventCallbackDelegate(IntPtr view);
 889         private DaliEventHandler<object, FocusedViewActivatedEventArgs> _accessibilityManagerFocusedViewActivatedEventHandler;
 890         private FocusedViewActivatedEventCallbackDelegate _accessibilityManagerFocusedViewActivatedEventCallbackDelegate;
 891
 892         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 893         private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction);
 894         private DaliEventHandler<object, FocusOvershotEventArgs> _accessibilityManagerFocusOvershotEventHandler;
 895         private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
 896
 897         public event DaliEventHandlerWithReturnType<object, StatusChangedEventArgs, bool> StatusChanged
 898         {
 899             add
 900             {
 901                 lock (this)
 902                 {
 903                     // Restricted to only one listener
 904                     if (_accessibilityManagerStatusChangedEventHandler == null)
 905                     {
 906                         _accessibilityManagerStatusChangedEventHandler += value;
 907
 908                         _accessibilityManagerStatusChangedEventCallbackDelegate = new StatusChangedEventCallbackDelegate(OnStatusChanged);
 909                         this.StatusChangedSignal().Connect(_accessibilityManagerStatusChangedEventCallbackDelegate);
 910                     }
 911                 }
 912             }
 913
 914             remove
 915             {
 916                 lock (this)
 917                 {
 918                     if (_accessibilityManagerStatusChangedEventHandler != null)
 919                     {
 920                         this.StatusChangedSignal().Disconnect(_accessibilityManagerStatusChangedEventCallbackDelegate);
 921                     }
 922
 923                     _accessibilityManagerStatusChangedEventHandler -= value;
 924                 }
 925             }
 926         }
 927
 928         // Callback for AccessibilityManager StatusChangedSignal
 929         private bool OnStatusChanged(IntPtr data)
 930         {
 931             StatusChangedEventArgs e = new StatusChangedEventArgs();
 932
 933             // Populate all members of "e" (StatusChangedEventArgs) with real data
 934             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
 935
 936             if (_accessibilityManagerStatusChangedEventHandler != null)
 937             {
 938                 //here we send all data to user event handlers
 939                 return _accessibilityManagerStatusChangedEventHandler(this, e);
 940             }
 941             return false;
 942         }
 943
 944         public event DaliEventHandlerWithReturnType<object, ActionNextEventArgs, bool> ActionNext
 945         {
 946             add
 947             {
 948                 lock (this)
 949                 {
 950                     // Restricted to only one listener
 951                     if (_accessibilityManagerActionNextEventHandler == null)
 952                     {
 953                         _accessibilityManagerActionNextEventHandler += value;
 954
 955                         _accessibilityManagerActionNextEventCallbackDelegate = new ActionNextEventCallbackDelegate(OnActionNext);
 956                         this.ActionNextSignal().Connect(_accessibilityManagerActionNextEventCallbackDelegate);
 957                     }
 958                 }
 959             }
 960
 961             remove
 962             {
 963                 lock (this)
 964                 {
 965                     if (_accessibilityManagerActionNextEventHandler != null)
 966                     {
 967                         this.ActionNextSignal().Disconnect(_accessibilityManagerActionNextEventCallbackDelegate);
 968                     }
 969
 970                     _accessibilityManagerActionNextEventHandler -= value;
 971                 }
 972             }
 973         }
 974
 975         // Callback for AccessibilityManager ActionNextSignal
 976         private bool OnActionNext(IntPtr data)
 977         {
 978             ActionNextEventArgs e = new ActionNextEventArgs();
 979
 980             // Populate all members of "e" (ActionNextEventArgs) with real data
 981             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
 982
 983             if (_accessibilityManagerActionNextEventHandler != null)
 984             {
 985                 //here we send all data to user event handlers
 986                 return _accessibilityManagerActionNextEventHandler(this, e);
 987             }
 988             return false;
 989         }
 990
 991         public event DaliEventHandlerWithReturnType<object, ActionPreviousEventArgs, bool> ActionPrevious
 992         {
 993             add
 994             {
 995                 lock (this)
 996                 {
 997                     // Restricted to only one listener
 998                     if (_accessibilityManagerActionPreviousEventHandler == null)
 999                     {
1000                         _accessibilityManagerActionPreviousEventHandler += value;
1001
1002                         _accessibilityManagerActionPreviousEventCallbackDelegate = new ActionPreviousEventCallbackDelegate(OnActionPrevious);
1003                         this.ActionPreviousSignal().Connect(_accessibilityManagerActionPreviousEventCallbackDelegate);
1004                     }
1005                 }
1006             }
1007
1008             remove
1009             {
1010                 lock (this)
1011                 {
1012                     if (_accessibilityManagerActionPreviousEventHandler != null)
1013                     {
1014                         this.ActionPreviousSignal().Disconnect(_accessibilityManagerActionPreviousEventCallbackDelegate);
1015                     }
1016
1017                     _accessibilityManagerActionPreviousEventHandler -= value;
1018                 }
1019             }
1020         }
1021
1022         // Callback for AccessibilityManager ActionPreviousSignal
1023         private bool OnActionPrevious(IntPtr data)
1024         {
1025             ActionPreviousEventArgs e = new ActionPreviousEventArgs();
1026
1027             // Populate all members of "e" (ActionPreviousEventArgs) with real data
1028             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1029
1030             if (_accessibilityManagerActionPreviousEventHandler != null)
1031             {
1032                 //here we send all data to user event handlers
1033                 return _accessibilityManagerActionPreviousEventHandler(this, e);
1034             }
1035             return false;
1036         }
1037
1038         public event DaliEventHandlerWithReturnType<object, ActionActivateEventArgs, bool> ActionActivate
1039         {
1040             add
1041             {
1042                 lock (this)
1043                 {
1044                     // Restricted to only one listener
1045                     if (_accessibilityManagerActionActivateEventHandler == null)
1046                     {
1047                         _accessibilityManagerActionActivateEventHandler += value;
1048
1049                         _accessibilityManagerActionActivateEventCallbackDelegate = new ActionActivateEventCallbackDelegate(OnActionActivate);
1050                         this.ActionActivateSignal().Connect(_accessibilityManagerActionActivateEventCallbackDelegate);
1051                     }
1052                 }
1053             }
1054
1055             remove
1056             {
1057                 lock (this)
1058                 {
1059                     if (_accessibilityManagerActionActivateEventHandler != null)
1060                     {
1061                         this.ActionActivateSignal().Disconnect(_accessibilityManagerActionActivateEventCallbackDelegate);
1062                     }
1063
1064                     _accessibilityManagerActionActivateEventHandler -= value;
1065                 }
1066             }
1067         }
1068
1069         // Callback for AccessibilityManager ActionActivateSignal
1070         private bool OnActionActivate(IntPtr data)
1071         {
1072             ActionActivateEventArgs e = new ActionActivateEventArgs();
1073
1074             // Populate all members of "e" (ActionActivateEventArgs) with real data
1075             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1076
1077             if (_accessibilityManagerActionActivateEventHandler != null)
1078             {
1079                 //here we send all data to user event handlers
1080                 return _accessibilityManagerActionActivateEventHandler(this, e);
1081             }
1082             return false;
1083         }
1084
1085         public event DaliEventHandlerWithReturnType<object, ActionReadEventArgs, bool> ActionRead
1086         {
1087             add
1088             {
1089                 lock (this)
1090                 {
1091                     // Restricted to only one listener
1092                     if (_accessibilityManagerActionReadEventHandler == null)
1093                     {
1094                         _accessibilityManagerActionReadEventHandler += value;
1095
1096                         _accessibilityManagerActionReadEventCallbackDelegate = new ActionReadEventCallbackDelegate(OnActionRead);
1097                         this.ActionReadSignal().Connect(_accessibilityManagerActionReadEventCallbackDelegate);
1098                     }
1099                 }
1100             }
1101
1102             remove
1103             {
1104                 lock (this)
1105                 {
1106                     if (_accessibilityManagerActionReadEventHandler != null)
1107                     {
1108                         this.ActionReadSignal().Disconnect(_accessibilityManagerActionReadEventCallbackDelegate);
1109                     }
1110
1111                     _accessibilityManagerActionReadEventHandler -= value;
1112                 }
1113             }
1114         }
1115
1116         // Callback for AccessibilityManager ActionReadSignal
1117         private bool OnActionRead(IntPtr data)
1118         {
1119             ActionReadEventArgs e = new ActionReadEventArgs();
1120
1121             // Populate all members of "e" (ActionReadEventArgs) with real data
1122             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1123
1124             if (_accessibilityManagerActionReadEventHandler != null)
1125             {
1126                 //here we send all data to user event handlers
1127                 return _accessibilityManagerActionReadEventHandler(this, e);
1128             }
1129             return false;
1130         }
1131
1132         public event DaliEventHandlerWithReturnType<object, ActionOverEventArgs, bool> ActionOver
1133         {
1134             add
1135             {
1136                 lock (this)
1137                 {
1138                     // Restricted to only one listener
1139                     if (_accessibilityManagerActionOverEventHandler == null)
1140                     {
1141                         _accessibilityManagerActionOverEventHandler += value;
1142
1143                         _accessibilityManagerActionOverEventCallbackDelegate = new ActionOverEventCallbackDelegate(OnActionOver);
1144                         this.ActionOverSignal().Connect(_accessibilityManagerActionOverEventCallbackDelegate);
1145                     }
1146                 }
1147             }
1148
1149             remove
1150             {
1151                 lock (this)
1152                 {
1153                     if (_accessibilityManagerActionOverEventHandler != null)
1154                     {
1155                         this.ActionOverSignal().Disconnect(_accessibilityManagerActionOverEventCallbackDelegate);
1156                     }
1157
1158                     _accessibilityManagerActionOverEventHandler -= value;
1159                 }
1160             }
1161         }
1162
1163         // Callback for AccessibilityManager ActionOverSignal
1164         private bool OnActionOver(IntPtr data)
1165         {
1166             ActionOverEventArgs e = new ActionOverEventArgs();
1167
1168             // Populate all members of "e" (ActionOverEventArgs) with real data
1169             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1170
1171             if (_accessibilityManagerActionOverEventHandler != null)
1172             {
1173                 //here we send all data to user event handlers
1174                 return _accessibilityManagerActionOverEventHandler(this, e);
1175             }
1176             return false;
1177         }
1178
1179         public event DaliEventHandlerWithReturnType<object, ActionReadNextEventArgs, bool> ActionReadNext
1180         {
1181             add
1182             {
1183                 lock (this)
1184                 {
1185                     // Restricted to only one listener
1186                     if (_accessibilityManagerActionReadNextEventHandler == null)
1187                     {
1188                         _accessibilityManagerActionReadNextEventHandler += value;
1189
1190                         _accessibilityManagerActionReadNextEventCallbackDelegate = new ActionReadNextEventCallbackDelegate(OnActionReadNext);
1191                         this.ActionReadNextSignal().Connect(_accessibilityManagerActionReadNextEventCallbackDelegate);
1192                     }
1193                 }
1194             }
1195
1196             remove
1197             {
1198                 lock (this)
1199                 {
1200                     if (_accessibilityManagerActionReadNextEventHandler != null)
1201                     {
1202                         this.ActionReadNextSignal().Disconnect(_accessibilityManagerActionReadNextEventCallbackDelegate);
1203                     }
1204
1205                     _accessibilityManagerActionReadNextEventHandler -= value;
1206                 }
1207             }
1208         }
1209
1210         // Callback for AccessibilityManager ActionReadNextSignal
1211         private bool OnActionReadNext(IntPtr data)
1212         {
1213             ActionReadNextEventArgs e = new ActionReadNextEventArgs();
1214
1215             // Populate all members of "e" (ActionReadNextEventArgs) with real data
1216             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1217
1218             if (_accessibilityManagerActionReadNextEventHandler != null)
1219             {
1220                 //here we send all data to user event handlers
1221                 return _accessibilityManagerActionReadNextEventHandler(this, e);
1222             }
1223             return false;
1224         }
1225
1226
1227         public event DaliEventHandlerWithReturnType<object, ActionReadPreviousEventArgs, bool> ActionReadPrevious
1228         {
1229             add
1230             {
1231                 lock (this)
1232                 {
1233                     // Restricted to only one listener
1234                     if (_accessibilityManagerActionReadPreviousEventHandler == null)
1235                     {
1236                         _accessibilityManagerActionReadPreviousEventHandler += value;
1237
1238                         _accessibilityManagerActionReadPreviousEventCallbackDelegate = new ActionReadPreviousEventCallbackDelegate(OnActionReadPrevious);
1239                         this.ActionReadPreviousSignal().Connect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
1240                     }
1241                 }
1242             }
1243
1244             remove
1245             {
1246                 lock (this)
1247                 {
1248                     if (_accessibilityManagerActionReadPreviousEventHandler != null)
1249                     {
1250                         this.ActionReadPreviousSignal().Disconnect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
1251                     }
1252
1253                     _accessibilityManagerActionReadPreviousEventHandler -= value;
1254                 }
1255             }
1256         }
1257
1258         // Callback for AccessibilityManager ActionReadPreviousSignal
1259         private bool OnActionReadPrevious(IntPtr data)
1260         {
1261             ActionReadPreviousEventArgs e = new ActionReadPreviousEventArgs();
1262
1263             // Populate all members of "e" (ActionReadPreviousEventArgs) with real data
1264             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1265
1266             if (_accessibilityManagerActionReadPreviousEventHandler != null)
1267             {
1268                 //here we send all data to user event handlers
1269                 return _accessibilityManagerActionReadPreviousEventHandler(this, e);
1270             }
1271             return false;
1272         }
1273
1274         public event DaliEventHandlerWithReturnType<object, ActionUpEventArgs, bool> ActionUp
1275         {
1276             add
1277             {
1278                 lock (this)
1279                 {
1280                     // Restricted to only one listener
1281                     if (_accessibilityManagerActionUpEventHandler == null)
1282                     {
1283                         _accessibilityManagerActionUpEventHandler += value;
1284
1285                         _accessibilityManagerActionUpEventCallbackDelegate = new ActionUpEventCallbackDelegate(OnActionUp);
1286                         this.ActionUpSignal().Connect(_accessibilityManagerActionUpEventCallbackDelegate);
1287                     }
1288                 }
1289             }
1290
1291             remove
1292             {
1293                 lock (this)
1294                 {
1295                     if (_accessibilityManagerActionUpEventHandler != null)
1296                     {
1297                         this.ActionUpSignal().Disconnect(_accessibilityManagerActionUpEventCallbackDelegate);
1298                     }
1299
1300                     _accessibilityManagerActionUpEventHandler -= value;
1301                 }
1302             }
1303         }
1304
1305         // Callback for AccessibilityManager ActionUpSignal
1306         private bool OnActionUp(IntPtr data)
1307         {
1308             ActionUpEventArgs e = new ActionUpEventArgs();
1309
1310             // Populate all members of "e" (ActionUpEventArgs) with real data
1311             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1312
1313             if (_accessibilityManagerActionUpEventHandler != null)
1314             {
1315                 //here we send all data to user event handlers
1316                 return _accessibilityManagerActionUpEventHandler(this, e);
1317             }
1318             return false;
1319         }
1320
1321         public event DaliEventHandlerWithReturnType<object, ActionDownEventArgs, bool> ActionDown
1322         {
1323             add
1324             {
1325                 lock (this)
1326                 {
1327                     // Restricted to only one listener
1328                     if (_accessibilityManagerActionDownEventHandler == null)
1329                     {
1330                         _accessibilityManagerActionDownEventHandler += value;
1331
1332                         _accessibilityManagerActionDownEventCallbackDelegate = new ActionDownEventCallbackDelegate(OnActionDown);
1333                         this.ActionDownSignal().Connect(_accessibilityManagerActionDownEventCallbackDelegate);
1334                     }
1335                 }
1336             }
1337
1338             remove
1339             {
1340                 lock (this)
1341                 {
1342                     if (_accessibilityManagerActionDownEventHandler != null)
1343                     {
1344                         this.ActionDownSignal().Disconnect(_accessibilityManagerActionDownEventCallbackDelegate);
1345                     }
1346
1347                     _accessibilityManagerActionDownEventHandler -= value;
1348                 }
1349             }
1350         }
1351
1352         // Callback for AccessibilityManager ActionDownSignal
1353         private bool OnActionDown(IntPtr data)
1354         {
1355             ActionDownEventArgs e = new ActionDownEventArgs();
1356
1357             // Populate all members of "e" (ActionDownEventArgs) with real data
1358             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1359
1360             if (_accessibilityManagerActionDownEventHandler != null)
1361             {
1362                 //here we send all data to user event handlers
1363                 return _accessibilityManagerActionDownEventHandler(this, e);
1364             }
1365             return false;
1366         }
1367
1368         public event DaliEventHandlerWithReturnType<object, ActionClearFocusEventArgs, bool> ActionClearFocus
1369         {
1370             add
1371             {
1372                 lock (this)
1373                 {
1374                     // Restricted to only one listener
1375                     if (_accessibilityManagerActionClearFocusEventHandler == null)
1376                     {
1377                         _accessibilityManagerActionClearFocusEventHandler += value;
1378
1379                         _accessibilityManagerActionClearFocusEventCallbackDelegate = new ActionClearFocusEventCallbackDelegate(OnActionClearFocus);
1380                         this.ActionClearFocusSignal().Connect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
1381                     }
1382                 }
1383             }
1384
1385             remove
1386             {
1387                 lock (this)
1388                 {
1389                     if (_accessibilityManagerActionClearFocusEventHandler != null)
1390                     {
1391                         this.ActionClearFocusSignal().Disconnect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
1392                     }
1393
1394                     _accessibilityManagerActionClearFocusEventHandler -= value;
1395                 }
1396             }
1397         }
1398
1399         // Callback for AccessibilityManager ActionClearFocusSignal
1400         private bool OnActionClearFocus(IntPtr data)
1401         {
1402             ActionClearFocusEventArgs e = new ActionClearFocusEventArgs();
1403
1404             // Populate all members of "e" (ActionClearFocusEventArgs) with real data
1405             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1406
1407             if (_accessibilityManagerActionClearFocusEventHandler != null)
1408             {
1409                 //here we send all data to user event handlers
1410                 return _accessibilityManagerActionClearFocusEventHandler(this, e);
1411             }
1412             return false;
1413         }
1414
1415         public event DaliEventHandlerWithReturnType<object, ActionBackEventArgs, bool> ActionBack
1416         {
1417             add
1418             {
1419                 lock (this)
1420                 {
1421                     // Restricted to only one listener
1422                     if (_accessibilityManagerActionBackEventHandler == null)
1423                     {
1424                         _accessibilityManagerActionBackEventHandler += value;
1425
1426                         _accessibilityManagerActionBackEventCallbackDelegate = new ActionBackEventCallbackDelegate(OnActionBack);
1427                         this.ActionBackSignal().Connect(_accessibilityManagerActionBackEventCallbackDelegate);
1428                     }
1429                 }
1430             }
1431
1432             remove
1433             {
1434                 lock (this)
1435                 {
1436                     if (_accessibilityManagerActionBackEventHandler != null)
1437                     {
1438                         this.ActionBackSignal().Disconnect(_accessibilityManagerActionBackEventCallbackDelegate);
1439                     }
1440
1441                     _accessibilityManagerActionBackEventHandler -= value;
1442                 }
1443             }
1444         }
1445
1446         // Callback for AccessibilityManager ActionBackSignal
1447         private bool OnActionBack(IntPtr data)
1448         {
1449             ActionBackEventArgs e = new ActionBackEventArgs();
1450
1451             // Populate all members of "e" (ActionBackEventArgs) with real data
1452             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1453
1454             if (_accessibilityManagerActionBackEventHandler != null)
1455             {
1456                 //here we send all data to user event handlers
1457                 return _accessibilityManagerActionBackEventHandler(this, e);
1458             }
1459             return false;
1460         }
1461
1462         public event DaliEventHandlerWithReturnType<object, ActionScrollUpEventArgs, bool> ActionScrollUp
1463         {
1464             add
1465             {
1466                 lock (this)
1467                 {
1468                     // Restricted to only one listener
1469                     if (_accessibilityManagerActionScrollUpEventHandler == null)
1470                     {
1471                         _accessibilityManagerActionScrollUpEventHandler += value;
1472
1473                         _accessibilityManagerActionScrollUpEventCallbackDelegate = new ActionScrollUpEventCallbackDelegate(OnActionScrollUp);
1474                         this.ActionScrollUpSignal().Connect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
1475                     }
1476                 }
1477             }
1478
1479             remove
1480             {
1481                 lock (this)
1482                 {
1483                     if (_accessibilityManagerActionScrollUpEventHandler != null)
1484                     {
1485                         this.ActionScrollUpSignal().Disconnect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
1486                     }
1487
1488                     _accessibilityManagerActionScrollUpEventHandler -= value;
1489                 }
1490             }
1491         }
1492
1493         // Callback for AccessibilityManager ActionScrollUpSignal
1494         private bool OnActionScrollUp(IntPtr data)
1495         {
1496             ActionScrollUpEventArgs e = new ActionScrollUpEventArgs();
1497
1498             // Populate all members of "e" (ActionScrollUpEventArgs) with real data
1499             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1500
1501             if (_accessibilityManagerActionScrollUpEventHandler != null)
1502             {
1503                 //here we send all data to user event handlers
1504                 return _accessibilityManagerActionScrollUpEventHandler(this, e);
1505             }
1506             return false;
1507         }
1508
1509         public event DaliEventHandlerWithReturnType<object, ActionScrollDownEventArgs, bool> ActionScrollDown
1510         {
1511             add
1512             {
1513                 lock (this)
1514                 {
1515                     // Restricted to only one listener
1516                     if (_accessibilityManagerActionScrollDownEventHandler == null)
1517                     {
1518                         _accessibilityManagerActionScrollDownEventHandler += value;
1519
1520                         _accessibilityManagerActionScrollDownEventCallbackDelegate = new ActionScrollDownEventCallbackDelegate(OnActionScrollDown);
1521                         this.ActionScrollDownSignal().Connect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
1522                     }
1523                 }
1524             }
1525
1526             remove
1527             {
1528                 lock (this)
1529                 {
1530                     if (_accessibilityManagerActionScrollDownEventHandler != null)
1531                     {
1532                         this.ActionScrollDownSignal().Disconnect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
1533                     }
1534
1535                     _accessibilityManagerActionScrollDownEventHandler -= value;
1536                 }
1537             }
1538         }
1539
1540         // Callback for AccessibilityManager ActionScrollDownSignal
1541         private bool OnActionScrollDown(IntPtr data)
1542         {
1543             ActionScrollDownEventArgs e = new ActionScrollDownEventArgs();
1544
1545             // Populate all members of "e" (ActionScrollDownEventArgs) with real data
1546             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1547
1548             if (_accessibilityManagerActionScrollDownEventHandler != null)
1549             {
1550                 //here we send all data to user event handlers
1551                 return _accessibilityManagerActionScrollDownEventHandler(this, e);
1552             }
1553             return false;
1554         }
1555
1556
1557         public event DaliEventHandlerWithReturnType<object, ActionPageLeftEventArgs, bool> ActionPageLeft
1558         {
1559             add
1560             {
1561                 lock (this)
1562                 {
1563                     // Restricted to only one listener
1564                     if (_accessibilityManagerActionPageLeftEventHandler == null)
1565                     {
1566                         _accessibilityManagerActionPageLeftEventHandler += value;
1567
1568                         _accessibilityManagerActionPageLeftEventCallbackDelegate = new ActionPageLeftEventCallbackDelegate(OnActionPageLeft);
1569                         this.ActionPageLeftSignal().Connect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
1570                     }
1571                 }
1572             }
1573
1574             remove
1575             {
1576                 lock (this)
1577                 {
1578                     if (_accessibilityManagerActionPageLeftEventHandler != null)
1579                     {
1580                         this.ActionPageLeftSignal().Disconnect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
1581                     }
1582
1583                     _accessibilityManagerActionPageLeftEventHandler -= value;
1584                 }
1585             }
1586         }
1587
1588         // Callback for AccessibilityManager ActionPageLeftSignal
1589         private bool OnActionPageLeft(IntPtr data)
1590         {
1591             ActionPageLeftEventArgs e = new ActionPageLeftEventArgs();
1592
1593             // Populate all members of "e" (ActionPageLeftEventArgs) with real data
1594             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1595
1596             if (_accessibilityManagerActionPageLeftEventHandler != null)
1597             {
1598                 //here we send all data to user event handlers
1599                 return _accessibilityManagerActionPageLeftEventHandler(this, e);
1600             }
1601             return false;
1602         }
1603
1604         public event DaliEventHandlerWithReturnType<object, ActionPageRightEventArgs, bool> ActionPageRight
1605         {
1606             add
1607             {
1608                 lock (this)
1609                 {
1610                     // Restricted to only one listener
1611                     if (_accessibilityManagerActionPageRightEventHandler == null)
1612                     {
1613                         _accessibilityManagerActionPageRightEventHandler += value;
1614
1615                         _accessibilityManagerActionPageRightEventCallbackDelegate = new ActionPageRightEventCallbackDelegate(OnActionPageRight);
1616                         this.ActionPageRightSignal().Connect(_accessibilityManagerActionPageRightEventCallbackDelegate);
1617                     }
1618                 }
1619             }
1620
1621             remove
1622             {
1623                 lock (this)
1624                 {
1625                     if (_accessibilityManagerActionPageRightEventHandler != null)
1626                     {
1627                         this.ActionPageRightSignal().Disconnect(_accessibilityManagerActionPageRightEventCallbackDelegate);
1628                     }
1629
1630                     _accessibilityManagerActionPageRightEventHandler -= value;
1631                 }
1632             }
1633         }
1634
1635         // Callback for AccessibilityManager ActionPageRightSignal
1636         private bool OnActionPageRight(IntPtr data)
1637         {
1638             ActionPageRightEventArgs e = new ActionPageRightEventArgs();
1639
1640             // Populate all members of "e" (ActionPageRightEventArgs) with real data
1641             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1642
1643             if (_accessibilityManagerActionPageRightEventHandler != null)
1644             {
1645                 //here we send all data to user event handlers
1646                 return _accessibilityManagerActionPageRightEventHandler(this, e);
1647             }
1648             return false;
1649         }
1650
1651         public event DaliEventHandlerWithReturnType<object, ActionPageUpEventArgs, bool> ActionPageUp
1652         {
1653             add
1654             {
1655                 lock (this)
1656                 {
1657                     // Restricted to only one listener
1658                     if (_accessibilityManagerActionPageUpEventHandler == null)
1659                     {
1660                         _accessibilityManagerActionPageUpEventHandler += value;
1661
1662                         _accessibilityManagerActionPageUpEventCallbackDelegate = new ActionPageUpEventCallbackDelegate(OnActionPageUp);
1663                         this.ActionPageUpSignal().Connect(_accessibilityManagerActionPageUpEventCallbackDelegate);
1664                     }
1665                 }
1666             }
1667
1668             remove
1669             {
1670                 lock (this)
1671                 {
1672                     if (_accessibilityManagerActionPageUpEventHandler != null)
1673                     {
1674                         this.ActionPageUpSignal().Disconnect(_accessibilityManagerActionPageUpEventCallbackDelegate);
1675                     }
1676
1677                     _accessibilityManagerActionPageUpEventHandler -= value;
1678                 }
1679             }
1680         }
1681
1682         // Callback for AccessibilityManager ActionPageUpSignal
1683         private bool OnActionPageUp(IntPtr data)
1684         {
1685             ActionPageUpEventArgs e = new ActionPageUpEventArgs();
1686
1687             // Populate all members of "e" (ActionPageUpEventArgs) with real data
1688             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1689
1690             if (_accessibilityManagerActionPageUpEventHandler != null)
1691             {
1692                 //here we send all data to user event handlers
1693                 return _accessibilityManagerActionPageUpEventHandler(this, e);
1694             }
1695             return false;
1696         }
1697
1698
1699         public event DaliEventHandlerWithReturnType<object, ActionPageDownEventArgs, bool> ActionPageDown
1700         {
1701             add
1702             {
1703                 lock (this)
1704                 {
1705                     // Restricted to only one listener
1706                     if (_accessibilityManagerActionPageDownEventHandler == null)
1707                     {
1708                         _accessibilityManagerActionPageDownEventHandler += value;
1709
1710                         _accessibilityManagerActionPageDownEventCallbackDelegate = new ActionPageDownEventCallbackDelegate(OnActionPageDown);
1711                         this.ActionPageDownSignal().Connect(_accessibilityManagerActionPageDownEventCallbackDelegate);
1712                     }
1713                 }
1714             }
1715
1716             remove
1717             {
1718                 lock (this)
1719                 {
1720                     if (_accessibilityManagerActionPageDownEventHandler != null)
1721                     {
1722                         this.ActionPageDownSignal().Disconnect(_accessibilityManagerActionPageDownEventCallbackDelegate);
1723                     }
1724
1725                     _accessibilityManagerActionPageDownEventHandler -= value;
1726                 }
1727             }
1728         }
1729
1730         // Callback for AccessibilityManager ActionPageDownSignal
1731         private bool OnActionPageDown(IntPtr data)
1732         {
1733             ActionPageDownEventArgs e = new ActionPageDownEventArgs();
1734
1735             // Populate all members of "e" (ActionPageDownEventArgs) with real data
1736             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1737
1738             if (_accessibilityManagerActionPageDownEventHandler != null)
1739             {
1740                 //here we send all data to user event handlers
1741                 return _accessibilityManagerActionPageDownEventHandler(this, e);
1742             }
1743             return false;
1744         }
1745
1746
1747         public event DaliEventHandlerWithReturnType<object, ActionMoveToFirstEventArgs, bool> ActionMoveToFirst
1748         {
1749             add
1750             {
1751                 lock (this)
1752                 {
1753                     // Restricted to only one listener
1754                     if (_accessibilityManagerActionMoveToFirstEventHandler == null)
1755                     {
1756                         _accessibilityManagerActionMoveToFirstEventHandler += value;
1757
1758                         _accessibilityManagerActionMoveToFirstEventCallbackDelegate = new ActionMoveToFirstEventCallbackDelegate(OnActionMoveToFirst);
1759                         this.ActionMoveToFirstSignal().Connect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
1760                     }
1761                 }
1762             }
1763
1764             remove
1765             {
1766                 lock (this)
1767                 {
1768                     if (_accessibilityManagerActionMoveToFirstEventHandler != null)
1769                     {
1770                         this.ActionMoveToFirstSignal().Disconnect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
1771                     }
1772
1773                     _accessibilityManagerActionMoveToFirstEventHandler -= value;
1774                 }
1775             }
1776         }
1777
1778         // Callback for AccessibilityManager ActionMoveToFirstSignal
1779         private bool OnActionMoveToFirst(IntPtr data)
1780         {
1781             ActionMoveToFirstEventArgs e = new ActionMoveToFirstEventArgs();
1782
1783             // Populate all members of "e" (ActionMoveToFirstEventArgs) with real data
1784             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1785
1786             if (_accessibilityManagerActionMoveToFirstEventHandler != null)
1787             {
1788                 //here we send all data to user event handlers
1789                 return _accessibilityManagerActionMoveToFirstEventHandler(this, e);
1790             }
1791             return false;
1792         }
1793
1794         public event DaliEventHandlerWithReturnType<object, ActionMoveToLastEventArgs, bool> ActionMoveToLast
1795         {
1796             add
1797             {
1798                 lock (this)
1799                 {
1800                     // Restricted to only one listener
1801                     if (_accessibilityManagerActionMoveToLastEventHandler == null)
1802                     {
1803                         _accessibilityManagerActionMoveToLastEventHandler += value;
1804
1805                         _accessibilityManagerActionMoveToLastEventCallbackDelegate = new ActionMoveToLastEventCallbackDelegate(OnActionMoveToLast);
1806                         this.ActionMoveToLastSignal().Connect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
1807                     }
1808                 }
1809             }
1810
1811             remove
1812             {
1813                 lock (this)
1814                 {
1815                     if (_accessibilityManagerActionMoveToLastEventHandler != null)
1816                     {
1817                         this.ActionMoveToLastSignal().Disconnect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
1818                     }
1819
1820                     _accessibilityManagerActionMoveToLastEventHandler -= value;
1821                 }
1822             }
1823         }
1824
1825         // Callback for AccessibilityManager ActionMoveToLastSignal
1826         private bool OnActionMoveToLast(IntPtr data)
1827         {
1828             ActionMoveToLastEventArgs e = new ActionMoveToLastEventArgs();
1829
1830             // Populate all members of "e" (ActionMoveToLastEventArgs) with real data
1831             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1832
1833             if (_accessibilityManagerActionMoveToLastEventHandler != null)
1834             {
1835                 //here we send all data to user event handlers
1836                 return _accessibilityManagerActionMoveToLastEventHandler(this, e);
1837             }
1838             return false;
1839         }
1840
1841         public event DaliEventHandlerWithReturnType<object, ActionReadFromTopEventArgs, bool> ActionReadFromTop
1842         {
1843             add
1844             {
1845                 lock (this)
1846                 {
1847                     // Restricted to only one listener
1848                     if (_accessibilityManagerActionReadFromTopEventHandler == null)
1849                     {
1850                         _accessibilityManagerActionReadFromTopEventHandler += value;
1851
1852                         _accessibilityManagerActionReadFromTopEventCallbackDelegate = new ActionReadFromTopEventCallbackDelegate(OnActionReadFromTop);
1853                         this.ActionReadFromTopSignal().Connect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
1854                     }
1855                 }
1856             }
1857
1858             remove
1859             {
1860                 lock (this)
1861                 {
1862                     if (_accessibilityManagerActionReadFromTopEventHandler != null)
1863                     {
1864                         this.ActionReadFromTopSignal().Disconnect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
1865                     }
1866
1867                     _accessibilityManagerActionReadFromTopEventHandler -= value;
1868                 }
1869             }
1870         }
1871
1872         // Callback for AccessibilityManager ActionReadFromTopSignal
1873         private bool OnActionReadFromTop(IntPtr data)
1874         {
1875             ActionReadFromTopEventArgs e = new ActionReadFromTopEventArgs();
1876
1877             // Populate all members of "e" (ActionReadFromTopEventArgs) with real data
1878             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1879
1880             if (_accessibilityManagerActionReadFromTopEventHandler != null)
1881             {
1882                 //here we send all data to user event handlers
1883                 return _accessibilityManagerActionReadFromTopEventHandler(this, e);
1884             }
1885             return false;
1886         }
1887
1888         public event DaliEventHandlerWithReturnType<object, ActionReadFromNextEventArgs, bool> ActionReadFromNext
1889         {
1890             add
1891             {
1892                 lock (this)
1893                 {
1894                     // Restricted to only one listener
1895                     if (_accessibilityManagerActionReadFromNextEventHandler == null)
1896                     {
1897                         _accessibilityManagerActionReadFromNextEventHandler += value;
1898
1899                         _accessibilityManagerActionReadFromNextEventCallbackDelegate = new ActionReadFromNextEventCallbackDelegate(OnActionReadFromNext);
1900                         this.ActionReadFromNextSignal().Connect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
1901                     }
1902                 }
1903             }
1904
1905             remove
1906             {
1907                 lock (this)
1908                 {
1909                     if (_accessibilityManagerActionReadFromNextEventHandler != null)
1910                     {
1911                         this.ActionReadFromNextSignal().Disconnect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
1912                     }
1913
1914                     _accessibilityManagerActionReadFromNextEventHandler -= value;
1915                 }
1916             }
1917         }
1918
1919         // Callback for AccessibilityManager ActionReadFromNextSignal
1920         private bool OnActionReadFromNext(IntPtr data)
1921         {
1922             ActionReadFromNextEventArgs e = new ActionReadFromNextEventArgs();
1923
1924             // Populate all members of "e" (ActionReadFromNextEventArgs) with real data
1925             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1926
1927             if (_accessibilityManagerActionReadFromNextEventHandler != null)
1928             {
1929                 //here we send all data to user event handlers
1930                 return _accessibilityManagerActionReadFromNextEventHandler(this, e);
1931             }
1932             return false;
1933         }
1934
1935         public event DaliEventHandlerWithReturnType<object, ActionZoomEventArgs, bool> ActionZoom
1936         {
1937             add
1938             {
1939                 lock (this)
1940                 {
1941                     // Restricted to only one listener
1942                     if (_accessibilityManagerActionZoomEventHandler == null)
1943                     {
1944                         _accessibilityManagerActionZoomEventHandler += value;
1945
1946                         _accessibilityManagerActionZoomEventCallbackDelegate = new ActionZoomEventCallbackDelegate(OnActionZoom);
1947                         this.ActionZoomSignal().Connect(_accessibilityManagerActionZoomEventCallbackDelegate);
1948                     }
1949                 }
1950             }
1951
1952             remove
1953             {
1954                 lock (this)
1955                 {
1956                     if (_accessibilityManagerActionZoomEventHandler != null)
1957                     {
1958                         this.ActionZoomSignal().Disconnect(_accessibilityManagerActionZoomEventCallbackDelegate);
1959                     }
1960
1961                     _accessibilityManagerActionZoomEventHandler -= value;
1962                 }
1963             }
1964         }
1965
1966         // Callback for AccessibilityManager ActionZoomSignal
1967         private bool OnActionZoom(IntPtr data)
1968         {
1969             ActionZoomEventArgs e = new ActionZoomEventArgs();
1970
1971             // Populate all members of "e" (ActionZoomEventArgs) with real data
1972             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1973
1974             if (_accessibilityManagerActionZoomEventHandler != null)
1975             {
1976                 //here we send all data to user event handlers
1977                 return _accessibilityManagerActionZoomEventHandler(this, e);
1978             }
1979             return false;
1980         }
1981
1982         public event DaliEventHandlerWithReturnType<object, ActionReadIndicatorInformationEventArgs, bool> ActionReadIndicatorInformation
1983         {
1984             add
1985             {
1986                 lock (this)
1987                 {
1988                     // Restricted to only one listener
1989                     if (_accessibilityManagerActionReadIndicatorInformationEventHandler == null)
1990                     {
1991                         _accessibilityManagerActionReadIndicatorInformationEventHandler += value;
1992
1993                         _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate = new ActionReadIndicatorInformationEventCallbackDelegate(OnActionReadIndicatorInformation);
1994                         this.ActionReadIndicatorInformationSignal().Connect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
1995                     }
1996                 }
1997             }
1998
1999             remove
2000             {
2001                 lock (this)
2002                 {
2003                     if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
2004                     {
2005                         this.ActionReadIndicatorInformationSignal().Disconnect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
2006                     }
2007
2008                     _accessibilityManagerActionReadIndicatorInformationEventHandler -= value;
2009                 }
2010             }
2011         }
2012
2013         // Callback for AccessibilityManager ActionReadIndicatorInformationSignal
2014         private bool OnActionReadIndicatorInformation(IntPtr data)
2015         {
2016             ActionReadIndicatorInformationEventArgs e = new ActionReadIndicatorInformationEventArgs();
2017
2018             // Populate all members of "e" (ActionReadIndicatorInformationEventArgs) with real data
2019             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2020
2021             if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
2022             {
2023                 //here we send all data to user event handlers
2024                 return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e);
2025             }
2026             return false;
2027         }
2028
2029         public event DaliEventHandlerWithReturnType<object, ActionReadPauseResumeEventArgs, bool> ActionReadPauseResume
2030         {
2031             add
2032             {
2033                 lock (this)
2034                 {
2035                     // Restricted to only one listener
2036                     if (_accessibilityManagerActionReadPauseResumeEventHandler == null)
2037                     {
2038                         _accessibilityManagerActionReadPauseResumeEventHandler += value;
2039
2040                         _accessibilityManagerActionReadPauseResumeEventCallbackDelegate = new ActionReadPauseResumeEventCallbackDelegate(OnActionReadPauseResume);
2041                         this.ActionReadPauseResumeSignal().Connect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
2042                     }
2043                 }
2044             }
2045
2046             remove
2047             {
2048                 lock (this)
2049                 {
2050                     if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
2051                     {
2052                         this.ActionReadPauseResumeSignal().Disconnect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
2053                     }
2054
2055                     _accessibilityManagerActionReadPauseResumeEventHandler -= value;
2056                 }
2057             }
2058         }
2059
2060         // Callback for AccessibilityManager ActionReadPauseResumeSignal
2061         private bool OnActionReadPauseResume(IntPtr data)
2062         {
2063             ActionReadPauseResumeEventArgs e = new ActionReadPauseResumeEventArgs();
2064
2065             // Populate all members of "e" (ActionReadPauseResumeEventArgs) with real data
2066             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2067
2068             if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
2069             {
2070                 //here we send all data to user event handlers
2071                 return _accessibilityManagerActionReadPauseResumeEventHandler(this, e);
2072             }
2073             return false;
2074         }
2075
2076         public event DaliEventHandlerWithReturnType<object, ActionStartStopEventArgs, bool> ActionStartStop
2077         {
2078             add
2079             {
2080                 lock (this)
2081                 {
2082                     // Restricted to only one listener
2083                     if (_accessibilityManagerActionStartStopEventHandler == null)
2084                     {
2085                         _accessibilityManagerActionStartStopEventHandler += value;
2086
2087                         _accessibilityManagerActionStartStopEventCallbackDelegate = new ActionStartStopEventCallbackDelegate(OnActionStartStop);
2088                         this.ActionStartStopSignal().Connect(_accessibilityManagerActionStartStopEventCallbackDelegate);
2089                     }
2090                 }
2091             }
2092
2093             remove
2094             {
2095                 lock (this)
2096                 {
2097                     if (_accessibilityManagerActionStartStopEventHandler != null)
2098                     {
2099                         this.ActionStartStopSignal().Disconnect(_accessibilityManagerActionStartStopEventCallbackDelegate);
2100                     }
2101
2102                     _accessibilityManagerActionStartStopEventHandler -= value;
2103                 }
2104             }
2105         }
2106
2107         // Callback for AccessibilityManager ActionStartStopSignal
2108         private bool OnActionStartStop(IntPtr data)
2109         {
2110             ActionStartStopEventArgs e = new ActionStartStopEventArgs();
2111
2112             // Populate all members of "e" (ActionStartStopEventArgs) with real data
2113             e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2114
2115             if (_accessibilityManagerActionStartStopEventHandler != null)
2116             {
2117                 //here we send all data to user event handlers
2118                 return _accessibilityManagerActionStartStopEventHandler(this, e);
2119             }
2120             return false;
2121         }
2122
2123         /*
2124             // To be replaced by a new event that takes Touch
2125             public event DaliEventHandlerWithReturnType<object,ActionScrollEventArgs,bool> ActionScroll
2126             {
2127               add
2128               {
2129                 lock(this)
2130                 {
2131                   // Restricted to only one listener
2132                   if (_accessibilityManagerActionScrollEventHandler == null)
2133                   {
2134                     _accessibilityManagerActionScrollEventHandler += value;
2135
2136                     _accessibilityManagerActionScrollEventCallbackDelegate = new ActionScrollEventCallbackDelegate(OnActionScroll);
2137                     this.ActionScrollSignal().Connect(_accessibilityManagerActionScrollEventCallbackDelegate);
2138                   }
2139                 }
2140               }
2141
2142               remove
2143               {
2144                 lock(this)
2145                 {
2146                   if (_accessibilityManagerActionScrollEventHandler != null)
2147                   {
2148                     this.ActionScrollSignal().Disconnect(_accessibilityManagerActionScrollEventCallbackDelegate);
2149                   }
2150
2151                   _accessibilityManagerActionScrollEventHandler -= value;
2152                 }
2153               }
2154             }
2155
2156             // Callback for AccessibilityManager ActionScrollSignal
2157             private bool OnActionScroll(IntPtr accessibilityManager, IntPtr touchEvent)
2158             {
2159               ActionScrollEventArgs e = new ActionScrollEventArgs();
2160
2161               // Populate all members of "e" (ActionScrollEventArgs) with real data
2162               e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(accessibilityManager);
2163               e.TouchEvent = TouchEvent.GetTouchEventFromPtr(touchEvent);
2164
2165               if (_accessibilityManagerActionScrollEventHandler != null)
2166               {
2167                 //here we send all data to user event handlers
2168                 return _accessibilityManagerActionScrollEventHandler(this, e);
2169               }
2170               return false;
2171             }
2172         */
2173
2174         public event DaliEventHandler<object, FocusChangedEventArgs> FocusChanged
2175         {
2176             add
2177             {
2178                 lock (this)
2179                 {
2180                     // Restricted to only one listener
2181                     if (_accessibilityManagerFocusChangedEventHandler == null)
2182                     {
2183                         _accessibilityManagerFocusChangedEventHandler += value;
2184
2185                         _accessibilityManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
2186                         this.FocusChangedSignal().Connect(_accessibilityManagerFocusChangedEventCallbackDelegate);
2187                     }
2188                 }
2189             }
2190
2191             remove
2192             {
2193                 lock (this)
2194                 {
2195                     if (_accessibilityManagerFocusChangedEventHandler != null)
2196                     {
2197                         this.FocusChangedSignal().Disconnect(_accessibilityManagerFocusChangedEventCallbackDelegate);
2198                     }
2199
2200                     _accessibilityManagerFocusChangedEventHandler -= value;
2201                 }
2202             }
2203         }
2204
2205         // Callback for AccessibilityManager FocusChangedSignal
2206         private void OnFocusChanged(IntPtr view1, IntPtr view2)
2207         {
2208             FocusChangedEventArgs e = new FocusChangedEventArgs();
2209
2210             // Populate all members of "e" (FocusChangedEventArgs) with real data
2211             e.ViewCurrent = Registry.GetManagedBaseHandleFromNativePtr(view1) as View;
2212             e.ViewNext = Registry.GetManagedBaseHandleFromNativePtr(view2) as View;
2213
2214             if (_accessibilityManagerFocusChangedEventHandler != null)
2215             {
2216                 //here we send all data to user event handlers
2217                 _accessibilityManagerFocusChangedEventHandler(this, e);
2218             }
2219         }
2220
2221         public event DaliEventHandler<object, FocusedViewActivatedEventArgs> FocusedViewActivated
2222         {
2223             add
2224             {
2225                 lock (this)
2226                 {
2227                     // Restricted to only one listener
2228                     if (_accessibilityManagerFocusedViewActivatedEventHandler == null)
2229                     {
2230                         _accessibilityManagerFocusedViewActivatedEventHandler += value;
2231
2232                         _accessibilityManagerFocusedViewActivatedEventCallbackDelegate = new FocusedViewActivatedEventCallbackDelegate(OnFocusedViewActivated);
2233                         this.FocusedViewActivatedSignal().Connect(_accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
2234                     }
2235                 }
2236             }
2237
2238             remove
2239             {
2240                 lock (this)
2241                 {
2242                     if (_accessibilityManagerFocusedViewActivatedEventHandler != null)
2243                     {
2244                         this.FocusedViewActivatedSignal().Disconnect(_accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
2245                     }
2246
2247                     _accessibilityManagerFocusedViewActivatedEventHandler -= value;
2248                 }
2249             }
2250         }
2251
2252         // Callback for AccessibilityManager FocusedViewActivatedSignal
2253         private void OnFocusedViewActivated(IntPtr view)
2254         {
2255             FocusedViewActivatedEventArgs e = new FocusedViewActivatedEventArgs();
2256
2257             // Populate all members of "e" (FocusedViewActivatedEventArgs) with real data
2258             e.View = Registry.GetManagedBaseHandleFromNativePtr(view) as View;
2259
2260             if (_accessibilityManagerFocusedViewActivatedEventHandler != null)
2261             {
2262                 //here we send all data to user event handlers
2263                 _accessibilityManagerFocusedViewActivatedEventHandler(this, e);
2264             }
2265         }
2266
2267
2268         public event DaliEventHandler<object, FocusOvershotEventArgs> FocusOvershot
2269         {
2270             add
2271             {
2272                 lock (this)
2273                 {
2274                     // Restricted to only one listener
2275                     if (_accessibilityManagerFocusOvershotEventHandler == null)
2276                     {
2277                         _accessibilityManagerFocusOvershotEventHandler += value;
2278
2279                         _accessibilityManagerFocusOvershotEventCallbackDelegate = new FocusOvershotEventCallbackDelegate(OnFocusOvershot);
2280                         this.FocusOvershotSignal().Connect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
2281                     }
2282                 }
2283             }
2284
2285             remove
2286             {
2287                 lock (this)
2288                 {
2289                     if (_accessibilityManagerFocusOvershotEventHandler != null)
2290                     {
2291                         this.FocusOvershotSignal().Disconnect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
2292                     }
2293
2294                     _accessibilityManagerFocusOvershotEventHandler -= value;
2295                 }
2296             }
2297         }
2298
2299         // Callback for AccessibilityManager FocusOvershotSignal
2300         private void OnFocusOvershot(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction)
2301         {
2302             FocusOvershotEventArgs e = new FocusOvershotEventArgs();
2303
2304             // Populate all members of "e" (FocusOvershotEventArgs) with real data
2305             e.CurrentFocusedView = Registry.GetManagedBaseHandleFromNativePtr(currentFocusedView) as View;
2306             e.FocusOvershotDirection = direction;
2307
2308             if (_accessibilityManagerFocusOvershotEventHandler != null)
2309             {
2310                 //here we send all data to user event handlers
2311                 _accessibilityManagerFocusOvershotEventHandler(this, e);
2312             }
2313         }
2314
2315
2316         public static AccessibilityManager GetAccessibilityManagerFromPtr(global::System.IntPtr cPtr)
2317         {
2318             AccessibilityManager ret = new AccessibilityManager(cPtr, false);
2319             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2320             return ret;
2321         }
2322
2323
2324         public AccessibilityManager() : this(NDalicPINVOKE.new_AccessibilityManager(), true)
2325         {
2326             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2327         }
2328
2329         public static AccessibilityManager Get()
2330         {
2331             AccessibilityManager ret = new AccessibilityManager(NDalicPINVOKE.AccessibilityManager_Get(), true);
2332             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2333             return ret;
2334         }
2335
2336         public void SetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type, string text)
2337         {
2338             NDalicPINVOKE.AccessibilityManager_SetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type, text);
2339             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2340         }
2341
2342         public string GetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type)
2343         {
2344             string ret = NDalicPINVOKE.AccessibilityManager_GetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type);
2345             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2346             return ret;
2347         }
2348
2349         public void SetFocusOrder(View view, uint order)
2350         {
2351             NDalicPINVOKE.AccessibilityManager_SetFocusOrder(swigCPtr, View.getCPtr(view), order);
2352             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2353         }
2354
2355         public uint GetFocusOrder(View view)
2356         {
2357             uint ret = NDalicPINVOKE.AccessibilityManager_GetFocusOrder(swigCPtr, View.getCPtr(view));
2358             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2359             return ret;
2360         }
2361
2362         public uint GenerateNewFocusOrder()
2363         {
2364             uint ret = NDalicPINVOKE.AccessibilityManager_GenerateNewFocusOrder(swigCPtr);
2365             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2366             return ret;
2367         }
2368
2369         public View GetViewByFocusOrder(uint order)
2370         {
2371             View ret = new View(NDalicPINVOKE.AccessibilityManager_GetActorByFocusOrder(swigCPtr, order), true);
2372             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2373             return ret;
2374         }
2375
2376         public bool SetCurrentFocusView(View view)
2377         {
2378             bool ret = NDalicPINVOKE.AccessibilityManager_SetCurrentFocusActor(swigCPtr, View.getCPtr(view));
2379             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2380             return ret;
2381         }
2382
2383         public View GetCurrentFocusView()
2384         {
2385             View ret = new View(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusActor(swigCPtr), true);
2386             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2387             return ret;
2388         }
2389
2390         public View GetCurrentFocusGroup()
2391         {
2392             View ret = new View(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusGroup(swigCPtr), true);
2393             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2394             return ret;
2395         }
2396
2397         public uint GetCurrentFocusOrder()
2398         {
2399             uint ret = NDalicPINVOKE.AccessibilityManager_GetCurrentFocusOrder(swigCPtr);
2400             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2401             return ret;
2402         }
2403
2404         public bool MoveFocusForward()
2405         {
2406             bool ret = NDalicPINVOKE.AccessibilityManager_MoveFocusForward(swigCPtr);
2407             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2408             return ret;
2409         }
2410
2411         public bool MoveFocusBackward()
2412         {
2413             bool ret = NDalicPINVOKE.AccessibilityManager_MoveFocusBackward(swigCPtr);
2414             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2415             return ret;
2416         }
2417
2418         public void ClearFocus()
2419         {
2420             NDalicPINVOKE.AccessibilityManager_ClearFocus(swigCPtr);
2421             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2422         }
2423
2424         public new void Reset()
2425         {
2426             NDalicPINVOKE.AccessibilityManager_Reset(swigCPtr);
2427             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2428         }
2429
2430         public void SetFocusGroup(View view, bool isFocusGroup)
2431         {
2432             NDalicPINVOKE.AccessibilityManager_SetFocusGroup(swigCPtr, View.getCPtr(view), isFocusGroup);
2433             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2434         }
2435
2436         public bool IsFocusGroup(View view)
2437         {
2438             bool ret = NDalicPINVOKE.AccessibilityManager_IsFocusGroup(swigCPtr, View.getCPtr(view));
2439             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2440             return ret;
2441         }
2442
2443         public void SetGroupMode(bool enabled)
2444         {
2445             NDalicPINVOKE.AccessibilityManager_SetGroupMode(swigCPtr, enabled);
2446             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2447         }
2448
2449         public bool GetGroupMode()
2450         {
2451             bool ret = NDalicPINVOKE.AccessibilityManager_GetGroupMode(swigCPtr);
2452             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2453             return ret;
2454         }
2455
2456         public void SetWrapMode(bool wrapped)
2457         {
2458             NDalicPINVOKE.AccessibilityManager_SetWrapMode(swigCPtr, wrapped);
2459             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2460         }
2461
2462         public bool GetWrapMode()
2463         {
2464             bool ret = NDalicPINVOKE.AccessibilityManager_GetWrapMode(swigCPtr);
2465             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2466             return ret;
2467         }
2468
2469         public void SetFocusIndicatorView(View indicator)
2470         {
2471             NDalicPINVOKE.AccessibilityManager_SetFocusIndicatorActor(swigCPtr, View.getCPtr(indicator));
2472             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2473         }
2474
2475         public View GetFocusIndicatorView()
2476         {
2477             View ret = new View(NDalicPINVOKE.AccessibilityManager_GetFocusIndicatorActor(swigCPtr), true);
2478             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2479             return ret;
2480         }
2481
2482         public View GetFocusGroup(View view)
2483         {
2484             View ret = new View(NDalicPINVOKE.AccessibilityManager_GetFocusGroup(swigCPtr, View.getCPtr(view)), true);
2485             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2486             return ret;
2487         }
2488
2489         public Vector2 GetReadPosition()
2490         {
2491             Vector2 ret = new Vector2(NDalicPINVOKE.AccessibilityManager_GetReadPosition(swigCPtr), true);
2492             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2493             return ret;
2494         }
2495
2496         public FocusChangedSignal FocusChangedSignal()
2497         {
2498             FocusChangedSignal ret = new FocusChangedSignal(NDalicPINVOKE.AccessibilityManager_FocusChangedSignal(swigCPtr), false);
2499             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2500             return ret;
2501         }
2502
2503         public AccessibilityFocusOvershotSignal FocusOvershotSignal()
2504         {
2505             AccessibilityFocusOvershotSignal ret = new AccessibilityFocusOvershotSignal(NDalicPINVOKE.AccessibilityManager_FocusOvershotSignal(swigCPtr), false);
2506             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2507             return ret;
2508         }
2509
2510         public ViewSignal FocusedViewActivatedSignal()
2511         {
2512             ViewSignal ret = new ViewSignal(NDalicPINVOKE.AccessibilityManager_FocusedActorActivatedSignal(swigCPtr), false);
2513             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2514             return ret;
2515         }
2516
2517         public AccessibilityActionSignal StatusChangedSignal()
2518         {
2519             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_StatusChangedSignal(swigCPtr), false);
2520             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2521             return ret;
2522         }
2523
2524         public AccessibilityActionSignal ActionNextSignal()
2525         {
2526             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionNextSignal(swigCPtr), false);
2527             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2528             return ret;
2529         }
2530
2531         public AccessibilityActionSignal ActionPreviousSignal()
2532         {
2533             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPreviousSignal(swigCPtr), false);
2534             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2535             return ret;
2536         }
2537
2538         public AccessibilityActionSignal ActionActivateSignal()
2539         {
2540             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionActivateSignal(swigCPtr), false);
2541             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2542             return ret;
2543         }
2544
2545         public AccessibilityActionSignal ActionReadSignal()
2546         {
2547             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadSignal(swigCPtr), false);
2548             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2549             return ret;
2550         }
2551
2552         public AccessibilityActionSignal ActionOverSignal()
2553         {
2554             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionOverSignal(swigCPtr), false);
2555             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2556             return ret;
2557         }
2558
2559         public AccessibilityActionSignal ActionReadNextSignal()
2560         {
2561             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadNextSignal(swigCPtr), false);
2562             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2563             return ret;
2564         }
2565
2566         public AccessibilityActionSignal ActionReadPreviousSignal()
2567         {
2568             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadPreviousSignal(swigCPtr), false);
2569             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2570             return ret;
2571         }
2572
2573         public AccessibilityActionSignal ActionUpSignal()
2574         {
2575             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionUpSignal(swigCPtr), false);
2576             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2577             return ret;
2578         }
2579
2580         public AccessibilityActionSignal ActionDownSignal()
2581         {
2582             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionDownSignal(swigCPtr), false);
2583             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2584             return ret;
2585         }
2586
2587         public AccessibilityActionSignal ActionClearFocusSignal()
2588         {
2589             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionClearFocusSignal(swigCPtr), false);
2590             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2591             return ret;
2592         }
2593
2594         public AccessibilityActionSignal ActionBackSignal()
2595         {
2596             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionBackSignal(swigCPtr), false);
2597             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2598             return ret;
2599         }
2600
2601         public AccessibilityActionSignal ActionScrollUpSignal()
2602         {
2603             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionScrollUpSignal(swigCPtr), false);
2604             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2605             return ret;
2606         }
2607
2608         public AccessibilityActionSignal ActionScrollDownSignal()
2609         {
2610             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionScrollDownSignal(swigCPtr), false);
2611             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2612             return ret;
2613         }
2614
2615         public AccessibilityActionSignal ActionPageLeftSignal()
2616         {
2617             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageLeftSignal(swigCPtr), false);
2618             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2619             return ret;
2620         }
2621
2622         public AccessibilityActionSignal ActionPageRightSignal()
2623         {
2624             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageRightSignal(swigCPtr), false);
2625             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2626             return ret;
2627         }
2628
2629         public AccessibilityActionSignal ActionPageUpSignal()
2630         {
2631             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageUpSignal(swigCPtr), false);
2632             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2633             return ret;
2634         }
2635
2636         public AccessibilityActionSignal ActionPageDownSignal()
2637         {
2638             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageDownSignal(swigCPtr), false);
2639             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2640             return ret;
2641         }
2642
2643         public AccessibilityActionSignal ActionMoveToFirstSignal()
2644         {
2645             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionMoveToFirstSignal(swigCPtr), false);
2646             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2647             return ret;
2648         }
2649
2650         public AccessibilityActionSignal ActionMoveToLastSignal()
2651         {
2652             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionMoveToLastSignal(swigCPtr), false);
2653             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2654             return ret;
2655         }
2656
2657         public AccessibilityActionSignal ActionReadFromTopSignal()
2658         {
2659             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadFromTopSignal(swigCPtr), false);
2660             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2661             return ret;
2662         }
2663
2664         public AccessibilityActionSignal ActionReadFromNextSignal()
2665         {
2666             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadFromNextSignal(swigCPtr), false);
2667             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2668             return ret;
2669         }
2670
2671         public AccessibilityActionSignal ActionZoomSignal()
2672         {
2673             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionZoomSignal(swigCPtr), false);
2674             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2675             return ret;
2676         }
2677
2678         public AccessibilityActionSignal ActionReadIndicatorInformationSignal()
2679         {
2680             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadIndicatorInformationSignal(swigCPtr), false);
2681             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2682             return ret;
2683         }
2684
2685         public AccessibilityActionSignal ActionReadPauseResumeSignal()
2686         {
2687             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadPauseResumeSignal(swigCPtr), false);
2688             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2689             return ret;
2690         }
2691
2692         public AccessibilityActionSignal ActionStartStopSignal()
2693         {
2694             AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionStartStopSignal(swigCPtr), false);
2695             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2696             return ret;
2697         }
2698
2699         public SWIGTYPE_p_Dali__SignalT_bool_fDali__Toolkit__AccessibilityManager_R_Dali__TouchEvent_const_RF_t ActionScrollSignal()
2700         {
2701             SWIGTYPE_p_Dali__SignalT_bool_fDali__Toolkit__AccessibilityManager_R_Dali__TouchEvent_const_RF_t ret = new SWIGTYPE_p_Dali__SignalT_bool_fDali__Toolkit__AccessibilityManager_R_Dali__TouchEvent_const_RF_t(NDalicPINVOKE.AccessibilityManager_ActionScrollSignal(swigCPtr), false);
2702             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2703             return ret;
2704         }
2705
2706         public enum AccessibilityAttribute
2707         {
2708             ACCESSIBILITY_LABEL = 0,
2709             ACCESSIBILITY_TRAIT,
2710             ACCESSIBILITY_VALUE,
2711             ACCESSIBILITY_HINT,
2712             ACCESSIBILITY_ATTRIBUTE_NUM
2713         }
2714
2715         public enum FocusOvershotDirection
2716         {
2717             OVERSHOT_PREVIOUS = -1,
2718             OVERSHOT_NEXT = 1
2719         }
2720
2721     }
2722
2723 }