plugins/dali-swig/SWIG/events/accessibilitymanager-event.i

   1 /*
   2  * Copyright (c) 2016 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 %define ACCESSIBILITY_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
  19   %typemap(csimports) NameSpace::ClassName %{
  20     using System;
  21     using System.Runtime.InteropServices;
  22 %}
  23
  24 %enddef
  25
  26
  27 %define ACCESSIBILITY_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
  28   %typemap(cscode) NameSpace::ClassName %{
  29
  30
  31     /**
  32       * @brief Event arguments that passed via StatusChanged signal
  33       *
  34       */
  35     public class StatusChangedEventArgs : EventArgs
  36     {
  37       private AccessibilityManager _accessibilityManager;
  38
  39       public AccessibilityManager AccessibilityManager
  40       {
  41         get
  42         {
  43           return _accessibilityManager;
  44         }
  45         set
  46         {
  47           _accessibilityManager = value;
  48         }
  49       }
  50     }
  51
  52     /**
  53       * @brief Event arguments that passed via ActionNext signal
  54       *
  55       */
  56     public class ActionNextEventArgs : EventArgs
  57     {
  58       private AccessibilityManager _accessibilityManager;
  59
  60       public AccessibilityManager AccessibilityManager
  61       {
  62         get
  63         {
  64           return _accessibilityManager;
  65         }
  66         set
  67         {
  68           _accessibilityManager = value;
  69         }
  70       }
  71     }
  72
  73     /**
  74       * @brief Event arguments that passed via ActionPrevious signal
  75       *
  76       */
  77     public class ActionPreviousEventArgs : EventArgs
  78     {
  79       private AccessibilityManager _accessibilityManager;
  80
  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 ActionActivate signal
  96       *
  97       */
  98     public class ActionActivateEventArgs : EventArgs
  99     {
 100       private AccessibilityManager _accessibilityManager;
 101
 102       public AccessibilityManager AccessibilityManager
 103       {
 104         get
 105         {
 106           return _accessibilityManager;
 107         }
 108         set
 109         {
 110           _accessibilityManager = value;
 111         }
 112       }
 113     }
 114
 115     /**
 116       * @brief Event arguments that passed via ActionRead signal
 117       *
 118       */
 119     public class ActionReadEventArgs : EventArgs
 120     {
 121       private AccessibilityManager _accessibilityManager;
 122
 123       public AccessibilityManager AccessibilityManager
 124       {
 125         get
 126         {
 127           return _accessibilityManager;
 128         }
 129         set
 130         {
 131           _accessibilityManager = value;
 132         }
 133       }
 134     }
 135
 136     /**
 137       * @brief Event arguments that passed via ActionOver signal
 138       *
 139       */
 140     public class ActionOverEventArgs : EventArgs
 141     {
 142       private AccessibilityManager _accessibilityManager;
 143
 144       public AccessibilityManager AccessibilityManager
 145       {
 146         get
 147         {
 148           return _accessibilityManager;
 149         }
 150         set
 151         {
 152           _accessibilityManager = value;
 153         }
 154       }
 155     }
 156
 157     /**
 158       * @brief Event arguments that passed via ActionReadNext signal
 159       *
 160       */
 161     public class ActionReadNextEventArgs : EventArgs
 162     {
 163       private AccessibilityManager _accessibilityManager;
 164
 165       public AccessibilityManager AccessibilityManager
 166       {
 167         get
 168         {
 169           return _accessibilityManager;
 170         }
 171         set
 172         {
 173           _accessibilityManager = value;
 174         }
 175       }
 176     }
 177
 178     /**
 179       * @brief Event arguments that passed via ActionReadPrevious signal
 180       *
 181       */
 182     public class ActionReadPreviousEventArgs : EventArgs
 183     {
 184       private AccessibilityManager _accessibilityManager;
 185
 186       public AccessibilityManager AccessibilityManager
 187       {
 188         get
 189         {
 190           return _accessibilityManager;
 191         }
 192         set
 193         {
 194           _accessibilityManager = value;
 195         }
 196       }
 197     }
 198
 199     /**
 200       * @brief Event arguments that passed via ActionUp signal
 201       *
 202       */
 203     public class ActionUpEventArgs : EventArgs
 204     {
 205       private AccessibilityManager _accessibilityManager;
 206
 207       public AccessibilityManager AccessibilityManager
 208       {
 209         get
 210         {
 211           return _accessibilityManager;
 212         }
 213         set
 214         {
 215           _accessibilityManager = value;
 216         }
 217       }
 218     }
 219
 220     /**
 221       * @brief Event arguments that passed via ActionDown signal
 222       *
 223       */
 224     public class ActionDownEventArgs : EventArgs
 225     {
 226       private AccessibilityManager _accessibilityManager;
 227
 228       public AccessibilityManager AccessibilityManager
 229       {
 230         get
 231         {
 232           return _accessibilityManager;
 233         }
 234         set
 235         {
 236           _accessibilityManager = value;
 237         }
 238       }
 239     }
 240
 241     /**
 242       * @brief Event arguments that passed via ActionClearFocus signal
 243       *
 244       */
 245     public class ActionClearFocusEventArgs : EventArgs
 246     {
 247       private AccessibilityManager _accessibilityManager;
 248
 249       public AccessibilityManager AccessibilityManager
 250       {
 251         get
 252         {
 253           return _accessibilityManager;
 254         }
 255         set
 256         {
 257           _accessibilityManager = value;
 258         }
 259       }
 260     }
 261
 262     /**
 263       * @brief Event arguments that passed via ActionBack signal
 264       *
 265       */
 266     public class ActionBackEventArgs : EventArgs
 267     {
 268       private AccessibilityManager _accessibilityManager;
 269
 270       public AccessibilityManager AccessibilityManager
 271       {
 272         get
 273         {
 274           return _accessibilityManager;
 275         }
 276         set
 277         {
 278           _accessibilityManager = value;
 279         }
 280       }
 281     }
 282
 283     /**
 284       * @brief Event arguments that passed via ActionScrollUp signal
 285       *
 286       */
 287     public class ActionScrollUpEventArgs : EventArgs
 288     {
 289       private AccessibilityManager _accessibilityManager;
 290
 291       public AccessibilityManager AccessibilityManager
 292       {
 293         get
 294         {
 295           return _accessibilityManager;
 296         }
 297         set
 298         {
 299           _accessibilityManager = value;
 300         }
 301       }
 302     }
 303
 304     /**
 305       * @brief Event arguments that passed via ActionScrollDown signal
 306       *
 307       */
 308     public class ActionScrollDownEventArgs : EventArgs
 309     {
 310       private AccessibilityManager _accessibilityManager;
 311
 312       public AccessibilityManager AccessibilityManager
 313       {
 314         get
 315         {
 316           return _accessibilityManager;
 317         }
 318         set
 319         {
 320           _accessibilityManager = value;
 321         }
 322       }
 323     }
 324
 325     /**
 326       * @brief Event arguments that passed via ActionPageLeft signal
 327       *
 328       */
 329     public class ActionPageLeftEventArgs : EventArgs
 330     {
 331       private AccessibilityManager _accessibilityManager;
 332
 333       public AccessibilityManager AccessibilityManager
 334       {
 335         get
 336         {
 337           return _accessibilityManager;
 338         }
 339         set
 340         {
 341           _accessibilityManager = value;
 342         }
 343       }
 344     }
 345
 346     /**
 347       * @brief Event arguments that passed via ActionPageRight signal
 348       *
 349       */
 350     public class ActionPageRightEventArgs : EventArgs
 351     {
 352       private AccessibilityManager _accessibilityManager;
 353
 354       public AccessibilityManager AccessibilityManager
 355       {
 356         get
 357         {
 358           return _accessibilityManager;
 359         }
 360         set
 361         {
 362           _accessibilityManager = value;
 363         }
 364       }
 365     }
 366
 367     /**
 368       * @brief Event arguments that passed via ActionPageUp signal
 369       *
 370       */
 371     public class ActionPageUpEventArgs : EventArgs
 372     {
 373       private AccessibilityManager _accessibilityManager;
 374
 375       public AccessibilityManager AccessibilityManager
 376       {
 377         get
 378         {
 379           return _accessibilityManager;
 380         }
 381         set
 382         {
 383           _accessibilityManager = value;
 384         }
 385       }
 386     }
 387
 388     /**
 389       * @brief Event arguments that passed via ActionPageDown signal
 390       *
 391       */
 392     public class ActionPageDownEventArgs : EventArgs
 393     {
 394       private AccessibilityManager _accessibilityManager;
 395
 396       public AccessibilityManager AccessibilityManager
 397       {
 398         get
 399         {
 400           return _accessibilityManager;
 401         }
 402         set
 403         {
 404           _accessibilityManager = value;
 405         }
 406       }
 407     }
 408
 409     /**
 410       * @brief Event arguments that passed via ActionMoveToFirst signal
 411       *
 412       */
 413     public class ActionMoveToFirstEventArgs : EventArgs
 414     {
 415       private AccessibilityManager _accessibilityManager;
 416
 417       public AccessibilityManager AccessibilityManager
 418       {
 419         get
 420         {
 421           return _accessibilityManager;
 422         }
 423         set
 424         {
 425           _accessibilityManager = value;
 426         }
 427       }
 428     }
 429
 430     /**
 431       * @brief Event arguments that passed via ActionMoveToLast signal
 432       *
 433       */
 434     public class ActionMoveToLastEventArgs : EventArgs
 435     {
 436       private AccessibilityManager _accessibilityManager;
 437
 438       public AccessibilityManager AccessibilityManager
 439       {
 440         get
 441         {
 442           return _accessibilityManager;
 443         }
 444         set
 445         {
 446           _accessibilityManager = value;
 447         }
 448       }
 449     }
 450
 451     /**
 452       * @brief Event arguments that passed via ActionReadFromTop signal
 453       *
 454       */
 455     public class ActionReadFromTopEventArgs : EventArgs
 456     {
 457       private AccessibilityManager _accessibilityManager;
 458
 459       public AccessibilityManager AccessibilityManager
 460       {
 461         get
 462         {
 463           return _accessibilityManager;
 464         }
 465         set
 466         {
 467           _accessibilityManager = value;
 468         }
 469       }
 470     }
 471
 472     /**
 473       * @brief Event arguments that passed via ActionReadFromNext signal
 474       *
 475       */
 476     public class ActionReadFromNextEventArgs : EventArgs
 477     {
 478       private AccessibilityManager _accessibilityManager;
 479
 480       public AccessibilityManager AccessibilityManager
 481       {
 482         get
 483         {
 484           return _accessibilityManager;
 485         }
 486         set
 487         {
 488           _accessibilityManager = value;
 489         }
 490       }
 491     }
 492
 493     /**
 494       * @brief Event arguments that passed via ActionZoom signal
 495       *
 496       */
 497     public class ActionZoomEventArgs : EventArgs
 498     {
 499       private AccessibilityManager _accessibilityManager;
 500
 501       public AccessibilityManager AccessibilityManager
 502       {
 503         get
 504         {
 505           return _accessibilityManager;
 506         }
 507         set
 508         {
 509           _accessibilityManager = value;
 510         }
 511       }
 512     }
 513
 514     /**
 515       * @brief Event arguments that passed via ActionReadIndicatorInformation signal
 516       *
 517       */
 518     public class ActionReadIndicatorInformationEventArgs : EventArgs
 519     {
 520       private AccessibilityManager _accessibilityManager;
 521
 522       public AccessibilityManager AccessibilityManager
 523       {
 524         get
 525         {
 526           return _accessibilityManager;
 527         }
 528         set
 529         {
 530           _accessibilityManager = value;
 531         }
 532       }
 533     }
 534
 535     /**
 536       * @brief Event arguments that passed via ActionReadPauseResume signal
 537       *
 538       */
 539     public class ActionReadPauseResumeEventArgs : EventArgs
 540     {
 541       private AccessibilityManager _accessibilityManager;
 542
 543       public AccessibilityManager AccessibilityManager
 544       {
 545         get
 546         {
 547           return _accessibilityManager;
 548         }
 549         set
 550         {
 551           _accessibilityManager = value;
 552         }
 553       }
 554     }
 555
 556     /**
 557       * @brief Event arguments that passed via ActionStartStop signal
 558       *
 559       */
 560     public class ActionStartStopEventArgs : EventArgs
 561     {
 562       private AccessibilityManager _accessibilityManager;
 563
 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 ActionScroll signal
 579       *
 580       */
 581     public class ActionScrollEventArgs : EventArgs
 582     {
 583       private AccessibilityManager _accessibilityManager;
 584       private TouchEvent _touchEvent;
 585
 586       public AccessibilityManager AccessibilityManager
 587       {
 588         get
 589         {
 590           return _accessibilityManager;
 591         }
 592         set
 593         {
 594           _accessibilityManager = value;
 595         }
 596       }
 597
 598       public TouchEvent TouchEvent
 599       {
 600         get
 601         {
 602           return _touchEvent;
 603         }
 604         set
 605         {
 606           _touchEvent = value;
 607         }
 608       }
 609     }
 610
 611     /**
 612       * @brief Event arguments that passed via ActionPageUp signal
 613       *
 614       */
 615     public class FocusChangedEventArgs : EventArgs
 616     {
 617       private Actor _actorCurrent;
 618       private Actor _actorNext;
 619
 620       public Actor ActorCurrent
 621       {
 622         get
 623         {
 624           return _actorCurrent;
 625         }
 626         set
 627         {
 628           _actorCurrent = value;
 629         }
 630       }
 631
 632       public Actor ActorNext
 633       {
 634         get
 635         {
 636           return _actorNext;
 637         }
 638         set
 639         {
 640           _actorNext = value;
 641         }
 642       }
 643     }
 644
 645     /**
 646       * @brief Event arguments that passed via FocusedActorActivated signal
 647       *
 648       */
 649     public class FocusedActorActivatedEventArgs : EventArgs
 650     {
 651       private Actor _actor;
 652
 653
 654       public Actor Actor
 655       {
 656         get
 657         {
 658           return _actor;
 659         }
 660         set
 661         {
 662           _actor = value;
 663         }
 664       }
 665     }
 666
 667     /**
 668       * @brief Event arguments that passed via FocusOvershot signal
 669       *
 670       */
 671     public class FocusOvershotEventArgs : EventArgs
 672     {
 673       private Actor _currentFocusedActor;
 674       private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
 675
 676       public Actor CurrentFocusedActor
 677       {
 678         get
 679         {
 680           return _currentFocusedActor;
 681         }
 682         set
 683         {
 684           _currentFocusedActor = value;
 685         }
 686       }
 687
 688       public AccessibilityManager.FocusOvershotDirection FocusOvershotDirection
 689       {
 690         get
 691         {
 692           return _focusOvershotDirection;
 693         }
 694         set
 695         {
 696           _focusOvershotDirection = value;
 697         }
 698       }
 699     }
 700
 701
 702     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 703     public delegate bool StatusChangedEventHandler(object source, StatusChangedEventArgs e);
 704
 705     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 706     public delegate bool ActionNextEventHandler(object source, ActionNextEventArgs e);
 707
 708     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 709     public delegate bool ActionPreviousEventHandler(object source, ActionPreviousEventArgs e);
 710
 711     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 712     public delegate bool ActionActivateEventHandler(object source, ActionActivateEventArgs e);
 713
 714     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 715     public delegate bool ActionReadEventHandler(object source, ActionReadEventArgs e);
 716
 717     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 718     public delegate bool ActionOverEventHandler(object source, ActionOverEventArgs e);
 719
 720     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 721     public delegate bool ActionReadNextEventHandler(object source, ActionReadNextEventArgs e);
 722
 723     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 724     public delegate bool ActionReadPreviousEventHandler(object source, ActionReadPreviousEventArgs e);
 725
 726     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 727     public delegate bool ActionUpEventHandler(object source, ActionUpEventArgs e);
 728
 729     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 730     public delegate bool ActionDownEventHandler(object source, ActionDownEventArgs e);
 731
 732     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 733     public delegate bool ActionClearFocusEventHandler(object source, ActionClearFocusEventArgs e);
 734
 735     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 736     public delegate bool ActionBackEventHandler(object source, ActionBackEventArgs e);
 737
 738     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 739     public delegate bool ActionScrollUpEventHandler(object source, ActionScrollUpEventArgs e);
 740
 741     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 742     public delegate bool ActionScrollDownEventHandler(object source, ActionScrollDownEventArgs e);
 743
 744     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 745     public delegate bool ActionPageLeftEventHandler(object source, ActionPageLeftEventArgs e);
 746
 747     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 748     public delegate bool ActionPageRightEventHandler(object source, ActionPageRightEventArgs e);
 749
 750     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 751     public delegate bool ActionPageUpEventHandler(object source, ActionPageUpEventArgs e);
 752
 753     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 754     public delegate bool ActionPageDownEventHandler(object source, ActionPageDownEventArgs e);
 755
 756     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 757     public delegate bool ActionMoveToFirstEventHandler(object source, ActionMoveToFirstEventArgs e);
 758
 759     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 760     public delegate bool ActionMoveToLastEventHandler(object source, ActionMoveToLastEventArgs e);
 761
 762     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 763     public delegate bool ActionReadFromTopEventHandler(object source, ActionReadFromTopEventArgs e);
 764
 765     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 766     public delegate bool ActionReadFromNextEventHandler(object source, ActionReadFromNextEventArgs e);
 767
 768     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 769     public delegate bool ActionZoomEventHandler(object source, ActionZoomEventArgs e);
 770
 771     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 772     public delegate bool ActionReadIndicatorInformationEventHandler(object source, ActionReadIndicatorInformationEventArgs e);
 773
 774     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 775     public delegate bool ActionReadPauseResumeEventHandler(object source, ActionReadPauseResumeEventArgs e);
 776
 777     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 778     public delegate bool ActionStartStopEventHandler(object source, ActionStartStopEventArgs e);
 779
 780     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 781     public delegate bool ActionScrollEventHandler(object source, ActionScrollEventArgs e);
 782
 783     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 784     public delegate void FocusChangedEventHandler(object source, FocusChangedEventArgs e);
 785
 786     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 787     public delegate void FocusedActorActivatedEventHandler(object source, FocusedActorActivatedEventArgs e);
 788
 789     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 790     public delegate void FocusOvershotEventHandler(object source, FocusOvershotEventArgs e);
 791     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 792     private delegate bool StatusChangedEventCallbackDelegate(IntPtr accessibilityManager);
 793     private StatusChangedEventHandler _accessibilityManagerStatusChangedEventHandler;
 794     private StatusChangedEventCallbackDelegate _accessibilityManagerStatusChangedEventCallbackDelegate;
 795
 796     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 797     private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
 798     private ActionNextEventHandler _accessibilityManagerActionNextEventHandler;
 799     private ActionNextEventCallbackDelegate _accessibilityManagerActionNextEventCallbackDelegate;
 800
 801     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 802     private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
 803     private ActionPreviousEventHandler _accessibilityManagerActionPreviousEventHandler;
 804     private ActionPreviousEventCallbackDelegate _accessibilityManagerActionPreviousEventCallbackDelegate;
 805
 806     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 807     private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
 808     private ActionActivateEventHandler _accessibilityManagerActionActivateEventHandler;
 809     private ActionActivateEventCallbackDelegate _accessibilityManagerActionActivateEventCallbackDelegate;
 810
 811     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 812     private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
 813     private ActionReadEventHandler _accessibilityManagerActionReadEventHandler;
 814     private ActionReadEventCallbackDelegate _accessibilityManagerActionReadEventCallbackDelegate;
 815
 816     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 817     private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
 818     private ActionOverEventHandler _accessibilityManagerActionOverEventHandler;
 819     private ActionOverEventCallbackDelegate _accessibilityManagerActionOverEventCallbackDelegate;
 820
 821     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 822     private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
 823     private ActionReadNextEventHandler _accessibilityManagerActionReadNextEventHandler;
 824     private ActionReadNextEventCallbackDelegate _accessibilityManagerActionReadNextEventCallbackDelegate;
 825
 826     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 827     private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
 828     private ActionReadPreviousEventHandler _accessibilityManagerActionReadPreviousEventHandler;
 829     private ActionReadPreviousEventCallbackDelegate _accessibilityManagerActionReadPreviousEventCallbackDelegate;
 830
 831     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 832     private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
 833     private ActionUpEventHandler _accessibilityManagerActionUpEventHandler;
 834     private ActionUpEventCallbackDelegate _accessibilityManagerActionUpEventCallbackDelegate;
 835
 836     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 837     private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
 838     private ActionDownEventHandler _accessibilityManagerActionDownEventHandler;
 839     private ActionDownEventCallbackDelegate _accessibilityManagerActionDownEventCallbackDelegate;
 840
 841     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 842     private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
 843     private ActionClearFocusEventHandler _accessibilityManagerActionClearFocusEventHandler;
 844     private ActionClearFocusEventCallbackDelegate _accessibilityManagerActionClearFocusEventCallbackDelegate;
 845
 846     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 847     private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
 848     private ActionBackEventHandler _accessibilityManagerActionBackEventHandler;
 849     private ActionBackEventCallbackDelegate _accessibilityManagerActionBackEventCallbackDelegate;
 850
 851     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 852     private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
 853     private ActionScrollUpEventHandler _accessibilityManagerActionScrollUpEventHandler;
 854     private ActionScrollUpEventCallbackDelegate _accessibilityManagerActionScrollUpEventCallbackDelegate;
 855
 856     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 857     private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
 858     private ActionScrollDownEventHandler _accessibilityManagerActionScrollDownEventHandler;
 859     private ActionScrollDownEventCallbackDelegate _accessibilityManagerActionScrollDownEventCallbackDelegate;
 860
 861     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 862     private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
 863     private ActionPageLeftEventHandler _accessibilityManagerActionPageLeftEventHandler;
 864     private ActionPageLeftEventCallbackDelegate _accessibilityManagerActionPageLeftEventCallbackDelegate;
 865
 866     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 867     private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
 868     private ActionPageRightEventHandler _accessibilityManagerActionPageRightEventHandler;
 869     private ActionPageRightEventCallbackDelegate _accessibilityManagerActionPageRightEventCallbackDelegate;
 870
 871     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 872     private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
 873     private ActionPageUpEventHandler _accessibilityManagerActionPageUpEventHandler;
 874     private ActionPageUpEventCallbackDelegate _accessibilityManagerActionPageUpEventCallbackDelegate;
 875
 876     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 877     private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
 878     private ActionPageDownEventHandler _accessibilityManagerActionPageDownEventHandler;
 879     private ActionPageDownEventCallbackDelegate _accessibilityManagerActionPageDownEventCallbackDelegate;
 880
 881     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 882     private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
 883     private ActionMoveToFirstEventHandler _accessibilityManagerActionMoveToFirstEventHandler;
 884     private ActionMoveToFirstEventCallbackDelegate _accessibilityManagerActionMoveToFirstEventCallbackDelegate;
 885
 886     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 887     private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
 888     private ActionMoveToLastEventHandler _accessibilityManagerActionMoveToLastEventHandler;
 889     private ActionMoveToLastEventCallbackDelegate _accessibilityManagerActionMoveToLastEventCallbackDelegate;
 890
 891     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 892     private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
 893     private ActionReadFromTopEventHandler _accessibilityManagerActionReadFromTopEventHandler;
 894     private ActionReadFromTopEventCallbackDelegate _accessibilityManagerActionReadFromTopEventCallbackDelegate;
 895
 896     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 897     private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
 898     private ActionReadFromNextEventHandler _accessibilityManagerActionReadFromNextEventHandler;
 899     private ActionReadFromNextEventCallbackDelegate _accessibilityManagerActionReadFromNextEventCallbackDelegate;
 900
 901     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 902     private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
 903     private ActionZoomEventHandler _accessibilityManagerActionZoomEventHandler;
 904     private ActionZoomEventCallbackDelegate _accessibilityManagerActionZoomEventCallbackDelegate;
 905
 906     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 907     private delegate bool ActionReadIndicatorInformationEventCallbackDelegate(IntPtr accessibilityManager);
 908     private ActionReadIndicatorInformationEventHandler _accessibilityManagerActionReadIndicatorInformationEventHandler;
 909     private ActionReadIndicatorInformationEventCallbackDelegate _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate;
 910
 911     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 912     private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
 913     private ActionReadPauseResumeEventHandler _accessibilityManagerActionReadPauseResumeEventHandler;
 914     private ActionReadPauseResumeEventCallbackDelegate _accessibilityManagerActionReadPauseResumeEventCallbackDelegate;
 915
 916     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 917     private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
 918     private ActionStartStopEventHandler _accessibilityManagerActionStartStopEventHandler;
 919     private ActionStartStopEventCallbackDelegate _accessibilityManagerActionStartStopEventCallbackDelegate;
 920
 921     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 922     private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
 923     private ActionScrollEventHandler _accessibilityManagerActionScrollEventHandler;
 924     private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;
 925
 926     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 927     private delegate void FocusChangedEventCallbackDelegate(IntPtr actor1, IntPtr actor2);
 928     private FocusChangedEventHandler _accessibilityManagerFocusChangedEventHandler;
 929     private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
 930
 931     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 932     private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
 933     private FocusedActorActivatedEventHandler _accessibilityManagerFocusedActorActivatedEventHandler;
 934     private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;
 935
 936     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 937     private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
 938     private FocusOvershotEventHandler _accessibilityManagerFocusOvershotEventHandler;
 939     private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
 940
 941     public event StatusChangedEventHandler StatusChanged
 942     {
 943       add
 944       {
 945         lock(this)
 946         {
 947           // Restricted to only one listener
 948           if (_accessibilityManagerStatusChangedEventHandler == null)
 949           {
 950             _accessibilityManagerStatusChangedEventHandler += value;
 951
 952             _accessibilityManagerStatusChangedEventCallbackDelegate = new StatusChangedEventCallbackDelegate(OnStatusChanged);
 953             this.StatusChangedSignal().Connect(_accessibilityManagerStatusChangedEventCallbackDelegate);
 954           }
 955         }
 956       }
 957
 958       remove
 959       {
 960         lock(this)
 961         {
 962           if (_accessibilityManagerStatusChangedEventHandler != null)
 963           {
 964             this.StatusChangedSignal().Disconnect(_accessibilityManagerStatusChangedEventCallbackDelegate);
 965           }
 966
 967           _accessibilityManagerStatusChangedEventHandler -= value;
 968         }
 969       }
 970     }
 971
 972     // Callback for AccessibilityManager StatusChangedSignal
 973     private bool OnStatusChanged(IntPtr data)
 974     {
 975       StatusChangedEventArgs e = new StatusChangedEventArgs();
 976
 977       // Populate all members of "e" (StatusChangedEventArgs) with real data
 978       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
 979
 980       if (_accessibilityManagerStatusChangedEventHandler != null)
 981       {
 982         //here we send all data to user event handlers
 983         return _accessibilityManagerStatusChangedEventHandler(this, e);
 984       }
 985       return false;
 986     }
 987
 988     public event ActionNextEventHandler ActionNext
 989     {
 990       add
 991       {
 992         lock(this)
 993         {
 994           // Restricted to only one listener
 995           if (_accessibilityManagerActionNextEventHandler == null)
 996           {
 997             _accessibilityManagerActionNextEventHandler += value;
 998
 999             _accessibilityManagerActionNextEventCallbackDelegate = new ActionNextEventCallbackDelegate(OnActionNext);
1000             this.ActionNextSignal().Connect(_accessibilityManagerActionNextEventCallbackDelegate);
1001           }
1002         }
1003       }
1004
1005       remove
1006       {
1007         lock(this)
1008         {
1009           if (_accessibilityManagerActionNextEventHandler != null)
1010           {
1011             this.ActionNextSignal().Disconnect(_accessibilityManagerActionNextEventCallbackDelegate);
1012           }
1013
1014           _accessibilityManagerActionNextEventHandler -= value;
1015         }
1016       }
1017     }
1018
1019     // Callback for AccessibilityManager ActionNextSignal
1020     private bool OnActionNext(IntPtr data)
1021     {
1022       ActionNextEventArgs e = new ActionNextEventArgs();
1023
1024       // Populate all members of "e" (ActionNextEventArgs) with real data
1025       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1026
1027       if (_accessibilityManagerActionNextEventHandler != null)
1028       {
1029         //here we send all data to user event handlers
1030         return _accessibilityManagerActionNextEventHandler(this, e);
1031       }
1032       return false;
1033     }
1034
1035     public event ActionPreviousEventHandler ActionPrevious
1036     {
1037       add
1038       {
1039         lock(this)
1040         {
1041           // Restricted to only one listener
1042           if (_accessibilityManagerActionPreviousEventHandler == null)
1043           {
1044             _accessibilityManagerActionPreviousEventHandler += value;
1045
1046             _accessibilityManagerActionPreviousEventCallbackDelegate = new ActionPreviousEventCallbackDelegate(OnActionPrevious);
1047             this.ActionPreviousSignal().Connect(_accessibilityManagerActionPreviousEventCallbackDelegate);
1048           }
1049         }
1050       }
1051
1052       remove
1053       {
1054         lock(this)
1055         {
1056           if (_accessibilityManagerActionPreviousEventHandler != null)
1057           {
1058             this.ActionPreviousSignal().Disconnect(_accessibilityManagerActionPreviousEventCallbackDelegate);
1059           }
1060
1061           _accessibilityManagerActionPreviousEventHandler -= value;
1062         }
1063       }
1064     }
1065
1066     // Callback for AccessibilityManager ActionPreviousSignal
1067     private bool OnActionPrevious(IntPtr data)
1068     {
1069       ActionPreviousEventArgs e = new ActionPreviousEventArgs();
1070
1071       // Populate all members of "e" (ActionPreviousEventArgs) with real data
1072       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1073
1074       if (_accessibilityManagerActionPreviousEventHandler != null)
1075       {
1076         //here we send all data to user event handlers
1077         return _accessibilityManagerActionPreviousEventHandler(this, e);
1078       }
1079       return false;
1080     }
1081
1082     public event ActionActivateEventHandler ActionActivate
1083     {
1084       add
1085       {
1086         lock(this)
1087         {
1088           // Restricted to only one listener
1089           if (_accessibilityManagerActionActivateEventHandler == null)
1090           {
1091             _accessibilityManagerActionActivateEventHandler += value;
1092
1093             _accessibilityManagerActionActivateEventCallbackDelegate = new ActionActivateEventCallbackDelegate(OnActionActivate);
1094             this.ActionActivateSignal().Connect(_accessibilityManagerActionActivateEventCallbackDelegate);
1095           }
1096         }
1097       }
1098
1099       remove
1100       {
1101         lock(this)
1102         {
1103           if (_accessibilityManagerActionActivateEventHandler != null)
1104           {
1105             this.ActionActivateSignal().Disconnect(_accessibilityManagerActionActivateEventCallbackDelegate);
1106           }
1107
1108           _accessibilityManagerActionActivateEventHandler -= value;
1109         }
1110       }
1111     }
1112
1113     // Callback for AccessibilityManager ActionActivateSignal
1114     private bool OnActionActivate(IntPtr data)
1115     {
1116       ActionActivateEventArgs e = new ActionActivateEventArgs();
1117
1118       // Populate all members of "e" (ActionActivateEventArgs) with real data
1119       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1120
1121       if (_accessibilityManagerActionActivateEventHandler != null)
1122       {
1123         //here we send all data to user event handlers
1124         return _accessibilityManagerActionActivateEventHandler(this, e);
1125       }
1126       return false;
1127     }
1128
1129     public event ActionReadEventHandler ActionRead
1130     {
1131       add
1132       {
1133         lock(this)
1134         {
1135           // Restricted to only one listener
1136           if (_accessibilityManagerActionReadEventHandler == null)
1137           {
1138             _accessibilityManagerActionReadEventHandler += value;
1139
1140             _accessibilityManagerActionReadEventCallbackDelegate = new ActionReadEventCallbackDelegate(OnActionRead);
1141             this.ActionReadSignal().Connect(_accessibilityManagerActionReadEventCallbackDelegate);
1142           }
1143         }
1144       }
1145
1146       remove
1147       {
1148         lock(this)
1149         {
1150           if (_accessibilityManagerActionReadEventHandler != null)
1151           {
1152             this.ActionReadSignal().Disconnect(_accessibilityManagerActionReadEventCallbackDelegate);
1153           }
1154
1155           _accessibilityManagerActionReadEventHandler -= value;
1156         }
1157       }
1158     }
1159
1160     // Callback for AccessibilityManager ActionReadSignal
1161     private bool OnActionRead(IntPtr data)
1162     {
1163       ActionReadEventArgs e = new ActionReadEventArgs();
1164
1165       // Populate all members of "e" (ActionReadEventArgs) with real data
1166       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1167
1168       if (_accessibilityManagerActionReadEventHandler != null)
1169       {
1170         //here we send all data to user event handlers
1171         return _accessibilityManagerActionReadEventHandler(this, e);
1172       }
1173       return false;
1174     }
1175
1176     public event ActionOverEventHandler ActionOver
1177     {
1178       add
1179       {
1180         lock(this)
1181         {
1182           // Restricted to only one listener
1183           if (_accessibilityManagerActionOverEventHandler == null)
1184           {
1185             _accessibilityManagerActionOverEventHandler += value;
1186
1187             _accessibilityManagerActionOverEventCallbackDelegate = new ActionOverEventCallbackDelegate(OnActionOver);
1188             this.ActionOverSignal().Connect(_accessibilityManagerActionOverEventCallbackDelegate);
1189           }
1190         }
1191       }
1192
1193       remove
1194       {
1195         lock(this)
1196         {
1197           if (_accessibilityManagerActionOverEventHandler != null)
1198           {
1199             this.ActionOverSignal().Disconnect(_accessibilityManagerActionOverEventCallbackDelegate);
1200           }
1201
1202           _accessibilityManagerActionOverEventHandler -= value;
1203         }
1204       }
1205     }
1206
1207     // Callback for AccessibilityManager ActionOverSignal
1208     private bool OnActionOver(IntPtr data)
1209     {
1210       ActionOverEventArgs e = new ActionOverEventArgs();
1211
1212       // Populate all members of "e" (ActionOverEventArgs) with real data
1213       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1214
1215       if (_accessibilityManagerActionOverEventHandler != null)
1216       {
1217         //here we send all data to user event handlers
1218         return _accessibilityManagerActionOverEventHandler(this, e);
1219       }
1220       return false;
1221     }
1222
1223     public event ActionReadNextEventHandler ActionReadNext
1224     {
1225       add
1226       {
1227         lock(this)
1228         {
1229           // Restricted to only one listener
1230           if (_accessibilityManagerActionReadNextEventHandler == null)
1231           {
1232             _accessibilityManagerActionReadNextEventHandler += value;
1233
1234             _accessibilityManagerActionReadNextEventCallbackDelegate = new ActionReadNextEventCallbackDelegate(OnActionReadNext);
1235             this.ActionReadNextSignal().Connect(_accessibilityManagerActionReadNextEventCallbackDelegate);
1236           }
1237         }
1238       }
1239
1240       remove
1241       {
1242         lock(this)
1243         {
1244           if (_accessibilityManagerActionReadNextEventHandler != null)
1245           {
1246             this.ActionReadNextSignal().Disconnect(_accessibilityManagerActionReadNextEventCallbackDelegate);
1247           }
1248
1249           _accessibilityManagerActionReadNextEventHandler -= value;
1250         }
1251       }
1252     }
1253
1254     // Callback for AccessibilityManager ActionReadNextSignal
1255     private bool OnActionReadNext(IntPtr data)
1256     {
1257       ActionReadNextEventArgs e = new ActionReadNextEventArgs();
1258
1259       // Populate all members of "e" (ActionReadNextEventArgs) with real data
1260       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1261
1262       if (_accessibilityManagerActionReadNextEventHandler != null)
1263       {
1264         //here we send all data to user event handlers
1265         return _accessibilityManagerActionReadNextEventHandler(this, e);
1266       }
1267       return false;
1268     }
1269
1270
1271     public event ActionReadPreviousEventHandler ActionReadPrevious
1272     {
1273       add
1274       {
1275         lock(this)
1276         {
1277           // Restricted to only one listener
1278           if (_accessibilityManagerActionReadPreviousEventHandler == null)
1279           {
1280             _accessibilityManagerActionReadPreviousEventHandler += value;
1281
1282             _accessibilityManagerActionReadPreviousEventCallbackDelegate = new ActionReadPreviousEventCallbackDelegate(OnActionReadPrevious);
1283             this.ActionReadPreviousSignal().Connect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
1284           }
1285         }
1286       }
1287
1288       remove
1289       {
1290         lock(this)
1291         {
1292           if (_accessibilityManagerActionReadPreviousEventHandler != null)
1293           {
1294             this.ActionReadPreviousSignal().Disconnect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
1295           }
1296
1297           _accessibilityManagerActionReadPreviousEventHandler -= value;
1298         }
1299       }
1300     }
1301
1302     // Callback for AccessibilityManager ActionReadPreviousSignal
1303     private bool OnActionReadPrevious(IntPtr data)
1304     {
1305       ActionReadPreviousEventArgs e = new ActionReadPreviousEventArgs();
1306
1307       // Populate all members of "e" (ActionReadPreviousEventArgs) with real data
1308       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1309
1310       if (_accessibilityManagerActionReadPreviousEventHandler != null)
1311       {
1312         //here we send all data to user event handlers
1313         return _accessibilityManagerActionReadPreviousEventHandler(this, e);
1314       }
1315       return false;
1316     }
1317
1318     public event ActionUpEventHandler ActionUp
1319     {
1320       add
1321       {
1322         lock(this)
1323         {
1324           // Restricted to only one listener
1325           if (_accessibilityManagerActionUpEventHandler == null)
1326           {
1327             _accessibilityManagerActionUpEventHandler += value;
1328
1329             _accessibilityManagerActionUpEventCallbackDelegate = new ActionUpEventCallbackDelegate(OnActionUp);
1330             this.ActionUpSignal().Connect(_accessibilityManagerActionUpEventCallbackDelegate);
1331           }
1332         }
1333       }
1334
1335       remove
1336       {
1337         lock(this)
1338         {
1339           if (_accessibilityManagerActionUpEventHandler != null)
1340           {
1341             this.ActionUpSignal().Disconnect(_accessibilityManagerActionUpEventCallbackDelegate);
1342           }
1343
1344           _accessibilityManagerActionUpEventHandler -= value;
1345         }
1346       }
1347     }
1348
1349     // Callback for AccessibilityManager ActionUpSignal
1350     private bool OnActionUp(IntPtr data)
1351     {
1352       ActionUpEventArgs e = new ActionUpEventArgs();
1353
1354       // Populate all members of "e" (ActionUpEventArgs) with real data
1355       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1356
1357       if (_accessibilityManagerActionUpEventHandler != null)
1358       {
1359         //here we send all data to user event handlers
1360         return _accessibilityManagerActionUpEventHandler(this, e);
1361       }
1362       return false;
1363     }
1364
1365     public event ActionDownEventHandler ActionDown
1366     {
1367       add
1368       {
1369         lock(this)
1370         {
1371           // Restricted to only one listener
1372           if (_accessibilityManagerActionDownEventHandler == null)
1373           {
1374             _accessibilityManagerActionDownEventHandler += value;
1375
1376             _accessibilityManagerActionDownEventCallbackDelegate = new ActionDownEventCallbackDelegate(OnActionDown);
1377             this.ActionDownSignal().Connect(_accessibilityManagerActionDownEventCallbackDelegate);
1378           }
1379         }
1380       }
1381
1382       remove
1383       {
1384         lock(this)
1385         {
1386           if (_accessibilityManagerActionDownEventHandler != null)
1387           {
1388             this.ActionDownSignal().Disconnect(_accessibilityManagerActionDownEventCallbackDelegate);
1389           }
1390
1391           _accessibilityManagerActionDownEventHandler -= value;
1392         }
1393       }
1394     }
1395
1396     // Callback for AccessibilityManager ActionDownSignal
1397     private bool OnActionDown(IntPtr data)
1398     {
1399       ActionDownEventArgs e = new ActionDownEventArgs();
1400
1401       // Populate all members of "e" (ActionDownEventArgs) with real data
1402       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1403
1404       if (_accessibilityManagerActionDownEventHandler != null)
1405       {
1406         //here we send all data to user event handlers
1407         return _accessibilityManagerActionDownEventHandler(this, e);
1408       }
1409       return false;
1410     }
1411
1412     public event ActionClearFocusEventHandler ActionClearFocus
1413     {
1414       add
1415       {
1416         lock(this)
1417         {
1418           // Restricted to only one listener
1419           if (_accessibilityManagerActionClearFocusEventHandler == null)
1420           {
1421             _accessibilityManagerActionClearFocusEventHandler += value;
1422
1423             _accessibilityManagerActionClearFocusEventCallbackDelegate = new ActionClearFocusEventCallbackDelegate(OnActionClearFocus);
1424             this.ActionClearFocusSignal().Connect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
1425           }
1426         }
1427       }
1428
1429       remove
1430       {
1431         lock(this)
1432         {
1433           if (_accessibilityManagerActionClearFocusEventHandler != null)
1434           {
1435             this.ActionClearFocusSignal().Disconnect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
1436           }
1437
1438           _accessibilityManagerActionClearFocusEventHandler -= value;
1439         }
1440       }
1441     }
1442
1443     // Callback for AccessibilityManager ActionClearFocusSignal
1444     private bool OnActionClearFocus(IntPtr data)
1445     {
1446       ActionClearFocusEventArgs e = new ActionClearFocusEventArgs();
1447
1448       // Populate all members of "e" (ActionClearFocusEventArgs) with real data
1449       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1450
1451       if (_accessibilityManagerActionClearFocusEventHandler != null)
1452       {
1453         //here we send all data to user event handlers
1454         return _accessibilityManagerActionClearFocusEventHandler(this, e);
1455       }
1456       return false;
1457     }
1458
1459     public event ActionBackEventHandler ActionBack
1460     {
1461       add
1462       {
1463         lock(this)
1464         {
1465           // Restricted to only one listener
1466           if (_accessibilityManagerActionBackEventHandler == null)
1467           {
1468             _accessibilityManagerActionBackEventHandler += value;
1469
1470             _accessibilityManagerActionBackEventCallbackDelegate = new ActionBackEventCallbackDelegate(OnActionBack);
1471             this.ActionBackSignal().Connect(_accessibilityManagerActionBackEventCallbackDelegate);
1472           }
1473         }
1474       }
1475
1476       remove
1477       {
1478         lock(this)
1479         {
1480           if (_accessibilityManagerActionBackEventHandler != null)
1481           {
1482             this.ActionBackSignal().Disconnect(_accessibilityManagerActionBackEventCallbackDelegate);
1483           }
1484
1485           _accessibilityManagerActionBackEventHandler -= value;
1486         }
1487       }
1488     }
1489
1490     // Callback for AccessibilityManager ActionBackSignal
1491     private bool OnActionBack(IntPtr data)
1492     {
1493       ActionBackEventArgs e = new ActionBackEventArgs();
1494
1495       // Populate all members of "e" (ActionBackEventArgs) with real data
1496       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1497
1498       if (_accessibilityManagerActionBackEventHandler != null)
1499       {
1500         //here we send all data to user event handlers
1501         return _accessibilityManagerActionBackEventHandler(this, e);
1502       }
1503       return false;
1504     }
1505
1506     public event ActionScrollUpEventHandler ActionScrollUp
1507     {
1508       add
1509       {
1510         lock(this)
1511         {
1512           // Restricted to only one listener
1513           if (_accessibilityManagerActionScrollUpEventHandler == null)
1514           {
1515             _accessibilityManagerActionScrollUpEventHandler += value;
1516
1517             _accessibilityManagerActionScrollUpEventCallbackDelegate = new ActionScrollUpEventCallbackDelegate(OnActionScrollUp);
1518             this.ActionScrollUpSignal().Connect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
1519           }
1520         }
1521       }
1522
1523       remove
1524       {
1525         lock(this)
1526         {
1527           if (_accessibilityManagerActionScrollUpEventHandler != null)
1528           {
1529             this.ActionScrollUpSignal().Disconnect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
1530           }
1531
1532           _accessibilityManagerActionScrollUpEventHandler -= value;
1533         }
1534       }
1535     }
1536
1537     // Callback for AccessibilityManager ActionScrollUpSignal
1538     private bool OnActionScrollUp(IntPtr data)
1539     {
1540       ActionScrollUpEventArgs e = new ActionScrollUpEventArgs();
1541
1542       // Populate all members of "e" (ActionScrollUpEventArgs) with real data
1543       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1544
1545       if (_accessibilityManagerActionScrollUpEventHandler != null)
1546       {
1547         //here we send all data to user event handlers
1548         return _accessibilityManagerActionScrollUpEventHandler(this, e);
1549       }
1550       return false;
1551     }
1552
1553     public event ActionScrollDownEventHandler ActionScrollDown
1554     {
1555       add
1556       {
1557         lock(this)
1558         {
1559           // Restricted to only one listener
1560           if (_accessibilityManagerActionScrollDownEventHandler == null)
1561           {
1562             _accessibilityManagerActionScrollDownEventHandler += value;
1563
1564             _accessibilityManagerActionScrollDownEventCallbackDelegate = new ActionScrollDownEventCallbackDelegate(OnActionScrollDown);
1565             this.ActionScrollDownSignal().Connect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
1566           }
1567         }
1568       }
1569
1570       remove
1571       {
1572         lock(this)
1573         {
1574           if (_accessibilityManagerActionScrollDownEventHandler != null)
1575           {
1576             this.ActionScrollDownSignal().Disconnect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
1577           }
1578
1579           _accessibilityManagerActionScrollDownEventHandler -= value;
1580         }
1581       }
1582     }
1583
1584     // Callback for AccessibilityManager ActionScrollDownSignal
1585     private bool OnActionScrollDown(IntPtr data)
1586     {
1587       ActionScrollDownEventArgs e = new ActionScrollDownEventArgs();
1588
1589       // Populate all members of "e" (ActionScrollDownEventArgs) with real data
1590       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1591
1592       if (_accessibilityManagerActionScrollDownEventHandler != null)
1593       {
1594         //here we send all data to user event handlers
1595         return _accessibilityManagerActionScrollDownEventHandler(this, e);
1596       }
1597       return false;
1598     }
1599
1600
1601     public event ActionPageLeftEventHandler ActionPageLeft
1602     {
1603       add
1604       {
1605         lock(this)
1606         {
1607           // Restricted to only one listener
1608           if (_accessibilityManagerActionPageLeftEventHandler == null)
1609           {
1610             _accessibilityManagerActionPageLeftEventHandler += value;
1611
1612             _accessibilityManagerActionPageLeftEventCallbackDelegate = new ActionPageLeftEventCallbackDelegate(OnActionPageLeft);
1613             this.ActionPageLeftSignal().Connect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
1614           }
1615         }
1616       }
1617
1618       remove
1619       {
1620         lock(this)
1621         {
1622           if (_accessibilityManagerActionPageLeftEventHandler != null)
1623           {
1624             this.ActionPageLeftSignal().Disconnect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
1625           }
1626
1627           _accessibilityManagerActionPageLeftEventHandler -= value;
1628         }
1629       }
1630     }
1631
1632     // Callback for AccessibilityManager ActionPageLeftSignal
1633     private bool OnActionPageLeft(IntPtr data)
1634     {
1635       ActionPageLeftEventArgs e = new ActionPageLeftEventArgs();
1636
1637       // Populate all members of "e" (ActionPageLeftEventArgs) with real data
1638       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1639
1640       if (_accessibilityManagerActionPageLeftEventHandler != null)
1641       {
1642         //here we send all data to user event handlers
1643         return _accessibilityManagerActionPageLeftEventHandler(this, e);
1644       }
1645       return false;
1646     }
1647
1648     public event ActionPageRightEventHandler ActionPageRight
1649     {
1650       add
1651       {
1652         lock(this)
1653         {
1654           // Restricted to only one listener
1655           if (_accessibilityManagerActionPageRightEventHandler == null)
1656           {
1657             _accessibilityManagerActionPageRightEventHandler += value;
1658
1659             _accessibilityManagerActionPageRightEventCallbackDelegate = new ActionPageRightEventCallbackDelegate(OnActionPageRight);
1660             this.ActionPageRightSignal().Connect(_accessibilityManagerActionPageRightEventCallbackDelegate);
1661           }
1662         }
1663       }
1664
1665       remove
1666       {
1667         lock(this)
1668         {
1669           if (_accessibilityManagerActionPageRightEventHandler != null)
1670           {
1671             this.ActionPageRightSignal().Disconnect(_accessibilityManagerActionPageRightEventCallbackDelegate);
1672           }
1673
1674           _accessibilityManagerActionPageRightEventHandler -= value;
1675         }
1676       }
1677     }
1678
1679     // Callback for AccessibilityManager ActionPageRightSignal
1680     private bool OnActionPageRight(IntPtr data)
1681     {
1682       ActionPageRightEventArgs e = new ActionPageRightEventArgs();
1683
1684       // Populate all members of "e" (ActionPageRightEventArgs) with real data
1685       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1686
1687       if (_accessibilityManagerActionPageRightEventHandler != null)
1688       {
1689         //here we send all data to user event handlers
1690         return _accessibilityManagerActionPageRightEventHandler(this, e);
1691       }
1692       return false;
1693     }
1694
1695     public event ActionPageUpEventHandler ActionPageUp
1696     {
1697       add
1698       {
1699         lock(this)
1700         {
1701           // Restricted to only one listener
1702           if (_accessibilityManagerActionPageUpEventHandler == null)
1703           {
1704             _accessibilityManagerActionPageUpEventHandler += value;
1705
1706             _accessibilityManagerActionPageUpEventCallbackDelegate = new ActionPageUpEventCallbackDelegate(OnActionPageUp);
1707             this.ActionPageUpSignal().Connect(_accessibilityManagerActionPageUpEventCallbackDelegate);
1708           }
1709         }
1710       }
1711
1712       remove
1713       {
1714         lock(this)
1715         {
1716           if (_accessibilityManagerActionPageUpEventHandler != null)
1717           {
1718             this.ActionPageUpSignal().Disconnect(_accessibilityManagerActionPageUpEventCallbackDelegate);
1719           }
1720
1721           _accessibilityManagerActionPageUpEventHandler -= value;
1722         }
1723       }
1724     }
1725
1726     // Callback for AccessibilityManager ActionPageUpSignal
1727     private bool OnActionPageUp(IntPtr data)
1728     {
1729       ActionPageUpEventArgs e = new ActionPageUpEventArgs();
1730
1731       // Populate all members of "e" (ActionPageUpEventArgs) with real data
1732       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1733
1734       if (_accessibilityManagerActionPageUpEventHandler != null)
1735       {
1736         //here we send all data to user event handlers
1737         return _accessibilityManagerActionPageUpEventHandler(this, e);
1738       }
1739       return false;
1740     }
1741
1742
1743     public event ActionPageDownEventHandler ActionPageDown
1744     {
1745       add
1746       {
1747         lock(this)
1748         {
1749           // Restricted to only one listener
1750           if (_accessibilityManagerActionPageDownEventHandler == null)
1751           {
1752             _accessibilityManagerActionPageDownEventHandler += value;
1753
1754             _accessibilityManagerActionPageDownEventCallbackDelegate = new ActionPageDownEventCallbackDelegate(OnActionPageDown);
1755             this.ActionPageDownSignal().Connect(_accessibilityManagerActionPageDownEventCallbackDelegate);
1756           }
1757         }
1758       }
1759
1760       remove
1761       {
1762         lock(this)
1763         {
1764           if (_accessibilityManagerActionPageDownEventHandler != null)
1765           {
1766             this.ActionPageDownSignal().Disconnect(_accessibilityManagerActionPageDownEventCallbackDelegate);
1767           }
1768
1769           _accessibilityManagerActionPageDownEventHandler -= value;
1770         }
1771       }
1772     }
1773
1774     // Callback for AccessibilityManager ActionPageDownSignal
1775     private bool OnActionPageDown(IntPtr data)
1776     {
1777       ActionPageDownEventArgs e = new ActionPageDownEventArgs();
1778
1779       // Populate all members of "e" (ActionPageDownEventArgs) with real data
1780       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1781
1782       if (_accessibilityManagerActionPageDownEventHandler != null)
1783       {
1784         //here we send all data to user event handlers
1785         return _accessibilityManagerActionPageDownEventHandler(this, e);
1786       }
1787       return false;
1788     }
1789
1790
1791     public event ActionMoveToFirstEventHandler ActionMoveToFirst
1792     {
1793       add
1794       {
1795         lock(this)
1796         {
1797           // Restricted to only one listener
1798           if (_accessibilityManagerActionMoveToFirstEventHandler == null)
1799           {
1800             _accessibilityManagerActionMoveToFirstEventHandler += value;
1801
1802             _accessibilityManagerActionMoveToFirstEventCallbackDelegate = new ActionMoveToFirstEventCallbackDelegate(OnActionMoveToFirst);
1803             this.ActionMoveToFirstSignal().Connect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
1804           }
1805         }
1806       }
1807
1808       remove
1809       {
1810         lock(this)
1811         {
1812           if (_accessibilityManagerActionMoveToFirstEventHandler != null)
1813           {
1814             this.ActionMoveToFirstSignal().Disconnect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
1815           }
1816
1817           _accessibilityManagerActionMoveToFirstEventHandler -= value;
1818         }
1819       }
1820     }
1821
1822     // Callback for AccessibilityManager ActionMoveToFirstSignal
1823     private bool OnActionMoveToFirst(IntPtr data)
1824     {
1825       ActionMoveToFirstEventArgs e = new ActionMoveToFirstEventArgs();
1826
1827       // Populate all members of "e" (ActionMoveToFirstEventArgs) with real data
1828       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1829
1830       if (_accessibilityManagerActionMoveToFirstEventHandler != null)
1831       {
1832         //here we send all data to user event handlers
1833         return _accessibilityManagerActionMoveToFirstEventHandler(this, e);
1834       }
1835       return false;
1836     }
1837
1838     public event ActionMoveToLastEventHandler ActionMoveToLast
1839     {
1840       add
1841       {
1842         lock(this)
1843         {
1844           // Restricted to only one listener
1845           if (_accessibilityManagerActionMoveToLastEventHandler == null)
1846           {
1847             _accessibilityManagerActionMoveToLastEventHandler += value;
1848
1849             _accessibilityManagerActionMoveToLastEventCallbackDelegate = new ActionMoveToLastEventCallbackDelegate(OnActionMoveToLast);
1850             this.ActionMoveToLastSignal().Connect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
1851           }
1852         }
1853       }
1854
1855       remove
1856       {
1857         lock(this)
1858         {
1859           if (_accessibilityManagerActionMoveToLastEventHandler != null)
1860           {
1861             this.ActionMoveToLastSignal().Disconnect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
1862           }
1863
1864           _accessibilityManagerActionMoveToLastEventHandler -= value;
1865         }
1866       }
1867     }
1868
1869     // Callback for AccessibilityManager ActionMoveToLastSignal
1870     private bool OnActionMoveToLast(IntPtr data)
1871     {
1872       ActionMoveToLastEventArgs e = new ActionMoveToLastEventArgs();
1873
1874       // Populate all members of "e" (ActionMoveToLastEventArgs) with real data
1875       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1876
1877       if (_accessibilityManagerActionMoveToLastEventHandler != null)
1878       {
1879         //here we send all data to user event handlers
1880         return _accessibilityManagerActionMoveToLastEventHandler(this, e);
1881       }
1882       return false;
1883     }
1884
1885     public event ActionReadFromTopEventHandler ActionReadFromTop
1886     {
1887       add
1888       {
1889         lock(this)
1890         {
1891           // Restricted to only one listener
1892           if (_accessibilityManagerActionReadFromTopEventHandler == null)
1893           {
1894             _accessibilityManagerActionReadFromTopEventHandler += value;
1895
1896             _accessibilityManagerActionReadFromTopEventCallbackDelegate = new ActionReadFromTopEventCallbackDelegate(OnActionReadFromTop);
1897             this.ActionReadFromTopSignal().Connect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
1898           }
1899         }
1900       }
1901
1902       remove
1903       {
1904         lock(this)
1905         {
1906           if (_accessibilityManagerActionReadFromTopEventHandler != null)
1907           {
1908             this.ActionReadFromTopSignal().Disconnect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
1909           }
1910
1911           _accessibilityManagerActionReadFromTopEventHandler -= value;
1912         }
1913       }
1914     }
1915
1916     // Callback for AccessibilityManager ActionReadFromTopSignal
1917     private bool OnActionReadFromTop(IntPtr data)
1918     {
1919       ActionReadFromTopEventArgs e = new ActionReadFromTopEventArgs();
1920
1921       // Populate all members of "e" (ActionReadFromTopEventArgs) with real data
1922       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1923
1924       if (_accessibilityManagerActionReadFromTopEventHandler != null)
1925       {
1926         //here we send all data to user event handlers
1927         return _accessibilityManagerActionReadFromTopEventHandler(this, e);
1928       }
1929       return false;
1930     }
1931
1932     public event ActionReadFromNextEventHandler ActionReadFromNext
1933     {
1934       add
1935       {
1936         lock(this)
1937         {
1938           // Restricted to only one listener
1939           if (_accessibilityManagerActionReadFromNextEventHandler == null)
1940           {
1941             _accessibilityManagerActionReadFromNextEventHandler += value;
1942
1943             _accessibilityManagerActionReadFromNextEventCallbackDelegate = new ActionReadFromNextEventCallbackDelegate(OnActionReadFromNext);
1944             this.ActionReadFromNextSignal().Connect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
1945           }
1946         }
1947       }
1948
1949       remove
1950       {
1951         lock(this)
1952         {
1953           if (_accessibilityManagerActionReadFromNextEventHandler != null)
1954           {
1955             this.ActionReadFromNextSignal().Disconnect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
1956           }
1957
1958           _accessibilityManagerActionReadFromNextEventHandler -= value;
1959         }
1960       }
1961     }
1962
1963     // Callback for AccessibilityManager ActionReadFromNextSignal
1964     private bool OnActionReadFromNext(IntPtr data)
1965     {
1966       ActionReadFromNextEventArgs e = new ActionReadFromNextEventArgs();
1967
1968       // Populate all members of "e" (ActionReadFromNextEventArgs) with real data
1969       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1970
1971       if (_accessibilityManagerActionReadFromNextEventHandler != null)
1972       {
1973         //here we send all data to user event handlers
1974         return _accessibilityManagerActionReadFromNextEventHandler(this, e);
1975       }
1976       return false;
1977     }
1978
1979     public event ActionZoomEventHandler ActionZoom
1980     {
1981       add
1982       {
1983         lock(this)
1984         {
1985           // Restricted to only one listener
1986           if (_accessibilityManagerActionZoomEventHandler == null)
1987           {
1988             _accessibilityManagerActionZoomEventHandler += value;
1989
1990             _accessibilityManagerActionZoomEventCallbackDelegate = new ActionZoomEventCallbackDelegate(OnActionZoom);
1991             this.ActionZoomSignal().Connect(_accessibilityManagerActionZoomEventCallbackDelegate);
1992           }
1993         }
1994       }
1995
1996       remove
1997       {
1998         lock(this)
1999         {
2000           if (_accessibilityManagerActionZoomEventHandler != null)
2001           {
2002             this.ActionZoomSignal().Disconnect(_accessibilityManagerActionZoomEventCallbackDelegate);
2003           }
2004
2005           _accessibilityManagerActionZoomEventHandler -= value;
2006         }
2007       }
2008     }
2009
2010     // Callback for AccessibilityManager ActionZoomSignal
2011     private bool OnActionZoom(IntPtr data)
2012     {
2013       ActionZoomEventArgs e = new ActionZoomEventArgs();
2014
2015       // Populate all members of "e" (ActionZoomEventArgs) with real data
2016       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2017
2018       if (_accessibilityManagerActionZoomEventHandler != null)
2019       {
2020         //here we send all data to user event handlers
2021         return _accessibilityManagerActionZoomEventHandler(this, e);
2022       }
2023       return false;
2024     }
2025
2026     public event ActionReadIndicatorInformationEventHandler ActionReadIndicatorInformation
2027     {
2028       add
2029       {
2030         lock(this)
2031         {
2032           // Restricted to only one listener
2033           if (_accessibilityManagerActionReadIndicatorInformationEventHandler == null)
2034           {
2035             _accessibilityManagerActionReadIndicatorInformationEventHandler += value;
2036
2037             _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate = new ActionReadIndicatorInformationEventCallbackDelegate(OnActionReadIndicatorInformation);
2038             this.ActionReadIndicatorInformationSignal().Connect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
2039           }
2040         }
2041       }
2042
2043       remove
2044       {
2045         lock(this)
2046         {
2047           if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
2048           {
2049             this.ActionReadIndicatorInformationSignal().Disconnect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
2050           }
2051
2052           _accessibilityManagerActionReadIndicatorInformationEventHandler -= value;
2053         }
2054       }
2055     }
2056
2057     // Callback for AccessibilityManager ActionReadIndicatorInformationSignal
2058     private bool OnActionReadIndicatorInformation(IntPtr data)
2059     {
2060       ActionReadIndicatorInformationEventArgs e = new ActionReadIndicatorInformationEventArgs();
2061
2062       // Populate all members of "e" (ActionReadIndicatorInformationEventArgs) with real data
2063       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2064
2065       if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
2066       {
2067         //here we send all data to user event handlers
2068         return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e);
2069       }
2070       return false;
2071     }
2072
2073     public event ActionReadPauseResumeEventHandler ActionReadPauseResume
2074     {
2075       add
2076       {
2077         lock(this)
2078         {
2079           // Restricted to only one listener
2080           if (_accessibilityManagerActionReadPauseResumeEventHandler == null)
2081           {
2082             _accessibilityManagerActionReadPauseResumeEventHandler += value;
2083
2084             _accessibilityManagerActionReadPauseResumeEventCallbackDelegate = new ActionReadPauseResumeEventCallbackDelegate(OnActionReadPauseResume);
2085             this.ActionReadPauseResumeSignal().Connect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
2086           }
2087         }
2088       }
2089
2090       remove
2091       {
2092         lock(this)
2093         {
2094           if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
2095           {
2096             this.ActionReadPauseResumeSignal().Disconnect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
2097           }
2098
2099           _accessibilityManagerActionReadPauseResumeEventHandler -= value;
2100         }
2101       }
2102     }
2103
2104     // Callback for AccessibilityManager ActionReadPauseResumeSignal
2105     private bool OnActionReadPauseResume(IntPtr data)
2106     {
2107       ActionReadPauseResumeEventArgs e = new ActionReadPauseResumeEventArgs();
2108
2109       // Populate all members of "e" (ActionReadPauseResumeEventArgs) with real data
2110       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2111
2112       if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
2113       {
2114         //here we send all data to user event handlers
2115         return _accessibilityManagerActionReadPauseResumeEventHandler(this, e);
2116       }
2117       return false;
2118     }
2119
2120     public event ActionStartStopEventHandler ActionStartStop
2121     {
2122       add
2123       {
2124         lock(this)
2125         {
2126           // Restricted to only one listener
2127           if (_accessibilityManagerActionStartStopEventHandler == null)
2128           {
2129             _accessibilityManagerActionStartStopEventHandler += value;
2130
2131             _accessibilityManagerActionStartStopEventCallbackDelegate = new ActionStartStopEventCallbackDelegate(OnActionStartStop);
2132             this.ActionStartStopSignal().Connect(_accessibilityManagerActionStartStopEventCallbackDelegate);
2133           }
2134         }
2135       }
2136
2137       remove
2138       {
2139         lock(this)
2140         {
2141           if (_accessibilityManagerActionStartStopEventHandler != null)
2142           {
2143             this.ActionStartStopSignal().Disconnect(_accessibilityManagerActionStartStopEventCallbackDelegate);
2144           }
2145
2146           _accessibilityManagerActionStartStopEventHandler -= value;
2147         }
2148       }
2149     }
2150
2151     // Callback for AccessibilityManager ActionStartStopSignal
2152     private bool OnActionStartStop(IntPtr data)
2153     {
2154       ActionStartStopEventArgs e = new ActionStartStopEventArgs();
2155
2156       // Populate all members of "e" (ActionStartStopEventArgs) with real data
2157       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2158
2159       if (_accessibilityManagerActionStartStopEventHandler != null)
2160       {
2161         //here we send all data to user event handlers
2162         return _accessibilityManagerActionStartStopEventHandler(this, e);
2163       }
2164       return false;
2165     }
2166
2167     public event ActionScrollEventHandler ActionScroll
2168     {
2169       add
2170       {
2171         lock(this)
2172         {
2173           // Restricted to only one listener
2174           if (_accessibilityManagerActionScrollEventHandler == null)
2175           {
2176             _accessibilityManagerActionScrollEventHandler += value;
2177
2178             _accessibilityManagerActionScrollEventCallbackDelegate = new ActionScrollEventCallbackDelegate(OnActionScroll);
2179             this.ActionScrollSignal().Connect(_accessibilityManagerActionScrollEventCallbackDelegate);
2180           }
2181         }
2182       }
2183
2184       remove
2185       {
2186         lock(this)
2187         {
2188           if (_accessibilityManagerActionScrollEventHandler != null)
2189           {
2190             this.ActionScrollSignal().Disconnect(_accessibilityManagerActionScrollEventCallbackDelegate);
2191           }
2192
2193           _accessibilityManagerActionScrollEventHandler -= value;
2194         }
2195       }
2196     }
2197
2198     // Callback for AccessibilityManager ActionScrollSignal
2199     private bool OnActionScroll(IntPtr accessibilityManager, IntPtr touchEvent)
2200     {
2201       ActionScrollEventArgs e = new ActionScrollEventArgs();
2202
2203       // Populate all members of "e" (ActionScrollEventArgs) with real data
2204       e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(accessibilityManager);
2205       e.TouchEvent = TouchEvent.GetTouchEventFromPtr(touchEvent);
2206
2207       if (_accessibilityManagerActionScrollEventHandler != null)
2208       {
2209         //here we send all data to user event handlers
2210         return _accessibilityManagerActionScrollEventHandler(this, e);
2211       }
2212       return false;
2213     }
2214
2215     public event FocusChangedEventHandler FocusChanged
2216     {
2217       add
2218       {
2219         lock(this)
2220         {
2221           // Restricted to only one listener
2222           if (_accessibilityManagerFocusChangedEventHandler == null)
2223           {
2224             _accessibilityManagerFocusChangedEventHandler += value;
2225
2226             _accessibilityManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
2227             this.FocusChangedSignal().Connect(_accessibilityManagerFocusChangedEventCallbackDelegate);
2228           }
2229         }
2230       }
2231
2232       remove
2233       {
2234         lock(this)
2235         {
2236           if (_accessibilityManagerFocusChangedEventHandler != null)
2237           {
2238             this.FocusChangedSignal().Disconnect(_accessibilityManagerFocusChangedEventCallbackDelegate);
2239           }
2240
2241           _accessibilityManagerFocusChangedEventHandler -= value;
2242         }
2243       }
2244     }
2245
2246     // Callback for AccessibilityManager FocusChangedSignal
2247     private void OnFocusChanged(IntPtr actor1, IntPtr actor2)
2248     {
2249       FocusChangedEventArgs e = new FocusChangedEventArgs();
2250
2251       // Populate all members of "e" (FocusChangedEventArgs) with real data
2252       e.ActorCurrent = Actor.GetActorFromPtr(actor1);
2253       e.ActorNext = Actor.GetActorFromPtr(actor2);
2254
2255       if (_accessibilityManagerFocusChangedEventHandler != null)
2256       {
2257         //here we send all data to user event handlers
2258         _accessibilityManagerFocusChangedEventHandler(this, e);
2259       }
2260     }
2261
2262     public event FocusedActorActivatedEventHandler FocusedActorActivated
2263     {
2264       add
2265       {
2266         lock(this)
2267         {
2268           // Restricted to only one listener
2269           if (_accessibilityManagerFocusedActorActivatedEventHandler == null)
2270           {
2271             _accessibilityManagerFocusedActorActivatedEventHandler += value;
2272
2273             _accessibilityManagerFocusedActorActivatedEventCallbackDelegate = new FocusedActorActivatedEventCallbackDelegate(OnFocusedActorActivated);
2274             this.FocusedActorActivatedSignal().Connect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
2275           }
2276         }
2277       }
2278
2279       remove
2280       {
2281         lock(this)
2282         {
2283           if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
2284           {
2285             this.FocusedActorActivatedSignal().Disconnect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
2286           }
2287
2288           _accessibilityManagerFocusedActorActivatedEventHandler -= value;
2289         }
2290       }
2291     }
2292
2293     // Callback for AccessibilityManager FocusedActorActivatedSignal
2294     private void OnFocusedActorActivated(IntPtr actor)
2295     {
2296       FocusedActorActivatedEventArgs e = new FocusedActorActivatedEventArgs();
2297
2298       // Populate all members of "e" (FocusedActorActivatedEventArgs) with real data
2299       e.Actor = Actor.GetActorFromPtr(actor);
2300
2301       if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
2302       {
2303         //here we send all data to user event handlers
2304         _accessibilityManagerFocusedActorActivatedEventHandler(this, e);
2305       }
2306     }
2307
2308
2309     public event FocusOvershotEventHandler FocusOvershot
2310     {
2311       add
2312       {
2313         lock(this)
2314         {
2315           // Restricted to only one listener
2316           if (_accessibilityManagerFocusOvershotEventHandler == null)
2317           {
2318             _accessibilityManagerFocusOvershotEventHandler += value;
2319
2320             _accessibilityManagerFocusOvershotEventCallbackDelegate = new FocusOvershotEventCallbackDelegate(OnFocusOvershot);
2321             this.FocusOvershotSignal().Connect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
2322           }
2323         }
2324       }
2325
2326       remove
2327       {
2328         lock(this)
2329         {
2330           if (_accessibilityManagerFocusOvershotEventHandler != null)
2331           {
2332             this.FocusOvershotSignal().Disconnect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
2333           }
2334
2335           _accessibilityManagerFocusOvershotEventHandler -= value;
2336         }
2337       }
2338     }
2339
2340     // Callback for AccessibilityManager FocusOvershotSignal
2341     private void OnFocusOvershot(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction)
2342     {
2343       FocusOvershotEventArgs e = new FocusOvershotEventArgs();
2344
2345       // Populate all members of "e" (FocusOvershotEventArgs) with real data
2346       e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
2347       e.FocusOvershotDirection = direction;
2348
2349       if (_accessibilityManagerFocusOvershotEventHandler != null)
2350       {
2351         //here we send all data to user event handlers
2352         _accessibilityManagerFocusOvershotEventHandler(this, e);
2353       }
2354     }
2355
2356
2357     public static ClassName Get ## ClassName ## FromPtr(global::System.IntPtr cPtr) {
2358       ClassName ret = new ClassName(cPtr, false);
2359       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2360       return ret;
2361     }
2362
2363     %}
2364     %enddef
2365
2366 %define DALI_ACCESSIBILITY_EVENTHANDLER_PARAM( NameSpace, ClassName)
2367   ACCESSIBILITY_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
2368   ACCESSIBILITY_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
2369   %enddef
2370
2371   namespace Dali
2372 {
2373   DALI_ACCESSIBILITY_EVENTHANDLER_PARAM( Dali::Toolkit, AccessibilityManager);
2374 }
2375
2376