2 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 %define ACCESSIBILITY_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
19 %typemap(csimports) NameSpace::ClassName %{
21 using System.Runtime.InteropServices;
27 %define ACCESSIBILITY_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
28 %typemap(cscode) NameSpace::ClassName %{
32 * @brief Event arguments that passed via StatusChanged signal
35 public class StatusChangedEventArgs : EventArgs
37 private AccessibilityManager _accessibilityManager;
39 public AccessibilityManager AccessibilityManager
43 return _accessibilityManager;
47 _accessibilityManager = value;
53 * @brief Event arguments that passed via ActionNext signal
56 public class ActionNextEventArgs : EventArgs
58 private AccessibilityManager _accessibilityManager;
60 public AccessibilityManager AccessibilityManager
64 return _accessibilityManager;
68 _accessibilityManager = value;
74 * @brief Event arguments that passed via ActionPrevious signal
77 public class ActionPreviousEventArgs : EventArgs
79 private AccessibilityManager _accessibilityManager;
81 public AccessibilityManager AccessibilityManager
85 return _accessibilityManager;
89 _accessibilityManager = value;
95 * @brief Event arguments that passed via ActionActivate signal
98 public class ActionActivateEventArgs : EventArgs
100 private AccessibilityManager _accessibilityManager;
102 public AccessibilityManager AccessibilityManager
106 return _accessibilityManager;
110 _accessibilityManager = value;
116 * @brief Event arguments that passed via ActionRead signal
119 public class ActionReadEventArgs : EventArgs
121 private AccessibilityManager _accessibilityManager;
123 public AccessibilityManager AccessibilityManager
127 return _accessibilityManager;
131 _accessibilityManager = value;
137 * @brief Event arguments that passed via ActionOver signal
140 public class ActionOverEventArgs : EventArgs
142 private AccessibilityManager _accessibilityManager;
144 public AccessibilityManager AccessibilityManager
148 return _accessibilityManager;
152 _accessibilityManager = value;
158 * @brief Event arguments that passed via ActionReadNext signal
161 public class ActionReadNextEventArgs : EventArgs
163 private AccessibilityManager _accessibilityManager;
165 public AccessibilityManager AccessibilityManager
169 return _accessibilityManager;
173 _accessibilityManager = value;
179 * @brief Event arguments that passed via ActionReadPrevious signal
182 public class ActionReadPreviousEventArgs : EventArgs
184 private AccessibilityManager _accessibilityManager;
186 public AccessibilityManager AccessibilityManager
190 return _accessibilityManager;
194 _accessibilityManager = value;
200 * @brief Event arguments that passed via ActionUp signal
203 public class ActionUpEventArgs : EventArgs
205 private AccessibilityManager _accessibilityManager;
207 public AccessibilityManager AccessibilityManager
211 return _accessibilityManager;
215 _accessibilityManager = value;
221 * @brief Event arguments that passed via ActionDown signal
224 public class ActionDownEventArgs : EventArgs
226 private AccessibilityManager _accessibilityManager;
228 public AccessibilityManager AccessibilityManager
232 return _accessibilityManager;
236 _accessibilityManager = value;
242 * @brief Event arguments that passed via ActionClearFocus signal
245 public class ActionClearFocusEventArgs : EventArgs
247 private AccessibilityManager _accessibilityManager;
249 public AccessibilityManager AccessibilityManager
253 return _accessibilityManager;
257 _accessibilityManager = value;
263 * @brief Event arguments that passed via ActionBack signal
266 public class ActionBackEventArgs : EventArgs
268 private AccessibilityManager _accessibilityManager;
270 public AccessibilityManager AccessibilityManager
274 return _accessibilityManager;
278 _accessibilityManager = value;
284 * @brief Event arguments that passed via ActionScrollUp signal
287 public class ActionScrollUpEventArgs : EventArgs
289 private AccessibilityManager _accessibilityManager;
291 public AccessibilityManager AccessibilityManager
295 return _accessibilityManager;
299 _accessibilityManager = value;
305 * @brief Event arguments that passed via ActionScrollDown signal
308 public class ActionScrollDownEventArgs : EventArgs
310 private AccessibilityManager _accessibilityManager;
312 public AccessibilityManager AccessibilityManager
316 return _accessibilityManager;
320 _accessibilityManager = value;
326 * @brief Event arguments that passed via ActionPageLeft signal
329 public class ActionPageLeftEventArgs : EventArgs
331 private AccessibilityManager _accessibilityManager;
333 public AccessibilityManager AccessibilityManager
337 return _accessibilityManager;
341 _accessibilityManager = value;
347 * @brief Event arguments that passed via ActionPageRight signal
350 public class ActionPageRightEventArgs : EventArgs
352 private AccessibilityManager _accessibilityManager;
354 public AccessibilityManager AccessibilityManager
358 return _accessibilityManager;
362 _accessibilityManager = value;
368 * @brief Event arguments that passed via ActionPageUp signal
371 public class ActionPageUpEventArgs : EventArgs
373 private AccessibilityManager _accessibilityManager;
375 public AccessibilityManager AccessibilityManager
379 return _accessibilityManager;
383 _accessibilityManager = value;
389 * @brief Event arguments that passed via ActionPageDown signal
392 public class ActionPageDownEventArgs : EventArgs
394 private AccessibilityManager _accessibilityManager;
396 public AccessibilityManager AccessibilityManager
400 return _accessibilityManager;
404 _accessibilityManager = value;
410 * @brief Event arguments that passed via ActionMoveToFirst signal
413 public class ActionMoveToFirstEventArgs : EventArgs
415 private AccessibilityManager _accessibilityManager;
417 public AccessibilityManager AccessibilityManager
421 return _accessibilityManager;
425 _accessibilityManager = value;
431 * @brief Event arguments that passed via ActionMoveToLast signal
434 public class ActionMoveToLastEventArgs : EventArgs
436 private AccessibilityManager _accessibilityManager;
438 public AccessibilityManager AccessibilityManager
442 return _accessibilityManager;
446 _accessibilityManager = value;
452 * @brief Event arguments that passed via ActionReadFromTop signal
455 public class ActionReadFromTopEventArgs : EventArgs
457 private AccessibilityManager _accessibilityManager;
459 public AccessibilityManager AccessibilityManager
463 return _accessibilityManager;
467 _accessibilityManager = value;
473 * @brief Event arguments that passed via ActionReadFromNext signal
476 public class ActionReadFromNextEventArgs : EventArgs
478 private AccessibilityManager _accessibilityManager;
480 public AccessibilityManager AccessibilityManager
484 return _accessibilityManager;
488 _accessibilityManager = value;
494 * @brief Event arguments that passed via ActionZoom signal
497 public class ActionZoomEventArgs : EventArgs
499 private AccessibilityManager _accessibilityManager;
501 public AccessibilityManager AccessibilityManager
505 return _accessibilityManager;
509 _accessibilityManager = value;
515 * @brief Event arguments that passed via ActionReadIndicatorInformation signal
518 public class ActionReadIndicatorInformationEventArgs : EventArgs
520 private AccessibilityManager _accessibilityManager;
522 public AccessibilityManager AccessibilityManager
526 return _accessibilityManager;
530 _accessibilityManager = value;
536 * @brief Event arguments that passed via ActionReadPauseResume signal
539 public class ActionReadPauseResumeEventArgs : EventArgs
541 private AccessibilityManager _accessibilityManager;
543 public AccessibilityManager AccessibilityManager
547 return _accessibilityManager;
551 _accessibilityManager = value;
557 * @brief Event arguments that passed via ActionStartStop signal
560 public class ActionStartStopEventArgs : EventArgs
562 private AccessibilityManager _accessibilityManager;
564 public AccessibilityManager AccessibilityManager
568 return _accessibilityManager;
572 _accessibilityManager = value;
578 * @brief Event arguments that passed via ActionScroll signal
581 public class ActionScrollEventArgs : EventArgs
583 private AccessibilityManager _accessibilityManager;
584 private TouchEvent _touchEvent;
586 public AccessibilityManager AccessibilityManager
590 return _accessibilityManager;
594 _accessibilityManager = value;
598 public TouchEvent TouchEvent
612 * @brief Event arguments that passed via ActionPageUp signal
615 public class FocusChangedEventArgs : EventArgs
617 private Actor _actorCurrent;
618 private Actor _actorNext;
620 public Actor ActorCurrent
624 return _actorCurrent;
628 _actorCurrent = value;
632 public Actor ActorNext
646 * @brief Event arguments that passed via FocusedActorActivated signal
649 public class FocusedActorActivatedEventArgs : EventArgs
651 private Actor _actor;
668 * @brief Event arguments that passed via FocusOvershot signal
671 public class FocusOvershotEventArgs : EventArgs
673 private Actor _currentFocusedActor;
674 private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
676 public Actor CurrentFocusedActor
680 return _currentFocusedActor;
684 _currentFocusedActor = value;
688 public AccessibilityManager.FocusOvershotDirection FocusOvershotDirection
692 return _focusOvershotDirection;
696 _focusOvershotDirection = value;
702 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
703 public delegate bool StatusChangedEventHandler(object source, StatusChangedEventArgs e);
705 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
706 public delegate bool ActionNextEventHandler(object source, ActionNextEventArgs e);
708 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
709 public delegate bool ActionPreviousEventHandler(object source, ActionPreviousEventArgs e);
711 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
712 public delegate bool ActionActivateEventHandler(object source, ActionActivateEventArgs e);
714 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
715 public delegate bool ActionReadEventHandler(object source, ActionReadEventArgs e);
717 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
718 public delegate bool ActionOverEventHandler(object source, ActionOverEventArgs e);
720 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
721 public delegate bool ActionReadNextEventHandler(object source, ActionReadNextEventArgs e);
723 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
724 public delegate bool ActionReadPreviousEventHandler(object source, ActionReadPreviousEventArgs e);
726 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
727 public delegate bool ActionUpEventHandler(object source, ActionUpEventArgs e);
729 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
730 public delegate bool ActionDownEventHandler(object source, ActionDownEventArgs e);
732 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
733 public delegate bool ActionClearFocusEventHandler(object source, ActionClearFocusEventArgs e);
735 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
736 public delegate bool ActionBackEventHandler(object source, ActionBackEventArgs e);
738 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
739 public delegate bool ActionScrollUpEventHandler(object source, ActionScrollUpEventArgs e);
741 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
742 public delegate bool ActionScrollDownEventHandler(object source, ActionScrollDownEventArgs e);
744 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
745 public delegate bool ActionPageLeftEventHandler(object source, ActionPageLeftEventArgs e);
747 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
748 public delegate bool ActionPageRightEventHandler(object source, ActionPageRightEventArgs e);
750 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
751 public delegate bool ActionPageUpEventHandler(object source, ActionPageUpEventArgs e);
753 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
754 public delegate bool ActionPageDownEventHandler(object source, ActionPageDownEventArgs e);
756 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
757 public delegate bool ActionMoveToFirstEventHandler(object source, ActionMoveToFirstEventArgs e);
759 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
760 public delegate bool ActionMoveToLastEventHandler(object source, ActionMoveToLastEventArgs e);
762 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
763 public delegate bool ActionReadFromTopEventHandler(object source, ActionReadFromTopEventArgs e);
765 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
766 public delegate bool ActionReadFromNextEventHandler(object source, ActionReadFromNextEventArgs e);
768 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
769 public delegate bool ActionZoomEventHandler(object source, ActionZoomEventArgs e);
771 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
772 public delegate bool ActionReadIndicatorInformationEventHandler(object source, ActionReadIndicatorInformationEventArgs e);
774 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
775 public delegate bool ActionReadPauseResumeEventHandler(object source, ActionReadPauseResumeEventArgs e);
777 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
778 public delegate bool ActionStartStopEventHandler(object source, ActionStartStopEventArgs e);
780 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
781 public delegate bool ActionScrollEventHandler(object source, ActionScrollEventArgs e);
783 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
784 public delegate void FocusChangedEventHandler(object source, FocusChangedEventArgs e);
786 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
787 public delegate void FocusedActorActivatedEventHandler(object source, FocusedActorActivatedEventArgs e);
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;
796 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
797 private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
798 private ActionNextEventHandler _accessibilityManagerActionNextEventHandler;
799 private ActionNextEventCallbackDelegate _accessibilityManagerActionNextEventCallbackDelegate;
801 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
802 private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
803 private ActionPreviousEventHandler _accessibilityManagerActionPreviousEventHandler;
804 private ActionPreviousEventCallbackDelegate _accessibilityManagerActionPreviousEventCallbackDelegate;
806 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
807 private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
808 private ActionActivateEventHandler _accessibilityManagerActionActivateEventHandler;
809 private ActionActivateEventCallbackDelegate _accessibilityManagerActionActivateEventCallbackDelegate;
811 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
812 private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
813 private ActionReadEventHandler _accessibilityManagerActionReadEventHandler;
814 private ActionReadEventCallbackDelegate _accessibilityManagerActionReadEventCallbackDelegate;
816 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
817 private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
818 private ActionOverEventHandler _accessibilityManagerActionOverEventHandler;
819 private ActionOverEventCallbackDelegate _accessibilityManagerActionOverEventCallbackDelegate;
821 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
822 private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
823 private ActionReadNextEventHandler _accessibilityManagerActionReadNextEventHandler;
824 private ActionReadNextEventCallbackDelegate _accessibilityManagerActionReadNextEventCallbackDelegate;
826 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
827 private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
828 private ActionReadPreviousEventHandler _accessibilityManagerActionReadPreviousEventHandler;
829 private ActionReadPreviousEventCallbackDelegate _accessibilityManagerActionReadPreviousEventCallbackDelegate;
831 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
832 private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
833 private ActionUpEventHandler _accessibilityManagerActionUpEventHandler;
834 private ActionUpEventCallbackDelegate _accessibilityManagerActionUpEventCallbackDelegate;
836 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
837 private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
838 private ActionDownEventHandler _accessibilityManagerActionDownEventHandler;
839 private ActionDownEventCallbackDelegate _accessibilityManagerActionDownEventCallbackDelegate;
841 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
842 private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
843 private ActionClearFocusEventHandler _accessibilityManagerActionClearFocusEventHandler;
844 private ActionClearFocusEventCallbackDelegate _accessibilityManagerActionClearFocusEventCallbackDelegate;
846 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
847 private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
848 private ActionBackEventHandler _accessibilityManagerActionBackEventHandler;
849 private ActionBackEventCallbackDelegate _accessibilityManagerActionBackEventCallbackDelegate;
851 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
852 private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
853 private ActionScrollUpEventHandler _accessibilityManagerActionScrollUpEventHandler;
854 private ActionScrollUpEventCallbackDelegate _accessibilityManagerActionScrollUpEventCallbackDelegate;
856 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
857 private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
858 private ActionScrollDownEventHandler _accessibilityManagerActionScrollDownEventHandler;
859 private ActionScrollDownEventCallbackDelegate _accessibilityManagerActionScrollDownEventCallbackDelegate;
861 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
862 private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
863 private ActionPageLeftEventHandler _accessibilityManagerActionPageLeftEventHandler;
864 private ActionPageLeftEventCallbackDelegate _accessibilityManagerActionPageLeftEventCallbackDelegate;
866 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
867 private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
868 private ActionPageRightEventHandler _accessibilityManagerActionPageRightEventHandler;
869 private ActionPageRightEventCallbackDelegate _accessibilityManagerActionPageRightEventCallbackDelegate;
871 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
872 private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
873 private ActionPageUpEventHandler _accessibilityManagerActionPageUpEventHandler;
874 private ActionPageUpEventCallbackDelegate _accessibilityManagerActionPageUpEventCallbackDelegate;
876 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
877 private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
878 private ActionPageDownEventHandler _accessibilityManagerActionPageDownEventHandler;
879 private ActionPageDownEventCallbackDelegate _accessibilityManagerActionPageDownEventCallbackDelegate;
881 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
882 private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
883 private ActionMoveToFirstEventHandler _accessibilityManagerActionMoveToFirstEventHandler;
884 private ActionMoveToFirstEventCallbackDelegate _accessibilityManagerActionMoveToFirstEventCallbackDelegate;
886 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
887 private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
888 private ActionMoveToLastEventHandler _accessibilityManagerActionMoveToLastEventHandler;
889 private ActionMoveToLastEventCallbackDelegate _accessibilityManagerActionMoveToLastEventCallbackDelegate;
891 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
892 private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
893 private ActionReadFromTopEventHandler _accessibilityManagerActionReadFromTopEventHandler;
894 private ActionReadFromTopEventCallbackDelegate _accessibilityManagerActionReadFromTopEventCallbackDelegate;
896 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
897 private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
898 private ActionReadFromNextEventHandler _accessibilityManagerActionReadFromNextEventHandler;
899 private ActionReadFromNextEventCallbackDelegate _accessibilityManagerActionReadFromNextEventCallbackDelegate;
901 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
902 private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
903 private ActionZoomEventHandler _accessibilityManagerActionZoomEventHandler;
904 private ActionZoomEventCallbackDelegate _accessibilityManagerActionZoomEventCallbackDelegate;
906 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
907 private delegate bool ActionReadIndicatorInformationEventCallbackDelegate(IntPtr accessibilityManager);
908 private ActionReadIndicatorInformationEventHandler _accessibilityManagerActionReadIndicatorInformationEventHandler;
909 private ActionReadIndicatorInformationEventCallbackDelegate _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate;
911 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
912 private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
913 private ActionReadPauseResumeEventHandler _accessibilityManagerActionReadPauseResumeEventHandler;
914 private ActionReadPauseResumeEventCallbackDelegate _accessibilityManagerActionReadPauseResumeEventCallbackDelegate;
916 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
917 private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
918 private ActionStartStopEventHandler _accessibilityManagerActionStartStopEventHandler;
919 private ActionStartStopEventCallbackDelegate _accessibilityManagerActionStartStopEventCallbackDelegate;
921 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
922 private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
923 private ActionScrollEventHandler _accessibilityManagerActionScrollEventHandler;
924 private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;
926 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
927 private delegate void FocusChangedEventCallbackDelegate(IntPtr actor1, IntPtr actor2);
928 private FocusChangedEventHandler _accessibilityManagerFocusChangedEventHandler;
929 private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
931 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
932 private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
933 private FocusedActorActivatedEventHandler _accessibilityManagerFocusedActorActivatedEventHandler;
934 private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;
936 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
937 private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
938 private FocusOvershotEventHandler _accessibilityManagerFocusOvershotEventHandler;
939 private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
941 public event StatusChangedEventHandler StatusChanged
947 // Restricted to only one listener
948 if (_accessibilityManagerStatusChangedEventHandler == null)
950 _accessibilityManagerStatusChangedEventHandler += value;
952 _accessibilityManagerStatusChangedEventCallbackDelegate = new StatusChangedEventCallbackDelegate(OnStatusChanged);
953 this.StatusChangedSignal().Connect(_accessibilityManagerStatusChangedEventCallbackDelegate);
962 if (_accessibilityManagerStatusChangedEventHandler != null)
964 this.StatusChangedSignal().Disconnect(_accessibilityManagerStatusChangedEventCallbackDelegate);
967 _accessibilityManagerStatusChangedEventHandler -= value;
972 // Callback for AccessibilityManager StatusChangedSignal
973 private bool OnStatusChanged(IntPtr data)
975 StatusChangedEventArgs e = new StatusChangedEventArgs();
977 // Populate all members of "e" (StatusChangedEventArgs) with real data
978 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
980 if (_accessibilityManagerStatusChangedEventHandler != null)
982 //here we send all data to user event handlers
983 return _accessibilityManagerStatusChangedEventHandler(this, e);
988 public event ActionNextEventHandler ActionNext
994 // Restricted to only one listener
995 if (_accessibilityManagerActionNextEventHandler == null)
997 _accessibilityManagerActionNextEventHandler += value;
999 _accessibilityManagerActionNextEventCallbackDelegate = new ActionNextEventCallbackDelegate(OnActionNext);
1000 this.ActionNextSignal().Connect(_accessibilityManagerActionNextEventCallbackDelegate);
1009 if (_accessibilityManagerActionNextEventHandler != null)
1011 this.ActionNextSignal().Disconnect(_accessibilityManagerActionNextEventCallbackDelegate);
1014 _accessibilityManagerActionNextEventHandler -= value;
1019 // Callback for AccessibilityManager ActionNextSignal
1020 private bool OnActionNext(IntPtr data)
1022 ActionNextEventArgs e = new ActionNextEventArgs();
1024 // Populate all members of "e" (ActionNextEventArgs) with real data
1025 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1027 if (_accessibilityManagerActionNextEventHandler != null)
1029 //here we send all data to user event handlers
1030 return _accessibilityManagerActionNextEventHandler(this, e);
1035 public event ActionPreviousEventHandler ActionPrevious
1041 // Restricted to only one listener
1042 if (_accessibilityManagerActionPreviousEventHandler == null)
1044 _accessibilityManagerActionPreviousEventHandler += value;
1046 _accessibilityManagerActionPreviousEventCallbackDelegate = new ActionPreviousEventCallbackDelegate(OnActionPrevious);
1047 this.ActionPreviousSignal().Connect(_accessibilityManagerActionPreviousEventCallbackDelegate);
1056 if (_accessibilityManagerActionPreviousEventHandler != null)
1058 this.ActionPreviousSignal().Disconnect(_accessibilityManagerActionPreviousEventCallbackDelegate);
1061 _accessibilityManagerActionPreviousEventHandler -= value;
1066 // Callback for AccessibilityManager ActionPreviousSignal
1067 private bool OnActionPrevious(IntPtr data)
1069 ActionPreviousEventArgs e = new ActionPreviousEventArgs();
1071 // Populate all members of "e" (ActionPreviousEventArgs) with real data
1072 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1074 if (_accessibilityManagerActionPreviousEventHandler != null)
1076 //here we send all data to user event handlers
1077 return _accessibilityManagerActionPreviousEventHandler(this, e);
1082 public event ActionActivateEventHandler ActionActivate
1088 // Restricted to only one listener
1089 if (_accessibilityManagerActionActivateEventHandler == null)
1091 _accessibilityManagerActionActivateEventHandler += value;
1093 _accessibilityManagerActionActivateEventCallbackDelegate = new ActionActivateEventCallbackDelegate(OnActionActivate);
1094 this.ActionActivateSignal().Connect(_accessibilityManagerActionActivateEventCallbackDelegate);
1103 if (_accessibilityManagerActionActivateEventHandler != null)
1105 this.ActionActivateSignal().Disconnect(_accessibilityManagerActionActivateEventCallbackDelegate);
1108 _accessibilityManagerActionActivateEventHandler -= value;
1113 // Callback for AccessibilityManager ActionActivateSignal
1114 private bool OnActionActivate(IntPtr data)
1116 ActionActivateEventArgs e = new ActionActivateEventArgs();
1118 // Populate all members of "e" (ActionActivateEventArgs) with real data
1119 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1121 if (_accessibilityManagerActionActivateEventHandler != null)
1123 //here we send all data to user event handlers
1124 return _accessibilityManagerActionActivateEventHandler(this, e);
1129 public event ActionReadEventHandler ActionRead
1135 // Restricted to only one listener
1136 if (_accessibilityManagerActionReadEventHandler == null)
1138 _accessibilityManagerActionReadEventHandler += value;
1140 _accessibilityManagerActionReadEventCallbackDelegate = new ActionReadEventCallbackDelegate(OnActionRead);
1141 this.ActionReadSignal().Connect(_accessibilityManagerActionReadEventCallbackDelegate);
1150 if (_accessibilityManagerActionReadEventHandler != null)
1152 this.ActionReadSignal().Disconnect(_accessibilityManagerActionReadEventCallbackDelegate);
1155 _accessibilityManagerActionReadEventHandler -= value;
1160 // Callback for AccessibilityManager ActionReadSignal
1161 private bool OnActionRead(IntPtr data)
1163 ActionReadEventArgs e = new ActionReadEventArgs();
1165 // Populate all members of "e" (ActionReadEventArgs) with real data
1166 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1168 if (_accessibilityManagerActionReadEventHandler != null)
1170 //here we send all data to user event handlers
1171 return _accessibilityManagerActionReadEventHandler(this, e);
1176 public event ActionOverEventHandler ActionOver
1182 // Restricted to only one listener
1183 if (_accessibilityManagerActionOverEventHandler == null)
1185 _accessibilityManagerActionOverEventHandler += value;
1187 _accessibilityManagerActionOverEventCallbackDelegate = new ActionOverEventCallbackDelegate(OnActionOver);
1188 this.ActionOverSignal().Connect(_accessibilityManagerActionOverEventCallbackDelegate);
1197 if (_accessibilityManagerActionOverEventHandler != null)
1199 this.ActionOverSignal().Disconnect(_accessibilityManagerActionOverEventCallbackDelegate);
1202 _accessibilityManagerActionOverEventHandler -= value;
1207 // Callback for AccessibilityManager ActionOverSignal
1208 private bool OnActionOver(IntPtr data)
1210 ActionOverEventArgs e = new ActionOverEventArgs();
1212 // Populate all members of "e" (ActionOverEventArgs) with real data
1213 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1215 if (_accessibilityManagerActionOverEventHandler != null)
1217 //here we send all data to user event handlers
1218 return _accessibilityManagerActionOverEventHandler(this, e);
1223 public event ActionReadNextEventHandler ActionReadNext
1229 // Restricted to only one listener
1230 if (_accessibilityManagerActionReadNextEventHandler == null)
1232 _accessibilityManagerActionReadNextEventHandler += value;
1234 _accessibilityManagerActionReadNextEventCallbackDelegate = new ActionReadNextEventCallbackDelegate(OnActionReadNext);
1235 this.ActionReadNextSignal().Connect(_accessibilityManagerActionReadNextEventCallbackDelegate);
1244 if (_accessibilityManagerActionReadNextEventHandler != null)
1246 this.ActionReadNextSignal().Disconnect(_accessibilityManagerActionReadNextEventCallbackDelegate);
1249 _accessibilityManagerActionReadNextEventHandler -= value;
1254 // Callback for AccessibilityManager ActionReadNextSignal
1255 private bool OnActionReadNext(IntPtr data)
1257 ActionReadNextEventArgs e = new ActionReadNextEventArgs();
1259 // Populate all members of "e" (ActionReadNextEventArgs) with real data
1260 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1262 if (_accessibilityManagerActionReadNextEventHandler != null)
1264 //here we send all data to user event handlers
1265 return _accessibilityManagerActionReadNextEventHandler(this, e);
1271 public event ActionReadPreviousEventHandler ActionReadPrevious
1277 // Restricted to only one listener
1278 if (_accessibilityManagerActionReadPreviousEventHandler == null)
1280 _accessibilityManagerActionReadPreviousEventHandler += value;
1282 _accessibilityManagerActionReadPreviousEventCallbackDelegate = new ActionReadPreviousEventCallbackDelegate(OnActionReadPrevious);
1283 this.ActionReadPreviousSignal().Connect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
1292 if (_accessibilityManagerActionReadPreviousEventHandler != null)
1294 this.ActionReadPreviousSignal().Disconnect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
1297 _accessibilityManagerActionReadPreviousEventHandler -= value;
1302 // Callback for AccessibilityManager ActionReadPreviousSignal
1303 private bool OnActionReadPrevious(IntPtr data)
1305 ActionReadPreviousEventArgs e = new ActionReadPreviousEventArgs();
1307 // Populate all members of "e" (ActionReadPreviousEventArgs) with real data
1308 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1310 if (_accessibilityManagerActionReadPreviousEventHandler != null)
1312 //here we send all data to user event handlers
1313 return _accessibilityManagerActionReadPreviousEventHandler(this, e);
1318 public event ActionUpEventHandler ActionUp
1324 // Restricted to only one listener
1325 if (_accessibilityManagerActionUpEventHandler == null)
1327 _accessibilityManagerActionUpEventHandler += value;
1329 _accessibilityManagerActionUpEventCallbackDelegate = new ActionUpEventCallbackDelegate(OnActionUp);
1330 this.ActionUpSignal().Connect(_accessibilityManagerActionUpEventCallbackDelegate);
1339 if (_accessibilityManagerActionUpEventHandler != null)
1341 this.ActionUpSignal().Disconnect(_accessibilityManagerActionUpEventCallbackDelegate);
1344 _accessibilityManagerActionUpEventHandler -= value;
1349 // Callback for AccessibilityManager ActionUpSignal
1350 private bool OnActionUp(IntPtr data)
1352 ActionUpEventArgs e = new ActionUpEventArgs();
1354 // Populate all members of "e" (ActionUpEventArgs) with real data
1355 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1357 if (_accessibilityManagerActionUpEventHandler != null)
1359 //here we send all data to user event handlers
1360 return _accessibilityManagerActionUpEventHandler(this, e);
1365 public event ActionDownEventHandler ActionDown
1371 // Restricted to only one listener
1372 if (_accessibilityManagerActionDownEventHandler == null)
1374 _accessibilityManagerActionDownEventHandler += value;
1376 _accessibilityManagerActionDownEventCallbackDelegate = new ActionDownEventCallbackDelegate(OnActionDown);
1377 this.ActionDownSignal().Connect(_accessibilityManagerActionDownEventCallbackDelegate);
1386 if (_accessibilityManagerActionDownEventHandler != null)
1388 this.ActionDownSignal().Disconnect(_accessibilityManagerActionDownEventCallbackDelegate);
1391 _accessibilityManagerActionDownEventHandler -= value;
1396 // Callback for AccessibilityManager ActionDownSignal
1397 private bool OnActionDown(IntPtr data)
1399 ActionDownEventArgs e = new ActionDownEventArgs();
1401 // Populate all members of "e" (ActionDownEventArgs) with real data
1402 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1404 if (_accessibilityManagerActionDownEventHandler != null)
1406 //here we send all data to user event handlers
1407 return _accessibilityManagerActionDownEventHandler(this, e);
1412 public event ActionClearFocusEventHandler ActionClearFocus
1418 // Restricted to only one listener
1419 if (_accessibilityManagerActionClearFocusEventHandler == null)
1421 _accessibilityManagerActionClearFocusEventHandler += value;
1423 _accessibilityManagerActionClearFocusEventCallbackDelegate = new ActionClearFocusEventCallbackDelegate(OnActionClearFocus);
1424 this.ActionClearFocusSignal().Connect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
1433 if (_accessibilityManagerActionClearFocusEventHandler != null)
1435 this.ActionClearFocusSignal().Disconnect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
1438 _accessibilityManagerActionClearFocusEventHandler -= value;
1443 // Callback for AccessibilityManager ActionClearFocusSignal
1444 private bool OnActionClearFocus(IntPtr data)
1446 ActionClearFocusEventArgs e = new ActionClearFocusEventArgs();
1448 // Populate all members of "e" (ActionClearFocusEventArgs) with real data
1449 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1451 if (_accessibilityManagerActionClearFocusEventHandler != null)
1453 //here we send all data to user event handlers
1454 return _accessibilityManagerActionClearFocusEventHandler(this, e);
1459 public event ActionBackEventHandler ActionBack
1465 // Restricted to only one listener
1466 if (_accessibilityManagerActionBackEventHandler == null)
1468 _accessibilityManagerActionBackEventHandler += value;
1470 _accessibilityManagerActionBackEventCallbackDelegate = new ActionBackEventCallbackDelegate(OnActionBack);
1471 this.ActionBackSignal().Connect(_accessibilityManagerActionBackEventCallbackDelegate);
1480 if (_accessibilityManagerActionBackEventHandler != null)
1482 this.ActionBackSignal().Disconnect(_accessibilityManagerActionBackEventCallbackDelegate);
1485 _accessibilityManagerActionBackEventHandler -= value;
1490 // Callback for AccessibilityManager ActionBackSignal
1491 private bool OnActionBack(IntPtr data)
1493 ActionBackEventArgs e = new ActionBackEventArgs();
1495 // Populate all members of "e" (ActionBackEventArgs) with real data
1496 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1498 if (_accessibilityManagerActionBackEventHandler != null)
1500 //here we send all data to user event handlers
1501 return _accessibilityManagerActionBackEventHandler(this, e);
1506 public event ActionScrollUpEventHandler ActionScrollUp
1512 // Restricted to only one listener
1513 if (_accessibilityManagerActionScrollUpEventHandler == null)
1515 _accessibilityManagerActionScrollUpEventHandler += value;
1517 _accessibilityManagerActionScrollUpEventCallbackDelegate = new ActionScrollUpEventCallbackDelegate(OnActionScrollUp);
1518 this.ActionScrollUpSignal().Connect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
1527 if (_accessibilityManagerActionScrollUpEventHandler != null)
1529 this.ActionScrollUpSignal().Disconnect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
1532 _accessibilityManagerActionScrollUpEventHandler -= value;
1537 // Callback for AccessibilityManager ActionScrollUpSignal
1538 private bool OnActionScrollUp(IntPtr data)
1540 ActionScrollUpEventArgs e = new ActionScrollUpEventArgs();
1542 // Populate all members of "e" (ActionScrollUpEventArgs) with real data
1543 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1545 if (_accessibilityManagerActionScrollUpEventHandler != null)
1547 //here we send all data to user event handlers
1548 return _accessibilityManagerActionScrollUpEventHandler(this, e);
1553 public event ActionScrollDownEventHandler ActionScrollDown
1559 // Restricted to only one listener
1560 if (_accessibilityManagerActionScrollDownEventHandler == null)
1562 _accessibilityManagerActionScrollDownEventHandler += value;
1564 _accessibilityManagerActionScrollDownEventCallbackDelegate = new ActionScrollDownEventCallbackDelegate(OnActionScrollDown);
1565 this.ActionScrollDownSignal().Connect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
1574 if (_accessibilityManagerActionScrollDownEventHandler != null)
1576 this.ActionScrollDownSignal().Disconnect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
1579 _accessibilityManagerActionScrollDownEventHandler -= value;
1584 // Callback for AccessibilityManager ActionScrollDownSignal
1585 private bool OnActionScrollDown(IntPtr data)
1587 ActionScrollDownEventArgs e = new ActionScrollDownEventArgs();
1589 // Populate all members of "e" (ActionScrollDownEventArgs) with real data
1590 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1592 if (_accessibilityManagerActionScrollDownEventHandler != null)
1594 //here we send all data to user event handlers
1595 return _accessibilityManagerActionScrollDownEventHandler(this, e);
1601 public event ActionPageLeftEventHandler ActionPageLeft
1607 // Restricted to only one listener
1608 if (_accessibilityManagerActionPageLeftEventHandler == null)
1610 _accessibilityManagerActionPageLeftEventHandler += value;
1612 _accessibilityManagerActionPageLeftEventCallbackDelegate = new ActionPageLeftEventCallbackDelegate(OnActionPageLeft);
1613 this.ActionPageLeftSignal().Connect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
1622 if (_accessibilityManagerActionPageLeftEventHandler != null)
1624 this.ActionPageLeftSignal().Disconnect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
1627 _accessibilityManagerActionPageLeftEventHandler -= value;
1632 // Callback for AccessibilityManager ActionPageLeftSignal
1633 private bool OnActionPageLeft(IntPtr data)
1635 ActionPageLeftEventArgs e = new ActionPageLeftEventArgs();
1637 // Populate all members of "e" (ActionPageLeftEventArgs) with real data
1638 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1640 if (_accessibilityManagerActionPageLeftEventHandler != null)
1642 //here we send all data to user event handlers
1643 return _accessibilityManagerActionPageLeftEventHandler(this, e);
1648 public event ActionPageRightEventHandler ActionPageRight
1654 // Restricted to only one listener
1655 if (_accessibilityManagerActionPageRightEventHandler == null)
1657 _accessibilityManagerActionPageRightEventHandler += value;
1659 _accessibilityManagerActionPageRightEventCallbackDelegate = new ActionPageRightEventCallbackDelegate(OnActionPageRight);
1660 this.ActionPageRightSignal().Connect(_accessibilityManagerActionPageRightEventCallbackDelegate);
1669 if (_accessibilityManagerActionPageRightEventHandler != null)
1671 this.ActionPageRightSignal().Disconnect(_accessibilityManagerActionPageRightEventCallbackDelegate);
1674 _accessibilityManagerActionPageRightEventHandler -= value;
1679 // Callback for AccessibilityManager ActionPageRightSignal
1680 private bool OnActionPageRight(IntPtr data)
1682 ActionPageRightEventArgs e = new ActionPageRightEventArgs();
1684 // Populate all members of "e" (ActionPageRightEventArgs) with real data
1685 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1687 if (_accessibilityManagerActionPageRightEventHandler != null)
1689 //here we send all data to user event handlers
1690 return _accessibilityManagerActionPageRightEventHandler(this, e);
1695 public event ActionPageUpEventHandler ActionPageUp
1701 // Restricted to only one listener
1702 if (_accessibilityManagerActionPageUpEventHandler == null)
1704 _accessibilityManagerActionPageUpEventHandler += value;
1706 _accessibilityManagerActionPageUpEventCallbackDelegate = new ActionPageUpEventCallbackDelegate(OnActionPageUp);
1707 this.ActionPageUpSignal().Connect(_accessibilityManagerActionPageUpEventCallbackDelegate);
1716 if (_accessibilityManagerActionPageUpEventHandler != null)
1718 this.ActionPageUpSignal().Disconnect(_accessibilityManagerActionPageUpEventCallbackDelegate);
1721 _accessibilityManagerActionPageUpEventHandler -= value;
1726 // Callback for AccessibilityManager ActionPageUpSignal
1727 private bool OnActionPageUp(IntPtr data)
1729 ActionPageUpEventArgs e = new ActionPageUpEventArgs();
1731 // Populate all members of "e" (ActionPageUpEventArgs) with real data
1732 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1734 if (_accessibilityManagerActionPageUpEventHandler != null)
1736 //here we send all data to user event handlers
1737 return _accessibilityManagerActionPageUpEventHandler(this, e);
1743 public event ActionPageDownEventHandler ActionPageDown
1749 // Restricted to only one listener
1750 if (_accessibilityManagerActionPageDownEventHandler == null)
1752 _accessibilityManagerActionPageDownEventHandler += value;
1754 _accessibilityManagerActionPageDownEventCallbackDelegate = new ActionPageDownEventCallbackDelegate(OnActionPageDown);
1755 this.ActionPageDownSignal().Connect(_accessibilityManagerActionPageDownEventCallbackDelegate);
1764 if (_accessibilityManagerActionPageDownEventHandler != null)
1766 this.ActionPageDownSignal().Disconnect(_accessibilityManagerActionPageDownEventCallbackDelegate);
1769 _accessibilityManagerActionPageDownEventHandler -= value;
1774 // Callback for AccessibilityManager ActionPageDownSignal
1775 private bool OnActionPageDown(IntPtr data)
1777 ActionPageDownEventArgs e = new ActionPageDownEventArgs();
1779 // Populate all members of "e" (ActionPageDownEventArgs) with real data
1780 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1782 if (_accessibilityManagerActionPageDownEventHandler != null)
1784 //here we send all data to user event handlers
1785 return _accessibilityManagerActionPageDownEventHandler(this, e);
1791 public event ActionMoveToFirstEventHandler ActionMoveToFirst
1797 // Restricted to only one listener
1798 if (_accessibilityManagerActionMoveToFirstEventHandler == null)
1800 _accessibilityManagerActionMoveToFirstEventHandler += value;
1802 _accessibilityManagerActionMoveToFirstEventCallbackDelegate = new ActionMoveToFirstEventCallbackDelegate(OnActionMoveToFirst);
1803 this.ActionMoveToFirstSignal().Connect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
1812 if (_accessibilityManagerActionMoveToFirstEventHandler != null)
1814 this.ActionMoveToFirstSignal().Disconnect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
1817 _accessibilityManagerActionMoveToFirstEventHandler -= value;
1822 // Callback for AccessibilityManager ActionMoveToFirstSignal
1823 private bool OnActionMoveToFirst(IntPtr data)
1825 ActionMoveToFirstEventArgs e = new ActionMoveToFirstEventArgs();
1827 // Populate all members of "e" (ActionMoveToFirstEventArgs) with real data
1828 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1830 if (_accessibilityManagerActionMoveToFirstEventHandler != null)
1832 //here we send all data to user event handlers
1833 return _accessibilityManagerActionMoveToFirstEventHandler(this, e);
1838 public event ActionMoveToLastEventHandler ActionMoveToLast
1844 // Restricted to only one listener
1845 if (_accessibilityManagerActionMoveToLastEventHandler == null)
1847 _accessibilityManagerActionMoveToLastEventHandler += value;
1849 _accessibilityManagerActionMoveToLastEventCallbackDelegate = new ActionMoveToLastEventCallbackDelegate(OnActionMoveToLast);
1850 this.ActionMoveToLastSignal().Connect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
1859 if (_accessibilityManagerActionMoveToLastEventHandler != null)
1861 this.ActionMoveToLastSignal().Disconnect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
1864 _accessibilityManagerActionMoveToLastEventHandler -= value;
1869 // Callback for AccessibilityManager ActionMoveToLastSignal
1870 private bool OnActionMoveToLast(IntPtr data)
1872 ActionMoveToLastEventArgs e = new ActionMoveToLastEventArgs();
1874 // Populate all members of "e" (ActionMoveToLastEventArgs) with real data
1875 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1877 if (_accessibilityManagerActionMoveToLastEventHandler != null)
1879 //here we send all data to user event handlers
1880 return _accessibilityManagerActionMoveToLastEventHandler(this, e);
1885 public event ActionReadFromTopEventHandler ActionReadFromTop
1891 // Restricted to only one listener
1892 if (_accessibilityManagerActionReadFromTopEventHandler == null)
1894 _accessibilityManagerActionReadFromTopEventHandler += value;
1896 _accessibilityManagerActionReadFromTopEventCallbackDelegate = new ActionReadFromTopEventCallbackDelegate(OnActionReadFromTop);
1897 this.ActionReadFromTopSignal().Connect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
1906 if (_accessibilityManagerActionReadFromTopEventHandler != null)
1908 this.ActionReadFromTopSignal().Disconnect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
1911 _accessibilityManagerActionReadFromTopEventHandler -= value;
1916 // Callback for AccessibilityManager ActionReadFromTopSignal
1917 private bool OnActionReadFromTop(IntPtr data)
1919 ActionReadFromTopEventArgs e = new ActionReadFromTopEventArgs();
1921 // Populate all members of "e" (ActionReadFromTopEventArgs) with real data
1922 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1924 if (_accessibilityManagerActionReadFromTopEventHandler != null)
1926 //here we send all data to user event handlers
1927 return _accessibilityManagerActionReadFromTopEventHandler(this, e);
1932 public event ActionReadFromNextEventHandler ActionReadFromNext
1938 // Restricted to only one listener
1939 if (_accessibilityManagerActionReadFromNextEventHandler == null)
1941 _accessibilityManagerActionReadFromNextEventHandler += value;
1943 _accessibilityManagerActionReadFromNextEventCallbackDelegate = new ActionReadFromNextEventCallbackDelegate(OnActionReadFromNext);
1944 this.ActionReadFromNextSignal().Connect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
1953 if (_accessibilityManagerActionReadFromNextEventHandler != null)
1955 this.ActionReadFromNextSignal().Disconnect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
1958 _accessibilityManagerActionReadFromNextEventHandler -= value;
1963 // Callback for AccessibilityManager ActionReadFromNextSignal
1964 private bool OnActionReadFromNext(IntPtr data)
1966 ActionReadFromNextEventArgs e = new ActionReadFromNextEventArgs();
1968 // Populate all members of "e" (ActionReadFromNextEventArgs) with real data
1969 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
1971 if (_accessibilityManagerActionReadFromNextEventHandler != null)
1973 //here we send all data to user event handlers
1974 return _accessibilityManagerActionReadFromNextEventHandler(this, e);
1979 public event ActionZoomEventHandler ActionZoom
1985 // Restricted to only one listener
1986 if (_accessibilityManagerActionZoomEventHandler == null)
1988 _accessibilityManagerActionZoomEventHandler += value;
1990 _accessibilityManagerActionZoomEventCallbackDelegate = new ActionZoomEventCallbackDelegate(OnActionZoom);
1991 this.ActionZoomSignal().Connect(_accessibilityManagerActionZoomEventCallbackDelegate);
2000 if (_accessibilityManagerActionZoomEventHandler != null)
2002 this.ActionZoomSignal().Disconnect(_accessibilityManagerActionZoomEventCallbackDelegate);
2005 _accessibilityManagerActionZoomEventHandler -= value;
2010 // Callback for AccessibilityManager ActionZoomSignal
2011 private bool OnActionZoom(IntPtr data)
2013 ActionZoomEventArgs e = new ActionZoomEventArgs();
2015 // Populate all members of "e" (ActionZoomEventArgs) with real data
2016 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2018 if (_accessibilityManagerActionZoomEventHandler != null)
2020 //here we send all data to user event handlers
2021 return _accessibilityManagerActionZoomEventHandler(this, e);
2026 public event ActionReadIndicatorInformationEventHandler ActionReadIndicatorInformation
2032 // Restricted to only one listener
2033 if (_accessibilityManagerActionReadIndicatorInformationEventHandler == null)
2035 _accessibilityManagerActionReadIndicatorInformationEventHandler += value;
2037 _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate = new ActionReadIndicatorInformationEventCallbackDelegate(OnActionReadIndicatorInformation);
2038 this.ActionReadIndicatorInformationSignal().Connect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
2047 if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
2049 this.ActionReadIndicatorInformationSignal().Disconnect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
2052 _accessibilityManagerActionReadIndicatorInformationEventHandler -= value;
2057 // Callback for AccessibilityManager ActionReadIndicatorInformationSignal
2058 private bool OnActionReadIndicatorInformation(IntPtr data)
2060 ActionReadIndicatorInformationEventArgs e = new ActionReadIndicatorInformationEventArgs();
2062 // Populate all members of "e" (ActionReadIndicatorInformationEventArgs) with real data
2063 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2065 if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
2067 //here we send all data to user event handlers
2068 return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e);
2073 public event ActionReadPauseResumeEventHandler ActionReadPauseResume
2079 // Restricted to only one listener
2080 if (_accessibilityManagerActionReadPauseResumeEventHandler == null)
2082 _accessibilityManagerActionReadPauseResumeEventHandler += value;
2084 _accessibilityManagerActionReadPauseResumeEventCallbackDelegate = new ActionReadPauseResumeEventCallbackDelegate(OnActionReadPauseResume);
2085 this.ActionReadPauseResumeSignal().Connect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
2094 if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
2096 this.ActionReadPauseResumeSignal().Disconnect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
2099 _accessibilityManagerActionReadPauseResumeEventHandler -= value;
2104 // Callback for AccessibilityManager ActionReadPauseResumeSignal
2105 private bool OnActionReadPauseResume(IntPtr data)
2107 ActionReadPauseResumeEventArgs e = new ActionReadPauseResumeEventArgs();
2109 // Populate all members of "e" (ActionReadPauseResumeEventArgs) with real data
2110 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2112 if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
2114 //here we send all data to user event handlers
2115 return _accessibilityManagerActionReadPauseResumeEventHandler(this, e);
2120 public event ActionStartStopEventHandler ActionStartStop
2126 // Restricted to only one listener
2127 if (_accessibilityManagerActionStartStopEventHandler == null)
2129 _accessibilityManagerActionStartStopEventHandler += value;
2131 _accessibilityManagerActionStartStopEventCallbackDelegate = new ActionStartStopEventCallbackDelegate(OnActionStartStop);
2132 this.ActionStartStopSignal().Connect(_accessibilityManagerActionStartStopEventCallbackDelegate);
2141 if (_accessibilityManagerActionStartStopEventHandler != null)
2143 this.ActionStartStopSignal().Disconnect(_accessibilityManagerActionStartStopEventCallbackDelegate);
2146 _accessibilityManagerActionStartStopEventHandler -= value;
2151 // Callback for AccessibilityManager ActionStartStopSignal
2152 private bool OnActionStartStop(IntPtr data)
2154 ActionStartStopEventArgs e = new ActionStartStopEventArgs();
2156 // Populate all members of "e" (ActionStartStopEventArgs) with real data
2157 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
2159 if (_accessibilityManagerActionStartStopEventHandler != null)
2161 //here we send all data to user event handlers
2162 return _accessibilityManagerActionStartStopEventHandler(this, e);
2167 public event ActionScrollEventHandler ActionScroll
2173 // Restricted to only one listener
2174 if (_accessibilityManagerActionScrollEventHandler == null)
2176 _accessibilityManagerActionScrollEventHandler += value;
2178 _accessibilityManagerActionScrollEventCallbackDelegate = new ActionScrollEventCallbackDelegate(OnActionScroll);
2179 this.ActionScrollSignal().Connect(_accessibilityManagerActionScrollEventCallbackDelegate);
2188 if (_accessibilityManagerActionScrollEventHandler != null)
2190 this.ActionScrollSignal().Disconnect(_accessibilityManagerActionScrollEventCallbackDelegate);
2193 _accessibilityManagerActionScrollEventHandler -= value;
2198 // Callback for AccessibilityManager ActionScrollSignal
2199 private bool OnActionScroll(IntPtr accessibilityManager, IntPtr touchEvent)
2201 ActionScrollEventArgs e = new ActionScrollEventArgs();
2203 // Populate all members of "e" (ActionScrollEventArgs) with real data
2204 e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(accessibilityManager);
2205 e.TouchEvent = TouchEvent.GetTouchEventFromPtr(touchEvent);
2207 if (_accessibilityManagerActionScrollEventHandler != null)
2209 //here we send all data to user event handlers
2210 return _accessibilityManagerActionScrollEventHandler(this, e);
2215 public event FocusChangedEventHandler FocusChanged
2221 // Restricted to only one listener
2222 if (_accessibilityManagerFocusChangedEventHandler == null)
2224 _accessibilityManagerFocusChangedEventHandler += value;
2226 _accessibilityManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
2227 this.FocusChangedSignal().Connect(_accessibilityManagerFocusChangedEventCallbackDelegate);
2236 if (_accessibilityManagerFocusChangedEventHandler != null)
2238 this.FocusChangedSignal().Disconnect(_accessibilityManagerFocusChangedEventCallbackDelegate);
2241 _accessibilityManagerFocusChangedEventHandler -= value;
2246 // Callback for AccessibilityManager FocusChangedSignal
2247 private void OnFocusChanged(IntPtr actor1, IntPtr actor2)
2249 FocusChangedEventArgs e = new FocusChangedEventArgs();
2251 // Populate all members of "e" (FocusChangedEventArgs) with real data
2252 e.ActorCurrent = Actor.GetActorFromPtr(actor1);
2253 e.ActorNext = Actor.GetActorFromPtr(actor2);
2255 if (_accessibilityManagerFocusChangedEventHandler != null)
2257 //here we send all data to user event handlers
2258 _accessibilityManagerFocusChangedEventHandler(this, e);
2262 public event FocusedActorActivatedEventHandler FocusedActorActivated
2268 // Restricted to only one listener
2269 if (_accessibilityManagerFocusedActorActivatedEventHandler == null)
2271 _accessibilityManagerFocusedActorActivatedEventHandler += value;
2273 _accessibilityManagerFocusedActorActivatedEventCallbackDelegate = new FocusedActorActivatedEventCallbackDelegate(OnFocusedActorActivated);
2274 this.FocusedActorActivatedSignal().Connect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
2283 if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
2285 this.FocusedActorActivatedSignal().Disconnect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
2288 _accessibilityManagerFocusedActorActivatedEventHandler -= value;
2293 // Callback for AccessibilityManager FocusedActorActivatedSignal
2294 private void OnFocusedActorActivated(IntPtr actor)
2296 FocusedActorActivatedEventArgs e = new FocusedActorActivatedEventArgs();
2298 // Populate all members of "e" (FocusedActorActivatedEventArgs) with real data
2299 e.Actor = Actor.GetActorFromPtr(actor);
2301 if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
2303 //here we send all data to user event handlers
2304 _accessibilityManagerFocusedActorActivatedEventHandler(this, e);
2309 public event FocusOvershotEventHandler FocusOvershot
2315 // Restricted to only one listener
2316 if (_accessibilityManagerFocusOvershotEventHandler == null)
2318 _accessibilityManagerFocusOvershotEventHandler += value;
2320 _accessibilityManagerFocusOvershotEventCallbackDelegate = new FocusOvershotEventCallbackDelegate(OnFocusOvershot);
2321 this.FocusOvershotSignal().Connect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
2330 if (_accessibilityManagerFocusOvershotEventHandler != null)
2332 this.FocusOvershotSignal().Disconnect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
2335 _accessibilityManagerFocusOvershotEventHandler -= value;
2340 // Callback for AccessibilityManager FocusOvershotSignal
2341 private void OnFocusOvershot(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction)
2343 FocusOvershotEventArgs e = new FocusOvershotEventArgs();
2345 // Populate all members of "e" (FocusOvershotEventArgs) with real data
2346 e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
2347 e.FocusOvershotDirection = direction;
2349 if (_accessibilityManagerFocusOvershotEventHandler != null)
2351 //here we send all data to user event handlers
2352 _accessibilityManagerFocusOvershotEventHandler(this, e);
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();
2366 %define DALI_ACCESSIBILITY_EVENTHANDLER_PARAM( NameSpace, ClassName)
2367 ACCESSIBILITY_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
2368 ACCESSIBILITY_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
2373 DALI_ACCESSIBILITY_EVENTHANDLER_PARAM( Dali::Toolkit, AccessibilityManager);