//------------------------------------------------------------------------------
//
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 3.0.9
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
namespace Dali {
using System;
using System.Runtime.InteropServices;
public class AccessibilityManager : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal AccessibilityManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.AccessibilityManager_SWIGUpcast(cPtr), cMemoryOwn) {
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(AccessibilityManager obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
~AccessibilityManager() {
Dispose();
}
public override void Dispose() {
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
NDalicPINVOKE.delete_AccessibilityManager(swigCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
global::System.GC.SuppressFinalize(this);
base.Dispose();
}
}
/**
* @brief Event arguments that passed via StatusChanged signal
*
*/
public class StatusChangedEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionNext signal
*
*/
public class ActionNextEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionPrevious signal
*
*/
public class ActionPreviousEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionActivate signal
*
*/
public class ActionActivateEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionRead signal
*
*/
public class ActionReadEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionOver signal
*
*/
public class ActionOverEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionReadNext signal
*
*/
public class ActionReadNextEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionReadPrevious signal
*
*/
public class ActionReadPreviousEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionUp signal
*
*/
public class ActionUpEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionDown signal
*
*/
public class ActionDownEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionClearFocus signal
*
*/
public class ActionClearFocusEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionBack signal
*
*/
public class ActionBackEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionScrollUp signal
*
*/
public class ActionScrollUpEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionScrollDown signal
*
*/
public class ActionScrollDownEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionPageLeft signal
*
*/
public class ActionPageLeftEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionPageRight signal
*
*/
public class ActionPageRightEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionPageUp signal
*
*/
public class ActionPageUpEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionPageDown signal
*
*/
public class ActionPageDownEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionMoveToFirst signal
*
*/
public class ActionMoveToFirstEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionMoveToLast signal
*
*/
public class ActionMoveToLastEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionReadFromTop signal
*
*/
public class ActionReadFromTopEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionReadFromNext signal
*
*/
public class ActionReadFromNextEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionZoom signal
*
*/
public class ActionZoomEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionReadIndicatorInformation signal
*
*/
public class ActionReadIndicatorInformationEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionReadPauseResume signal
*
*/
public class ActionReadPauseResumeEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionStartStop signal
*
*/
public class ActionStartStopEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
}
/**
* @brief Event arguments that passed via ActionScroll signal
*
*/
public class ActionScrollEventArgs : EventArgs
{
private AccessibilityManager _accessibilityManager;
private TouchEvent _touchEvent;
public AccessibilityManager AccessibilityManager
{
get
{
return _accessibilityManager;
}
set
{
_accessibilityManager = value;
}
}
public TouchEvent TouchEvent
{
get
{
return _touchEvent;
}
set
{
_touchEvent = value;
}
}
}
/**
* @brief Event arguments that passed via ActionPageUp signal
*
*/
public class FocusChangedEventArgs : EventArgs
{
private Actor _actorCurrent;
private Actor _actorNext;
public Actor ActorCurrent
{
get
{
return _actorCurrent;
}
set
{
_actorCurrent = value;
}
}
public Actor ActorNext
{
get
{
return _actorNext;
}
set
{
_actorNext = value;
}
}
}
/**
* @brief Event arguments that passed via FocusedActorActivated signal
*
*/
public class FocusedActorActivatedEventArgs : EventArgs
{
private Actor _actor;
public Actor Actor
{
get
{
return _actor;
}
set
{
_actor = value;
}
}
}
/**
* @brief Event arguments that passed via FocusOvershot signal
*
*/
public class FocusOvershotEventArgs : EventArgs
{
private Actor _currentFocusedActor;
private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
public Actor CurrentFocusedActor
{
get
{
return _currentFocusedActor;
}
set
{
_currentFocusedActor = value;
}
}
public AccessibilityManager.FocusOvershotDirection FocusOvershotDirection
{
get
{
return _focusOvershotDirection;
}
set
{
_focusOvershotDirection = value;
}
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool StatusChangedEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerStatusChangedEventHandler;
private StatusChangedEventCallbackDelegate _accessibilityManagerStatusChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionNextEventHandler;
private ActionNextEventCallbackDelegate _accessibilityManagerActionNextEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionPreviousEventHandler;
private ActionPreviousEventCallbackDelegate _accessibilityManagerActionPreviousEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionActivateEventHandler;
private ActionActivateEventCallbackDelegate _accessibilityManagerActionActivateEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionReadEventHandler;
private ActionReadEventCallbackDelegate _accessibilityManagerActionReadEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionOverEventHandler;
private ActionOverEventCallbackDelegate _accessibilityManagerActionOverEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionReadNextEventHandler;
private ActionReadNextEventCallbackDelegate _accessibilityManagerActionReadNextEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionReadPreviousEventHandler;
private ActionReadPreviousEventCallbackDelegate _accessibilityManagerActionReadPreviousEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionUpEventHandler;
private ActionUpEventCallbackDelegate _accessibilityManagerActionUpEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionDownEventHandler;
private ActionDownEventCallbackDelegate _accessibilityManagerActionDownEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionClearFocusEventHandler;
private ActionClearFocusEventCallbackDelegate _accessibilityManagerActionClearFocusEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionBackEventHandler;
private ActionBackEventCallbackDelegate _accessibilityManagerActionBackEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionScrollUpEventHandler;
private ActionScrollUpEventCallbackDelegate _accessibilityManagerActionScrollUpEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionScrollDownEventHandler;
private ActionScrollDownEventCallbackDelegate _accessibilityManagerActionScrollDownEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionPageLeftEventHandler;
private ActionPageLeftEventCallbackDelegate _accessibilityManagerActionPageLeftEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionPageRightEventHandler;
private ActionPageRightEventCallbackDelegate _accessibilityManagerActionPageRightEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionPageUpEventHandler;
private ActionPageUpEventCallbackDelegate _accessibilityManagerActionPageUpEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionPageDownEventHandler;
private ActionPageDownEventCallbackDelegate _accessibilityManagerActionPageDownEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionMoveToFirstEventHandler;
private ActionMoveToFirstEventCallbackDelegate _accessibilityManagerActionMoveToFirstEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionMoveToLastEventHandler;
private ActionMoveToLastEventCallbackDelegate _accessibilityManagerActionMoveToLastEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionReadFromTopEventHandler;
private ActionReadFromTopEventCallbackDelegate _accessibilityManagerActionReadFromTopEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionReadFromNextEventHandler;
private ActionReadFromNextEventCallbackDelegate _accessibilityManagerActionReadFromNextEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionZoomEventHandler;
private ActionZoomEventCallbackDelegate _accessibilityManagerActionZoomEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadIndicatorInformationEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionReadIndicatorInformationEventHandler;
private ActionReadIndicatorInformationEventCallbackDelegate _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionReadPauseResumeEventHandler;
private ActionReadPauseResumeEventCallbackDelegate _accessibilityManagerActionReadPauseResumeEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
private DaliEventHandlerWithReturnType _accessibilityManagerActionStartStopEventHandler;
private ActionStartStopEventCallbackDelegate _accessibilityManagerActionStartStopEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
private DaliEventHandlerWithReturnType _accessibilityManagerActionScrollEventHandler;
private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusChangedEventCallbackDelegate(IntPtr actor1, IntPtr actor2);
private DaliEventHandler _accessibilityManagerFocusChangedEventHandler;
private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
private DaliEventHandler _accessibilityManagerFocusedActorActivatedEventHandler;
private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
private DaliEventHandler _accessibilityManagerFocusOvershotEventHandler;
private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
public event DaliEventHandlerWithReturnType StatusChanged
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerStatusChangedEventHandler == null)
{
_accessibilityManagerStatusChangedEventHandler += value;
_accessibilityManagerStatusChangedEventCallbackDelegate = new StatusChangedEventCallbackDelegate(OnStatusChanged);
this.StatusChangedSignal().Connect(_accessibilityManagerStatusChangedEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerStatusChangedEventHandler != null)
{
this.StatusChangedSignal().Disconnect(_accessibilityManagerStatusChangedEventCallbackDelegate);
}
_accessibilityManagerStatusChangedEventHandler -= value;
}
}
}
// Callback for AccessibilityManager StatusChangedSignal
private bool OnStatusChanged(IntPtr data)
{
StatusChangedEventArgs e = new StatusChangedEventArgs();
// Populate all members of "e" (StatusChangedEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerStatusChangedEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerStatusChangedEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionNext
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionNextEventHandler == null)
{
_accessibilityManagerActionNextEventHandler += value;
_accessibilityManagerActionNextEventCallbackDelegate = new ActionNextEventCallbackDelegate(OnActionNext);
this.ActionNextSignal().Connect(_accessibilityManagerActionNextEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionNextEventHandler != null)
{
this.ActionNextSignal().Disconnect(_accessibilityManagerActionNextEventCallbackDelegate);
}
_accessibilityManagerActionNextEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionNextSignal
private bool OnActionNext(IntPtr data)
{
ActionNextEventArgs e = new ActionNextEventArgs();
// Populate all members of "e" (ActionNextEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionNextEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionNextEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionPrevious
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionPreviousEventHandler == null)
{
_accessibilityManagerActionPreviousEventHandler += value;
_accessibilityManagerActionPreviousEventCallbackDelegate = new ActionPreviousEventCallbackDelegate(OnActionPrevious);
this.ActionPreviousSignal().Connect(_accessibilityManagerActionPreviousEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionPreviousEventHandler != null)
{
this.ActionPreviousSignal().Disconnect(_accessibilityManagerActionPreviousEventCallbackDelegate);
}
_accessibilityManagerActionPreviousEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionPreviousSignal
private bool OnActionPrevious(IntPtr data)
{
ActionPreviousEventArgs e = new ActionPreviousEventArgs();
// Populate all members of "e" (ActionPreviousEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionPreviousEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionPreviousEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionActivate
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionActivateEventHandler == null)
{
_accessibilityManagerActionActivateEventHandler += value;
_accessibilityManagerActionActivateEventCallbackDelegate = new ActionActivateEventCallbackDelegate(OnActionActivate);
this.ActionActivateSignal().Connect(_accessibilityManagerActionActivateEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionActivateEventHandler != null)
{
this.ActionActivateSignal().Disconnect(_accessibilityManagerActionActivateEventCallbackDelegate);
}
_accessibilityManagerActionActivateEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionActivateSignal
private bool OnActionActivate(IntPtr data)
{
ActionActivateEventArgs e = new ActionActivateEventArgs();
// Populate all members of "e" (ActionActivateEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionActivateEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionActivateEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionRead
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionReadEventHandler == null)
{
_accessibilityManagerActionReadEventHandler += value;
_accessibilityManagerActionReadEventCallbackDelegate = new ActionReadEventCallbackDelegate(OnActionRead);
this.ActionReadSignal().Connect(_accessibilityManagerActionReadEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionReadEventHandler != null)
{
this.ActionReadSignal().Disconnect(_accessibilityManagerActionReadEventCallbackDelegate);
}
_accessibilityManagerActionReadEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionReadSignal
private bool OnActionRead(IntPtr data)
{
ActionReadEventArgs e = new ActionReadEventArgs();
// Populate all members of "e" (ActionReadEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionReadEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionReadEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionOver
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionOverEventHandler == null)
{
_accessibilityManagerActionOverEventHandler += value;
_accessibilityManagerActionOverEventCallbackDelegate = new ActionOverEventCallbackDelegate(OnActionOver);
this.ActionOverSignal().Connect(_accessibilityManagerActionOverEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionOverEventHandler != null)
{
this.ActionOverSignal().Disconnect(_accessibilityManagerActionOverEventCallbackDelegate);
}
_accessibilityManagerActionOverEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionOverSignal
private bool OnActionOver(IntPtr data)
{
ActionOverEventArgs e = new ActionOverEventArgs();
// Populate all members of "e" (ActionOverEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionOverEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionOverEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionReadNext
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionReadNextEventHandler == null)
{
_accessibilityManagerActionReadNextEventHandler += value;
_accessibilityManagerActionReadNextEventCallbackDelegate = new ActionReadNextEventCallbackDelegate(OnActionReadNext);
this.ActionReadNextSignal().Connect(_accessibilityManagerActionReadNextEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionReadNextEventHandler != null)
{
this.ActionReadNextSignal().Disconnect(_accessibilityManagerActionReadNextEventCallbackDelegate);
}
_accessibilityManagerActionReadNextEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionReadNextSignal
private bool OnActionReadNext(IntPtr data)
{
ActionReadNextEventArgs e = new ActionReadNextEventArgs();
// Populate all members of "e" (ActionReadNextEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionReadNextEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionReadNextEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionReadPrevious
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionReadPreviousEventHandler == null)
{
_accessibilityManagerActionReadPreviousEventHandler += value;
_accessibilityManagerActionReadPreviousEventCallbackDelegate = new ActionReadPreviousEventCallbackDelegate(OnActionReadPrevious);
this.ActionReadPreviousSignal().Connect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionReadPreviousEventHandler != null)
{
this.ActionReadPreviousSignal().Disconnect(_accessibilityManagerActionReadPreviousEventCallbackDelegate);
}
_accessibilityManagerActionReadPreviousEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionReadPreviousSignal
private bool OnActionReadPrevious(IntPtr data)
{
ActionReadPreviousEventArgs e = new ActionReadPreviousEventArgs();
// Populate all members of "e" (ActionReadPreviousEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionReadPreviousEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionReadPreviousEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionUp
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionUpEventHandler == null)
{
_accessibilityManagerActionUpEventHandler += value;
_accessibilityManagerActionUpEventCallbackDelegate = new ActionUpEventCallbackDelegate(OnActionUp);
this.ActionUpSignal().Connect(_accessibilityManagerActionUpEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionUpEventHandler != null)
{
this.ActionUpSignal().Disconnect(_accessibilityManagerActionUpEventCallbackDelegate);
}
_accessibilityManagerActionUpEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionUpSignal
private bool OnActionUp(IntPtr data)
{
ActionUpEventArgs e = new ActionUpEventArgs();
// Populate all members of "e" (ActionUpEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionUpEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionUpEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionDown
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionDownEventHandler == null)
{
_accessibilityManagerActionDownEventHandler += value;
_accessibilityManagerActionDownEventCallbackDelegate = new ActionDownEventCallbackDelegate(OnActionDown);
this.ActionDownSignal().Connect(_accessibilityManagerActionDownEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionDownEventHandler != null)
{
this.ActionDownSignal().Disconnect(_accessibilityManagerActionDownEventCallbackDelegate);
}
_accessibilityManagerActionDownEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionDownSignal
private bool OnActionDown(IntPtr data)
{
ActionDownEventArgs e = new ActionDownEventArgs();
// Populate all members of "e" (ActionDownEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionDownEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionDownEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionClearFocus
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionClearFocusEventHandler == null)
{
_accessibilityManagerActionClearFocusEventHandler += value;
_accessibilityManagerActionClearFocusEventCallbackDelegate = new ActionClearFocusEventCallbackDelegate(OnActionClearFocus);
this.ActionClearFocusSignal().Connect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionClearFocusEventHandler != null)
{
this.ActionClearFocusSignal().Disconnect(_accessibilityManagerActionClearFocusEventCallbackDelegate);
}
_accessibilityManagerActionClearFocusEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionClearFocusSignal
private bool OnActionClearFocus(IntPtr data)
{
ActionClearFocusEventArgs e = new ActionClearFocusEventArgs();
// Populate all members of "e" (ActionClearFocusEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionClearFocusEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionClearFocusEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionBack
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionBackEventHandler == null)
{
_accessibilityManagerActionBackEventHandler += value;
_accessibilityManagerActionBackEventCallbackDelegate = new ActionBackEventCallbackDelegate(OnActionBack);
this.ActionBackSignal().Connect(_accessibilityManagerActionBackEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionBackEventHandler != null)
{
this.ActionBackSignal().Disconnect(_accessibilityManagerActionBackEventCallbackDelegate);
}
_accessibilityManagerActionBackEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionBackSignal
private bool OnActionBack(IntPtr data)
{
ActionBackEventArgs e = new ActionBackEventArgs();
// Populate all members of "e" (ActionBackEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionBackEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionBackEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionScrollUp
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionScrollUpEventHandler == null)
{
_accessibilityManagerActionScrollUpEventHandler += value;
_accessibilityManagerActionScrollUpEventCallbackDelegate = new ActionScrollUpEventCallbackDelegate(OnActionScrollUp);
this.ActionScrollUpSignal().Connect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionScrollUpEventHandler != null)
{
this.ActionScrollUpSignal().Disconnect(_accessibilityManagerActionScrollUpEventCallbackDelegate);
}
_accessibilityManagerActionScrollUpEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionScrollUpSignal
private bool OnActionScrollUp(IntPtr data)
{
ActionScrollUpEventArgs e = new ActionScrollUpEventArgs();
// Populate all members of "e" (ActionScrollUpEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionScrollUpEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionScrollUpEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionScrollDown
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionScrollDownEventHandler == null)
{
_accessibilityManagerActionScrollDownEventHandler += value;
_accessibilityManagerActionScrollDownEventCallbackDelegate = new ActionScrollDownEventCallbackDelegate(OnActionScrollDown);
this.ActionScrollDownSignal().Connect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionScrollDownEventHandler != null)
{
this.ActionScrollDownSignal().Disconnect(_accessibilityManagerActionScrollDownEventCallbackDelegate);
}
_accessibilityManagerActionScrollDownEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionScrollDownSignal
private bool OnActionScrollDown(IntPtr data)
{
ActionScrollDownEventArgs e = new ActionScrollDownEventArgs();
// Populate all members of "e" (ActionScrollDownEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionScrollDownEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionScrollDownEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionPageLeft
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionPageLeftEventHandler == null)
{
_accessibilityManagerActionPageLeftEventHandler += value;
_accessibilityManagerActionPageLeftEventCallbackDelegate = new ActionPageLeftEventCallbackDelegate(OnActionPageLeft);
this.ActionPageLeftSignal().Connect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionPageLeftEventHandler != null)
{
this.ActionPageLeftSignal().Disconnect(_accessibilityManagerActionPageLeftEventCallbackDelegate);
}
_accessibilityManagerActionPageLeftEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionPageLeftSignal
private bool OnActionPageLeft(IntPtr data)
{
ActionPageLeftEventArgs e = new ActionPageLeftEventArgs();
// Populate all members of "e" (ActionPageLeftEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionPageLeftEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionPageLeftEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionPageRight
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionPageRightEventHandler == null)
{
_accessibilityManagerActionPageRightEventHandler += value;
_accessibilityManagerActionPageRightEventCallbackDelegate = new ActionPageRightEventCallbackDelegate(OnActionPageRight);
this.ActionPageRightSignal().Connect(_accessibilityManagerActionPageRightEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionPageRightEventHandler != null)
{
this.ActionPageRightSignal().Disconnect(_accessibilityManagerActionPageRightEventCallbackDelegate);
}
_accessibilityManagerActionPageRightEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionPageRightSignal
private bool OnActionPageRight(IntPtr data)
{
ActionPageRightEventArgs e = new ActionPageRightEventArgs();
// Populate all members of "e" (ActionPageRightEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionPageRightEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionPageRightEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionPageUp
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionPageUpEventHandler == null)
{
_accessibilityManagerActionPageUpEventHandler += value;
_accessibilityManagerActionPageUpEventCallbackDelegate = new ActionPageUpEventCallbackDelegate(OnActionPageUp);
this.ActionPageUpSignal().Connect(_accessibilityManagerActionPageUpEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionPageUpEventHandler != null)
{
this.ActionPageUpSignal().Disconnect(_accessibilityManagerActionPageUpEventCallbackDelegate);
}
_accessibilityManagerActionPageUpEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionPageUpSignal
private bool OnActionPageUp(IntPtr data)
{
ActionPageUpEventArgs e = new ActionPageUpEventArgs();
// Populate all members of "e" (ActionPageUpEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionPageUpEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionPageUpEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionPageDown
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionPageDownEventHandler == null)
{
_accessibilityManagerActionPageDownEventHandler += value;
_accessibilityManagerActionPageDownEventCallbackDelegate = new ActionPageDownEventCallbackDelegate(OnActionPageDown);
this.ActionPageDownSignal().Connect(_accessibilityManagerActionPageDownEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionPageDownEventHandler != null)
{
this.ActionPageDownSignal().Disconnect(_accessibilityManagerActionPageDownEventCallbackDelegate);
}
_accessibilityManagerActionPageDownEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionPageDownSignal
private bool OnActionPageDown(IntPtr data)
{
ActionPageDownEventArgs e = new ActionPageDownEventArgs();
// Populate all members of "e" (ActionPageDownEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionPageDownEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionPageDownEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionMoveToFirst
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionMoveToFirstEventHandler == null)
{
_accessibilityManagerActionMoveToFirstEventHandler += value;
_accessibilityManagerActionMoveToFirstEventCallbackDelegate = new ActionMoveToFirstEventCallbackDelegate(OnActionMoveToFirst);
this.ActionMoveToFirstSignal().Connect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionMoveToFirstEventHandler != null)
{
this.ActionMoveToFirstSignal().Disconnect(_accessibilityManagerActionMoveToFirstEventCallbackDelegate);
}
_accessibilityManagerActionMoveToFirstEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionMoveToFirstSignal
private bool OnActionMoveToFirst(IntPtr data)
{
ActionMoveToFirstEventArgs e = new ActionMoveToFirstEventArgs();
// Populate all members of "e" (ActionMoveToFirstEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionMoveToFirstEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionMoveToFirstEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionMoveToLast
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionMoveToLastEventHandler == null)
{
_accessibilityManagerActionMoveToLastEventHandler += value;
_accessibilityManagerActionMoveToLastEventCallbackDelegate = new ActionMoveToLastEventCallbackDelegate(OnActionMoveToLast);
this.ActionMoveToLastSignal().Connect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionMoveToLastEventHandler != null)
{
this.ActionMoveToLastSignal().Disconnect(_accessibilityManagerActionMoveToLastEventCallbackDelegate);
}
_accessibilityManagerActionMoveToLastEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionMoveToLastSignal
private bool OnActionMoveToLast(IntPtr data)
{
ActionMoveToLastEventArgs e = new ActionMoveToLastEventArgs();
// Populate all members of "e" (ActionMoveToLastEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionMoveToLastEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionMoveToLastEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionReadFromTop
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionReadFromTopEventHandler == null)
{
_accessibilityManagerActionReadFromTopEventHandler += value;
_accessibilityManagerActionReadFromTopEventCallbackDelegate = new ActionReadFromTopEventCallbackDelegate(OnActionReadFromTop);
this.ActionReadFromTopSignal().Connect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionReadFromTopEventHandler != null)
{
this.ActionReadFromTopSignal().Disconnect(_accessibilityManagerActionReadFromTopEventCallbackDelegate);
}
_accessibilityManagerActionReadFromTopEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionReadFromTopSignal
private bool OnActionReadFromTop(IntPtr data)
{
ActionReadFromTopEventArgs e = new ActionReadFromTopEventArgs();
// Populate all members of "e" (ActionReadFromTopEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionReadFromTopEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionReadFromTopEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionReadFromNext
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionReadFromNextEventHandler == null)
{
_accessibilityManagerActionReadFromNextEventHandler += value;
_accessibilityManagerActionReadFromNextEventCallbackDelegate = new ActionReadFromNextEventCallbackDelegate(OnActionReadFromNext);
this.ActionReadFromNextSignal().Connect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionReadFromNextEventHandler != null)
{
this.ActionReadFromNextSignal().Disconnect(_accessibilityManagerActionReadFromNextEventCallbackDelegate);
}
_accessibilityManagerActionReadFromNextEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionReadFromNextSignal
private bool OnActionReadFromNext(IntPtr data)
{
ActionReadFromNextEventArgs e = new ActionReadFromNextEventArgs();
// Populate all members of "e" (ActionReadFromNextEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionReadFromNextEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionReadFromNextEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionZoom
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionZoomEventHandler == null)
{
_accessibilityManagerActionZoomEventHandler += value;
_accessibilityManagerActionZoomEventCallbackDelegate = new ActionZoomEventCallbackDelegate(OnActionZoom);
this.ActionZoomSignal().Connect(_accessibilityManagerActionZoomEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionZoomEventHandler != null)
{
this.ActionZoomSignal().Disconnect(_accessibilityManagerActionZoomEventCallbackDelegate);
}
_accessibilityManagerActionZoomEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionZoomSignal
private bool OnActionZoom(IntPtr data)
{
ActionZoomEventArgs e = new ActionZoomEventArgs();
// Populate all members of "e" (ActionZoomEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionZoomEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionZoomEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionReadIndicatorInformation
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionReadIndicatorInformationEventHandler == null)
{
_accessibilityManagerActionReadIndicatorInformationEventHandler += value;
_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate = new ActionReadIndicatorInformationEventCallbackDelegate(OnActionReadIndicatorInformation);
this.ActionReadIndicatorInformationSignal().Connect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
{
this.ActionReadIndicatorInformationSignal().Disconnect(_accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate);
}
_accessibilityManagerActionReadIndicatorInformationEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionReadIndicatorInformationSignal
private bool OnActionReadIndicatorInformation(IntPtr data)
{
ActionReadIndicatorInformationEventArgs e = new ActionReadIndicatorInformationEventArgs();
// Populate all members of "e" (ActionReadIndicatorInformationEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionReadPauseResume
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionReadPauseResumeEventHandler == null)
{
_accessibilityManagerActionReadPauseResumeEventHandler += value;
_accessibilityManagerActionReadPauseResumeEventCallbackDelegate = new ActionReadPauseResumeEventCallbackDelegate(OnActionReadPauseResume);
this.ActionReadPauseResumeSignal().Connect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
{
this.ActionReadPauseResumeSignal().Disconnect(_accessibilityManagerActionReadPauseResumeEventCallbackDelegate);
}
_accessibilityManagerActionReadPauseResumeEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionReadPauseResumeSignal
private bool OnActionReadPauseResume(IntPtr data)
{
ActionReadPauseResumeEventArgs e = new ActionReadPauseResumeEventArgs();
// Populate all members of "e" (ActionReadPauseResumeEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionReadPauseResumeEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionStartStop
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionStartStopEventHandler == null)
{
_accessibilityManagerActionStartStopEventHandler += value;
_accessibilityManagerActionStartStopEventCallbackDelegate = new ActionStartStopEventCallbackDelegate(OnActionStartStop);
this.ActionStartStopSignal().Connect(_accessibilityManagerActionStartStopEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionStartStopEventHandler != null)
{
this.ActionStartStopSignal().Disconnect(_accessibilityManagerActionStartStopEventCallbackDelegate);
}
_accessibilityManagerActionStartStopEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionStartStopSignal
private bool OnActionStartStop(IntPtr data)
{
ActionStartStopEventArgs e = new ActionStartStopEventArgs();
// Populate all members of "e" (ActionStartStopEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(data);
if (_accessibilityManagerActionStartStopEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionStartStopEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandlerWithReturnType ActionScroll
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerActionScrollEventHandler == null)
{
_accessibilityManagerActionScrollEventHandler += value;
_accessibilityManagerActionScrollEventCallbackDelegate = new ActionScrollEventCallbackDelegate(OnActionScroll);
this.ActionScrollSignal().Connect(_accessibilityManagerActionScrollEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerActionScrollEventHandler != null)
{
this.ActionScrollSignal().Disconnect(_accessibilityManagerActionScrollEventCallbackDelegate);
}
_accessibilityManagerActionScrollEventHandler -= value;
}
}
}
// Callback for AccessibilityManager ActionScrollSignal
private bool OnActionScroll(IntPtr accessibilityManager, IntPtr touchEvent)
{
ActionScrollEventArgs e = new ActionScrollEventArgs();
// Populate all members of "e" (ActionScrollEventArgs) with real data
e.AccessibilityManager = AccessibilityManager.GetAccessibilityManagerFromPtr(accessibilityManager);
e.TouchEvent = TouchEvent.GetTouchEventFromPtr(touchEvent);
if (_accessibilityManagerActionScrollEventHandler != null)
{
//here we send all data to user event handlers
return _accessibilityManagerActionScrollEventHandler(this, e, true);
}
return false;
}
public event DaliEventHandler FocusChanged
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerFocusChangedEventHandler == null)
{
_accessibilityManagerFocusChangedEventHandler += value;
_accessibilityManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
this.FocusChangedSignal().Connect(_accessibilityManagerFocusChangedEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerFocusChangedEventHandler != null)
{
this.FocusChangedSignal().Disconnect(_accessibilityManagerFocusChangedEventCallbackDelegate);
}
_accessibilityManagerFocusChangedEventHandler -= value;
}
}
}
// Callback for AccessibilityManager FocusChangedSignal
private void OnFocusChanged(IntPtr actor1, IntPtr actor2)
{
FocusChangedEventArgs e = new FocusChangedEventArgs();
// Populate all members of "e" (FocusChangedEventArgs) with real data
e.ActorCurrent = Actor.GetActorFromPtr(actor1);
e.ActorNext = Actor.GetActorFromPtr(actor2);
if (_accessibilityManagerFocusChangedEventHandler != null)
{
//here we send all data to user event handlers
_accessibilityManagerFocusChangedEventHandler(this, e);
}
}
public event DaliEventHandler FocusedActorActivated
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerFocusedActorActivatedEventHandler == null)
{
_accessibilityManagerFocusedActorActivatedEventHandler += value;
_accessibilityManagerFocusedActorActivatedEventCallbackDelegate = new FocusedActorActivatedEventCallbackDelegate(OnFocusedActorActivated);
this.FocusedActorActivatedSignal().Connect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
{
this.FocusedActorActivatedSignal().Disconnect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
}
_accessibilityManagerFocusedActorActivatedEventHandler -= value;
}
}
}
// Callback for AccessibilityManager FocusedActorActivatedSignal
private void OnFocusedActorActivated(IntPtr actor)
{
FocusedActorActivatedEventArgs e = new FocusedActorActivatedEventArgs();
// Populate all members of "e" (FocusedActorActivatedEventArgs) with real data
e.Actor = Actor.GetActorFromPtr(actor);
if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
{
//here we send all data to user event handlers
_accessibilityManagerFocusedActorActivatedEventHandler(this, e);
}
}
public event DaliEventHandler FocusOvershot
{
add
{
lock(this)
{
// Restricted to only one listener
if (_accessibilityManagerFocusOvershotEventHandler == null)
{
_accessibilityManagerFocusOvershotEventHandler += value;
_accessibilityManagerFocusOvershotEventCallbackDelegate = new FocusOvershotEventCallbackDelegate(OnFocusOvershot);
this.FocusOvershotSignal().Connect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_accessibilityManagerFocusOvershotEventHandler != null)
{
this.FocusOvershotSignal().Disconnect(_accessibilityManagerFocusOvershotEventCallbackDelegate);
}
_accessibilityManagerFocusOvershotEventHandler -= value;
}
}
}
// Callback for AccessibilityManager FocusOvershotSignal
private void OnFocusOvershot(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction)
{
FocusOvershotEventArgs e = new FocusOvershotEventArgs();
// Populate all members of "e" (FocusOvershotEventArgs) with real data
e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
e.FocusOvershotDirection = direction;
if (_accessibilityManagerFocusOvershotEventHandler != null)
{
//here we send all data to user event handlers
_accessibilityManagerFocusOvershotEventHandler(this, e);
}
}
public static AccessibilityManager GetAccessibilityManagerFromPtr(global::System.IntPtr cPtr) {
AccessibilityManager ret = new AccessibilityManager(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityManager() : this(NDalicPINVOKE.new_AccessibilityManager(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public static AccessibilityManager Get() {
AccessibilityManager ret = new AccessibilityManager(NDalicPINVOKE.AccessibilityManager_Get(), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void SetAccessibilityAttribute(Actor actor, AccessibilityManager.AccessibilityAttribute type, string text) {
NDalicPINVOKE.AccessibilityManager_SetAccessibilityAttribute(swigCPtr, Actor.getCPtr(actor), (int)type, text);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public string GetAccessibilityAttribute(Actor actor, AccessibilityManager.AccessibilityAttribute type) {
string ret = NDalicPINVOKE.AccessibilityManager_GetAccessibilityAttribute(swigCPtr, Actor.getCPtr(actor), (int)type);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void SetFocusOrder(Actor actor, uint order) {
NDalicPINVOKE.AccessibilityManager_SetFocusOrder(swigCPtr, Actor.getCPtr(actor), order);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public uint GetFocusOrder(Actor actor) {
uint ret = NDalicPINVOKE.AccessibilityManager_GetFocusOrder(swigCPtr, Actor.getCPtr(actor));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public uint GenerateNewFocusOrder() {
uint ret = NDalicPINVOKE.AccessibilityManager_GenerateNewFocusOrder(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public Actor GetActorByFocusOrder(uint order) {
Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetActorByFocusOrder(swigCPtr, order), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool SetCurrentFocusActor(Actor actor) {
bool ret = NDalicPINVOKE.AccessibilityManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public Actor GetCurrentFocusActor() {
Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public Actor GetCurrentFocusGroup() {
Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusGroup(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public uint GetCurrentFocusOrder() {
uint ret = NDalicPINVOKE.AccessibilityManager_GetCurrentFocusOrder(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool MoveFocusForward() {
bool ret = NDalicPINVOKE.AccessibilityManager_MoveFocusForward(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool MoveFocusBackward() {
bool ret = NDalicPINVOKE.AccessibilityManager_MoveFocusBackward(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void ClearFocus() {
NDalicPINVOKE.AccessibilityManager_ClearFocus(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public new void Reset() {
NDalicPINVOKE.AccessibilityManager_Reset(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public void SetFocusGroup(Actor actor, bool isFocusGroup) {
NDalicPINVOKE.AccessibilityManager_SetFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public bool IsFocusGroup(Actor actor) {
bool ret = NDalicPINVOKE.AccessibilityManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void SetGroupMode(bool enabled) {
NDalicPINVOKE.AccessibilityManager_SetGroupMode(swigCPtr, enabled);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public bool GetGroupMode() {
bool ret = NDalicPINVOKE.AccessibilityManager_GetGroupMode(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void SetWrapMode(bool wrapped) {
NDalicPINVOKE.AccessibilityManager_SetWrapMode(swigCPtr, wrapped);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public bool GetWrapMode() {
bool ret = NDalicPINVOKE.AccessibilityManager_GetWrapMode(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void SetFocusIndicatorActor(Actor indicator) {
NDalicPINVOKE.AccessibilityManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public Actor GetFocusIndicatorActor() {
Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetFocusIndicatorActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public Actor GetFocusGroup(Actor actor) {
Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public Vector2 GetReadPosition() {
Vector2 ret = new Vector2(NDalicPINVOKE.AccessibilityManager_GetReadPosition(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public FocusChangedSignal FocusChangedSignal() {
FocusChangedSignal ret = new FocusChangedSignal(NDalicPINVOKE.AccessibilityManager_FocusChangedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityFocusOvershotSignal FocusOvershotSignal() {
AccessibilityFocusOvershotSignal ret = new AccessibilityFocusOvershotSignal(NDalicPINVOKE.AccessibilityManager_FocusOvershotSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ActorSignal FocusedActorActivatedSignal() {
ActorSignal ret = new ActorSignal(NDalicPINVOKE.AccessibilityManager_FocusedActorActivatedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal StatusChangedSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_StatusChangedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionNextSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionNextSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionPreviousSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPreviousSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionActivateSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionActivateSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionReadSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionOverSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionOverSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionReadNextSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadNextSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionReadPreviousSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadPreviousSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionUpSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionUpSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionDownSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionDownSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionClearFocusSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionClearFocusSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionBackSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionBackSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionScrollUpSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionScrollUpSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionScrollDownSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionScrollDownSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionPageLeftSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageLeftSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionPageRightSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageRightSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionPageUpSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageUpSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionPageDownSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionPageDownSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionMoveToFirstSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionMoveToFirstSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionMoveToLastSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionMoveToLastSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionReadFromTopSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadFromTopSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionReadFromNextSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadFromNextSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionZoomSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionZoomSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionReadIndicatorInformationSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadIndicatorInformationSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionReadPauseResumeSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionReadPauseResumeSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionSignal ActionStartStopSignal() {
AccessibilityActionSignal ret = new AccessibilityActionSignal(NDalicPINVOKE.AccessibilityManager_ActionStartStopSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public AccessibilityActionScrollSignal ActionScrollSignal() {
AccessibilityActionScrollSignal ret = new AccessibilityActionScrollSignal(NDalicPINVOKE.AccessibilityManager_ActionScrollSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public enum AccessibilityAttribute {
ACCESSIBILITY_LABEL = 0,
ACCESSIBILITY_TRAIT,
ACCESSIBILITY_VALUE,
ACCESSIBILITY_HINT,
ACCESSIBILITY_ATTRIBUTE_NUM
}
public enum FocusOvershotDirection {
OVERSHOT_PREVIOUS = -1,
OVERSHOT_NEXT = 1
}
}
}