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

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