//------------------------------------------------------------------------------
// <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 Dali {

using System;
using System.Runtime.InteropServices;


public class Stage : BaseHandle {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;

  internal Stage(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Stage_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  }

  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Stage obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }

  ~Stage() {
    Dispose();
  }

  public override void Dispose() {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          NDalicPINVOKE.delete_Stage(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 Touch signal
  *
  */
public class TouchEventArgs : EventArgs
{
   private TouchData _touchData;

   /**
     * @brief TouchData - contains the information of touch points
     *
     */
   public TouchData TouchData
   {
      get
      {
         return _touchData;
      }
      set
      {
         _touchData = value;
      }
   }
}


/**
  * @brief Event arguments that passed via Wheel signal
  *
  */
public class WheelEventArgs : EventArgs
{
   private WheelEvent _wheelEvent;

   /**
     * @brief WheelEvent - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
     *
     */
   public WheelEvent WheelEvent
   {
      get
      {
         return _wheelEvent;
      }
      set
      {
         _wheelEvent = value;
      }
   }
}

/**
  * @brief Event arguments that passed via KeyEvent signal
  *
  */
public class KeyEventArgs : EventArgs
{
   private KeyEvent _keyEvent;

   /**
     * @brief KeyEvent - is the keyevent sent to Stage.
     *
     */
   public KeyEvent KeyEvent
   {
      get
      {
         return _keyEvent;
      }
      set
      {
         _keyEvent = value;
      }
   }
}

/**
  * @brief Event arguments that passed via EventProcessingFinished signal
  *
  */
public class EventProcessingFinishedEventArgs : EventArgs
{
}

/**
  * @brief Event arguments that passed via ContextLost signal
  *
  */
public class ContextLostEventArgs : EventArgs
{
}

/**
  * @brief Event arguments that passed via ContextRegained signal
  *
  */
public class ContextRegainedEventArgs : EventArgs
{
}

/**
  * @brief Event arguments that passed via SceneCreated signal
  *
  */
public class SceneCreatedEventArgs : EventArgs
{
}


  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate void StageTouchCallbackDelegate(IntPtr data);
  private DaliEventHandler<object,TouchEventArgs> _stageTouchEventHandler;
  private StageTouchCallbackDelegate _stageTouchCallbackDelegate;

  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate void WheelCallbackDelegate(IntPtr data);
  private DaliEventHandler<object,WheelEventArgs> _stageWheelEventHandler;
  private WheelCallbackDelegate _stageWheelCallbackDelegate;

  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate void KeyCallbackDelegate(IntPtr data);
  private DaliEventHandler<object,KeyEventArgs> _stageKeyEventHandler;
  private KeyCallbackDelegate _stageKeyCallbackDelegate;

  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate void EventProcessingFinishedEventCallbackDelegate();
  private DaliEventHandler<object,EventProcessingFinishedEventArgs> _stageEventProcessingFinishedEventHandler;
  private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;

  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate void ContextLostEventCallbackDelegate();
  private DaliEventHandler<object,ContextLostEventArgs> _stageContextLostEventHandler;
  private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;

  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate void ContextRegainedEventCallbackDelegate();
  private DaliEventHandler<object,ContextRegainedEventArgs> _stageContextRegainedEventHandler;
  private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;

  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  private delegate void SceneCreatedEventCallbackDelegate();
  private DaliEventHandler<object,SceneCreatedEventArgs> _stageSceneCreatedEventHandler;
  private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate;

  /**
    * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
    * (in the type of TouchEventHandler-DaliEventHandler<object,TouchEventArgs>) provided by the user.
    * Touched signal is emitted when the screen is touched and when the touch ends
    * (i.e. the down & up touch events only).
    *
    */
  public event DaliEventHandler<object,TouchEventArgs> Touched
  {
     add
     {
        lock(this)
        {
           // Restricted to only one listener
           if (_stageTouchEventHandler == null)
           {
              _stageTouchEventHandler += value;

              _stageTouchCallbackDelegate = new StageTouchCallbackDelegate(OnStageTouch);
              this.TouchSignal().Connect(_stageTouchCallbackDelegate);
           }
        }
     }

     remove
     {
        lock(this)
        {
           if (_stageTouchEventHandler != null)
           {
              this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
           }

           _stageTouchEventHandler -= value;
        }
     }
  }

  // Callback for Stage Touch signal
  private void OnStageTouch(IntPtr data)
  {
     TouchEventArgs e = new TouchEventArgs();

     // Populate all members of "e" (TouchEventArgs) with real data
     e.TouchData = TouchData.GetTouchDataFromPtr( data );

     if (_stageTouchEventHandler != null)
     {
        //here we send all data to user event handlers
        _stageTouchEventHandler(this, e);
     }
  }

  /**
    * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
    * (in the type of WheelEventHandler-DaliEventHandler<object,WheelEventArgs>) provided by the user.
    * WheelMoved signal is emitted is emitted when wheel event is received.
    *
    */
  public event DaliEventHandler<object,WheelEventArgs> WheelMoved
  {
     add
     {
        lock(this)
        {
           // Restricted to only one listener
           if (_stageWheelEventHandler == null)
           {
              _stageWheelEventHandler += value;

              _stageWheelCallbackDelegate = new WheelCallbackDelegate(OnStageWheel);
              this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
           }
        }
     }

     remove
     {
        lock(this)
        {
           if (_stageWheelEventHandler != null)
           {
              this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
           }

           _stageWheelEventHandler -= value;
        }
     }
  }

  // Callback for Stage WheelEventsignal
  private void OnStageWheel(IntPtr data)
  {
     WheelEventArgs e = new WheelEventArgs();

     // Populate all members of "e" (WheelEventArgs) with real data
     e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );

     if (_stageWheelEventHandler != null)
     {
        //here we send all data to user event handlers
        _stageWheelEventHandler(this, e);
     }
  }

  /**
    * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
    * (in the type of KeyEventHandler-DaliEventHandler<object,KeyEventArgs>) provided by the user.
    * KeyPressed signal is emitted is emitted when key event is received.
    *
    */
  public event DaliEventHandler<object,KeyEventArgs> KeyPressed
  {
     add
     {
        lock(this)
        {
           // Restricted to only one listener
           if (_stageKeyEventHandler == null)
           {
              _stageKeyEventHandler += value;

              _stageKeyCallbackDelegate = new KeyCallbackDelegate(OnStageKey);
              this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
           }
        }
     }

     remove
     {
        lock(this)
        {
           if (_stageKeyEventHandler != null)
           {
              this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
           }

           _stageKeyEventHandler -= value;
        }
     }
  }

  // Callback for Stage KeyEventsignal
  private void OnStageKey(IntPtr keyEvent)
  {
     KeyEventArgs e = new KeyEventArgs();

     // Populate all members of "e" (KeyEventArgs) with real data
     e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( keyEvent );

     if (_stageKeyEventHandler != null)
     {
        //here we send all data to user event handlers
        _stageKeyEventHandler(this, e);
     }
  }

  /**
    * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
    * (in the type of EventProcessingFinishedEventHandler-DaliEventHandler<object,EventProcessingFinishedEventArgs>) 
    * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
    *
    */
  public event DaliEventHandler<object,EventProcessingFinishedEventArgs> EventProcessingFinished
  {
     add
     {
        lock(this)
        {
           // Restricted to only one listener
           if (_stageEventProcessingFinishedEventHandler == null)
           {
              _stageEventProcessingFinishedEventHandler += value;

              _stageEventProcessingFinishedEventCallbackDelegate = new EventProcessingFinishedEventCallbackDelegate(OnEventProcessingFinished);
              this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
           }
        }
     }

     remove
     {
        lock(this)
        {
           if (_stageEventProcessingFinishedEventHandler != null)
           {
              this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
           }

           _stageEventProcessingFinishedEventHandler -= value;
        }
     }
  }

  // Callback for Stage EventProcessingFinishedSignal
  private void OnEventProcessingFinished()
  {
     EventProcessingFinishedEventArgs e = new EventProcessingFinishedEventArgs();

     if (_stageEventProcessingFinishedEventHandler != null)
     {
        //here we send all data to user event handlers
        _stageEventProcessingFinishedEventHandler(this, e);
     }
  }

  /**
    * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
    * (in the type of ContextLostEventHandler-DaliEventHandler<object,ContextLostEventArgs>) provided by the user.
    * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
    *
    */
  public event DaliEventHandler<object,ContextLostEventArgs> ContextLost
  {
     add
     {
        lock(this)
        {
           // Restricted to only one listener
           if (_stageContextLostEventHandler == null)
           {
              _stageContextLostEventHandler += value;

              _stageContextLostEventCallbackDelegate = new ContextLostEventCallbackDelegate(OnContextLost);
              this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
           }
        }
     }

     remove
     {
        lock(this)
        {
           if (_stageContextLostEventHandler != null)
           {
              this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
           }

           _stageContextLostEventHandler -= value;
        }
     }
  }

  // Callback for Stage ContextLostSignal
  private void OnContextLost()
  {
     ContextLostEventArgs e = new ContextLostEventArgs();

     if (_stageContextLostEventHandler != null)
     {
        //here we send all data to user event handlers
        _stageContextLostEventHandler(this, e);
     }
  }

  /**
    * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
    * (in the type of ContextRegainedEventHandler-DaliEventHandler<object,ContextRegainedEventArgs>) 
    * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
    * behaviour).
    *
    */
  public event DaliEventHandler<object,ContextRegainedEventArgs> ContextRegained
  {
     add
     {
        lock(this)
        {
           // Restricted to only one listener
           if (_stageContextRegainedEventHandler == null)
           {
              _stageContextRegainedEventHandler += value;

              _stageContextRegainedEventCallbackDelegate = new ContextRegainedEventCallbackDelegate(OnContextRegained);
              this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
           }
        }
     }

     remove
     {
        lock(this)
        {
           if (_stageContextRegainedEventHandler != null)
           {
              this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
           }

           _stageContextRegainedEventHandler -= value;
        }
     }
  }

  // Callback for Stage ContextRegainedSignal
  private void OnContextRegained()
  {
     ContextRegainedEventArgs e = new ContextRegainedEventArgs();

     if (_stageContextRegainedEventHandler != null)
     {
        //here we send all data to user event handlers
        _stageContextRegainedEventHandler(this, e);
     }
  }

  /**
    * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
    * (in the type of SceneCreatedEventHandler-DaliEventHandler<object,SceneCreatedEventArgs>) provided by the user.
    * SceneCreated signal is emitted after the initial scene is created.
    *
    */
  public event DaliEventHandler<object,SceneCreatedEventArgs> SceneCreated
  {
     add
     {
        lock(this)
        {
           // Restricted to only one listener
           if (_stageSceneCreatedEventHandler == null)
           {
              _stageSceneCreatedEventHandler += value;

              _stageSceneCreatedEventCallbackDelegate = new SceneCreatedEventCallbackDelegate(OnSceneCreated);
              this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
           }
        }
     }

     remove
     {
        lock(this)
        {
           if (_stageSceneCreatedEventHandler != null)
           {
              this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
           }

           _stageSceneCreatedEventHandler -= value;
        }
     }
  }

  // Callback for Stage SceneCreatedSignal
  private void OnSceneCreated()
  {
     SceneCreatedEventArgs e = new SceneCreatedEventArgs();

     if (_stageSceneCreatedEventHandler != null)
     {
        //here we send all data to user event handlers
        _stageSceneCreatedEventHandler(this, e);
     }
  }

  public Vector2 Size
  {
     get
     {
        Vector2 ret = GetSize();
        return ret;
     }
  }

  public Vector4 BackgroundColor
  {
     set
     {
        SetBackgroundColor(value);
     }
     get
     {
        Vector4 ret = GetBackgroundColor();
        return ret;
     }
   }


  public static Vector4 DEFAULT_BACKGROUND_COLOR {
    get {
      global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
      Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } 
  }

  public static Vector4 DEBUG_BACKGROUND_COLOR {
    get {
      global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
      Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    } 
  }

  public Stage() : this(NDalicPINVOKE.new_Stage__SWIG_0(), true) {
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public static Stage GetCurrent() {
    Stage ret = new Stage(NDalicPINVOKE.Stage_GetCurrent(), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static bool IsInstalled() {
    bool ret = NDalicPINVOKE.Stage_IsInstalled();
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Stage(Stage handle) : this(NDalicPINVOKE.new_Stage__SWIG_1(Stage.getCPtr(handle)), true) {
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Stage Assign(Stage rhs) {
    Stage ret = new Stage(NDalicPINVOKE.Stage_Assign(swigCPtr, Stage.getCPtr(rhs)), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void Add(Actor actor) {
    NDalicPINVOKE.Stage_Add(swigCPtr, Actor.getCPtr(actor));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void Remove(Actor actor) {
    NDalicPINVOKE.Stage_Remove(swigCPtr, Actor.getCPtr(actor));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector2 GetSize() {
    Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetSize(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public RenderTaskList GetRenderTaskList() {
    RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public uint GetLayerCount() {
    uint ret = NDalicPINVOKE.Stage_GetLayerCount(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Layer GetLayer(uint depth) {
    Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(swigCPtr, depth), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Layer GetRootLayer() {
    Layer ret = new Layer(NDalicPINVOKE.Stage_GetRootLayer(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetBackgroundColor(Vector4 color) {
    NDalicPINVOKE.Stage_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector4 GetBackgroundColor() {
    Vector4 ret = new Vector4(NDalicPINVOKE.Stage_GetBackgroundColor(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Vector2 GetDpi() {
    Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ObjectRegistry GetObjectRegistry() {
    ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void KeepRendering(float durationSeconds) {
    NDalicPINVOKE.Stage_KeepRendering(swigCPtr, durationSeconds);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public KeyEventSignal KeyEventSignal() {
    KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public VoidSignal EventProcessingFinishedSignal() {
    VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public TouchEventSignal TouchedSignal() {
    TouchEventSignal ret = new TouchEventSignal(NDalicPINVOKE.Stage_TouchedSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public TouchSignal TouchSignal() {
    TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public StageWheelEventSignal WheelEventSignal() {
    StageWheelEventSignal ret = new StageWheelEventSignal(NDalicPINVOKE.Stage_WheelEventSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public VoidSignal ContextLostSignal() {
    VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public VoidSignal ContextRegainedSignal() {
    VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public VoidSignal SceneCreatedSignal() {
    VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(swigCPtr), false);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

}

}