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

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