Dali C#: csharp dll initial upload

[platform/core/csapi/nui.git] / Tizen.NUI / src / public / AccessibilityManager.cs

//------------------------------------------------------------------------------
// <auto-generated />
//
// 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 NUI {

    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() {
    DisposeQueue.Instance.Add(this);
  }

  public override void Dispose() {
    if (!Stage.IsInstalled()) {
      DisposeQueue.Instance.Add(this);
      return;
    }

    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 EventHandlerWithReturnType<object,StatusChangedEventArgs,bool> _accessibilityManagerStatusChangedEventHandler;
    private StatusChangedEventCallbackDelegate _accessibilityManagerStatusChangedEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionNextEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionNextEventArgs,bool> _accessibilityManagerActionNextEventHandler;
    private ActionNextEventCallbackDelegate _accessibilityManagerActionNextEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionPreviousEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionPreviousEventArgs,bool> _accessibilityManagerActionPreviousEventHandler;
    private ActionPreviousEventCallbackDelegate _accessibilityManagerActionPreviousEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionActivateEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionActivateEventArgs,bool> _accessibilityManagerActionActivateEventHandler;
    private ActionActivateEventCallbackDelegate _accessibilityManagerActionActivateEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionReadEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionReadEventArgs,bool> _accessibilityManagerActionReadEventHandler;
    private ActionReadEventCallbackDelegate _accessibilityManagerActionReadEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionOverEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionOverEventArgs,bool> _accessibilityManagerActionOverEventHandler;
    private ActionOverEventCallbackDelegate _accessibilityManagerActionOverEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionReadNextEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionReadNextEventArgs,bool> _accessibilityManagerActionReadNextEventHandler;
    private ActionReadNextEventCallbackDelegate _accessibilityManagerActionReadNextEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionReadPreviousEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionReadPreviousEventArgs,bool> _accessibilityManagerActionReadPreviousEventHandler;
    private ActionReadPreviousEventCallbackDelegate _accessibilityManagerActionReadPreviousEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionUpEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionUpEventArgs,bool> _accessibilityManagerActionUpEventHandler;
    private ActionUpEventCallbackDelegate _accessibilityManagerActionUpEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionDownEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionDownEventArgs,bool> _accessibilityManagerActionDownEventHandler;
    private ActionDownEventCallbackDelegate _accessibilityManagerActionDownEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionClearFocusEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionClearFocusEventArgs,bool> _accessibilityManagerActionClearFocusEventHandler;
    private ActionClearFocusEventCallbackDelegate _accessibilityManagerActionClearFocusEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionBackEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionBackEventArgs,bool> _accessibilityManagerActionBackEventHandler;
    private ActionBackEventCallbackDelegate _accessibilityManagerActionBackEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionScrollUpEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionScrollUpEventArgs,bool> _accessibilityManagerActionScrollUpEventHandler;
    private ActionScrollUpEventCallbackDelegate _accessibilityManagerActionScrollUpEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionScrollDownEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionScrollDownEventArgs,bool> _accessibilityManagerActionScrollDownEventHandler;
    private ActionScrollDownEventCallbackDelegate _accessibilityManagerActionScrollDownEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionPageLeftEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionPageLeftEventArgs,bool> _accessibilityManagerActionPageLeftEventHandler;
    private ActionPageLeftEventCallbackDelegate _accessibilityManagerActionPageLeftEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionPageRightEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionPageRightEventArgs,bool> _accessibilityManagerActionPageRightEventHandler;
    private ActionPageRightEventCallbackDelegate _accessibilityManagerActionPageRightEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionPageUpEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionPageUpEventArgs,bool> _accessibilityManagerActionPageUpEventHandler;
    private ActionPageUpEventCallbackDelegate _accessibilityManagerActionPageUpEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionPageDownEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionPageDownEventArgs,bool> _accessibilityManagerActionPageDownEventHandler;
    private ActionPageDownEventCallbackDelegate _accessibilityManagerActionPageDownEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionMoveToFirstEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionMoveToFirstEventArgs,bool> _accessibilityManagerActionMoveToFirstEventHandler;
    private ActionMoveToFirstEventCallbackDelegate _accessibilityManagerActionMoveToFirstEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionMoveToLastEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionMoveToLastEventArgs,bool> _accessibilityManagerActionMoveToLastEventHandler;
    private ActionMoveToLastEventCallbackDelegate _accessibilityManagerActionMoveToLastEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionReadFromTopEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionReadFromTopEventArgs,bool> _accessibilityManagerActionReadFromTopEventHandler;
    private ActionReadFromTopEventCallbackDelegate _accessibilityManagerActionReadFromTopEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionReadFromNextEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionReadFromNextEventArgs,bool> _accessibilityManagerActionReadFromNextEventHandler;
    private ActionReadFromNextEventCallbackDelegate _accessibilityManagerActionReadFromNextEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionZoomEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionZoomEventArgs,bool> _accessibilityManagerActionZoomEventHandler;
    private ActionZoomEventCallbackDelegate _accessibilityManagerActionZoomEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionReadIndicatorInformationEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionReadIndicatorInformationEventArgs,bool> _accessibilityManagerActionReadIndicatorInformationEventHandler;
    private ActionReadIndicatorInformationEventCallbackDelegate _accessibilityManagerActionReadIndicatorInformationEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionReadPauseResumeEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionReadPauseResumeEventArgs,bool> _accessibilityManagerActionReadPauseResumeEventHandler;
    private ActionReadPauseResumeEventCallbackDelegate _accessibilityManagerActionReadPauseResumeEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionStartStopEventCallbackDelegate(IntPtr accessibilityManager);
    private EventHandlerWithReturnType<object,ActionStartStopEventArgs,bool> _accessibilityManagerActionStartStopEventHandler;
    private ActionStartStopEventCallbackDelegate _accessibilityManagerActionStartStopEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate bool ActionScrollEventCallbackDelegate(IntPtr accessibilityManager, IntPtr touchEvent);
    private EventHandlerWithReturnType<object,ActionScrollEventArgs,bool> _accessibilityManagerActionScrollEventHandler;
    private ActionScrollEventCallbackDelegate _accessibilityManagerActionScrollEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate void FocusChangedEventCallbackDelegate(IntPtr actor1, IntPtr actor2);
    private DaliEventHandler<object,FocusChangedEventArgs> _accessibilityManagerFocusChangedEventHandler;
    private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
    private DaliEventHandler<object,FocusedActorActivatedEventArgs> _accessibilityManagerFocusedActorActivatedEventHandler;
    private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
    private DaliEventHandler<object,FocusOvershotEventArgs> _accessibilityManagerFocusOvershotEventHandler;
    private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;

    public event EventHandlerWithReturnType<object,StatusChangedEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionNextEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionPreviousEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionActivateEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionReadEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionOverEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionReadNextEventArgs,bool> 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);
      }
      return false;
    }


    public event EventHandlerWithReturnType<object,ActionReadPreviousEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionUpEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionDownEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionClearFocusEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionBackEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionScrollUpEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionScrollDownEventArgs,bool> 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);
      }
      return false;
    }


    public event EventHandlerWithReturnType<object,ActionPageLeftEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionPageRightEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionPageUpEventArgs, bool> 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);
      }
      return false;
    }


    public event EventHandlerWithReturnType<object,ActionPageDownEventArgs,bool> 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);
      }
      return false;
    }


    public event EventHandlerWithReturnType<object,ActionMoveToFirstEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionMoveToLastEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionReadFromTopEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionReadFromNextEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionZoomEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionReadIndicatorInformationEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionReadPauseResumeEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionStartStopEventArgs,bool> 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);
      }
      return false;
    }

    public event EventHandlerWithReturnType<object,ActionScrollEventArgs,bool> 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);
      }
      return false;
    }

    public event DaliEventHandler<object,FocusChangedEventArgs> 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<object,FocusedActorActivatedEventArgs> 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<object,FocusOvershotEventArgs> 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
  }

}

}