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

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