/** Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 3.0.10
//
// 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 Actor : Handle {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;

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

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

  ~Actor() {
    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_Actor(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      global::System.GC.SuppressFinalize(this);
      base.Dispose();
    }
  }



    public static Actor GetActorFromPtr(global::System.IntPtr cPtr) {
      Actor ret = new Actor(cPtr, false);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
      return ret;
    }

    public IntPtr GetPtrfromActor ()
    {
      return (IntPtr)swigCPtr;
    }

    public Position CurrentPosition
    {
      get
      {
        return GetCurrentPosition();
      }
    }

    public Size2D Size2D
    {
      get
      {
        Size temp = new Size(0.0f,0.0f,0.0f);
        GetProperty( Actor.Property.SIZE).Get(  temp );
        return new Size2D(temp);
      }
      set
      {
        SetProperty( Actor.Property.SIZE, new Dali.Property.Value( new Size(value) ) );
      }
    }

    public Size CurrentSize
    {
      get
      {
        return GetCurrentSize();
      }
    }

    public Actor Parent
    {
      get
      {
        return GetParent();
      }
    }

    public bool Visibility
    {
      get
      {
        return IsVisible();
      }
    }

    public float Opacity
    {
      get
      {
        float temp = 0;
        GetProperty( Actor.Property.OPACITY ).Get( ref temp );
        return temp;
      }
      set
      {
        SetProperty( Actor.Property.OPACITY, new Dali.Property.Value( value ) );
      }
    }

    public Position2D Position2D
    {
      get
      {
        Position temp = new Position(0.0f,0.0f,0.0f);
        GetProperty( Actor.Property.POSITION).Get(  temp );
        return new Position2D(temp);
      }
      set
      {
        SetProperty( Actor.Property.POSITION, new Dali.Property.Value( new Position(value) ) );
      }
    }

    public Vector2 ScreenPosition
    {
      get
      {
        Vector2 temp = new Vector2( 0.0f, 0.0f );
        GetProperty( Actor.Property.SCREEN_POSITION ).Get( temp );
        return temp;
      }
    }

    protected bool PositionUsesAnchorPoint
    {
      get
      {
        bool temp = false;
        GetProperty( Actor.Property.POSITION_USES_ANCHOR_POINT ).Get( ref temp );
        return temp;
      }
      set
      {
        SetProperty( Actor.Property.POSITION_USES_ANCHOR_POINT, new Dali.Property.Value( value ) );
      }
    }

    public bool StateFocusEnable
    {
      get
      {
        return IsKeyboardFocusable();
      }
      set
      {
        SetKeyboardFocusable(value);
      }
    }

    public bool IsOnStage
    {
      get
      {
        return OnStage();
      }
    }

    public int SiblingOrder
    {
      get
      {
        int temp = 0;
        GetProperty( Actor.Property.SIBLING_ORDER ).Get( ref temp );
        return temp;
      }
      set
      {
        SetProperty( Actor.Property.SIBLING_ORDER, new Dali.Property.Value( value ) );
      }
    }

    public void Show()
    {
      SetVisible(true);
    }

    public void Hide()
    {
      SetVisible(false);
    }

    public void Raise()
    {
      NDalicPINVOKE.Raise(swigCPtr);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    }

    public void Lower()
    {
      NDalicPINVOKE.Lower(swigCPtr);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    }

    public void RaiseToTop()
    {
      NDalicPINVOKE.RaiseToTop(swigCPtr);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    }

    public void LowerToBottom()
    {
      NDalicPINVOKE.LowerToBottom(swigCPtr);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    }

    public void RaiseAbove(Actor target)
    {
      NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    }

    public void LowerBelow(Actor target)
    {
      NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    }


  public class Property : global::System.IDisposable {
    private global::System.Runtime.InteropServices.HandleRef swigCPtr;
    protected bool swigCMemOwn;
  
    internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
      swigCMemOwn = cMemoryOwn;
      swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
    }
  
    internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
      return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
    }
  
    ~Property() {
      Dispose();
    }
  
    public virtual void Dispose() {
      lock(this) {
        if (swigCPtr.Handle != global::System.IntPtr.Zero) {
          if (swigCMemOwn) {
            swigCMemOwn = false;
            NDalicPINVOKE.delete_Actor_Property(swigCPtr);
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
        global::System.GC.SuppressFinalize(this);
      }
    }
  
    public static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
    public static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
    public static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
    public static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
  
    public Property() : this(NDalicPINVOKE.new_Actor_Property(), true) {
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    }
  
    public static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
    public static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
    public static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
    public static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
    public static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
    public static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
    public static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
    public static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
    public static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
    public static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
    public static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
    public static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
    public static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
    public static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
    public static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
    public static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
    public static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
    public static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
    public static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
    public static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
    public static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
    public static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
    public static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
    public static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
    public static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
    public static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
    public static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
    public static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
    public static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
    public static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
    public static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
    public static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
    public static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
    public static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
    public static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
    public static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
    public static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
    public static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
    public static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
    public static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
    public static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
    public static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
    public static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
    public static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
    public static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
    public static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
    public static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
    public static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
    public static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
    public static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
    public static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
    public static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
    public static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
    public static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
  
  }

  public Actor () : this (NDalicPINVOKE.Actor_New(), true) {
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();

  }
  public new static Actor DownCast(BaseHandle handle) {
    Actor ret = new Actor(NDalicPINVOKE.Actor_DownCast(BaseHandle.getCPtr(handle)), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Actor(Actor copy) : this(NDalicPINVOKE.new_Actor__SWIG_1(Actor.getCPtr(copy)), true) {
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

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

  public string GetName() {
    string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetName(string name) {
    NDalicPINVOKE.Actor_SetName(swigCPtr, name);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

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

  public bool IsRoot() {
    bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool OnStage() {
    bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool IsLayer() {
    bool ret = NDalicPINVOKE.Actor_IsLayer(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

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

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

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

  public void Unparent() {
    NDalicPINVOKE.Actor_Unparent(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

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

  public Actor GetChildAt(uint index) {
    Actor ret = new Actor(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Actor FindChildByName(string actorName) {
    Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Actor FindChildById(uint id) {
    Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Actor GetParent() {
    Actor ret = new Actor(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetParentOrigin(Vector3 origin) {
    NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector3 GetCurrentParentOrigin() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetAnchorPoint(Vector3 anchorPoint) {
    NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector3 GetCurrentAnchorPoint() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetSize(float width, float height) {
    NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetSize(float width, float height, float depth) {
    NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetSize(Vector2 size) {
    NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetSize(Vector3 size) {
    NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector3 GetTargetSize() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Vector3 GetCurrentSize() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Vector3 GetNaturalSize() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetPosition(float x, float y) {
    NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetPosition(float x, float y, float z) {
    NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetPosition(Vector3 position) {
    NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetX(float x) {
    NDalicPINVOKE.Actor_SetX(swigCPtr, x);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetY(float y) {
    NDalicPINVOKE.Actor_SetY(swigCPtr, y);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetZ(float z) {
    NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void TranslateBy(Vector3 distance) {
    NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector3 GetCurrentPosition() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Vector3 GetCurrentWorldPosition() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetInheritPosition(bool inherit) {
    NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public PositionInheritanceMode GetPositionInheritanceMode() {
    PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool IsPositionInherited() {
    bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetOrientation(Degree angle, Vector3 axis) {
    NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetOrientation(Radian angle, Vector3 axis) {
    NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetOrientation(Rotation orientation) {
    NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void RotateBy(Degree angle, Vector3 axis) {
    NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void RotateBy(Radian angle, Vector3 axis) {
    NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void RotateBy(Rotation relativeRotation) {
    NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Rotation GetCurrentOrientation() {
    Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetInheritOrientation(bool inherit) {
    NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public bool IsOrientationInherited() {
    bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Rotation GetCurrentWorldOrientation() {
    Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetScale(float scale) {
    NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetScale(float scaleX, float scaleY, float scaleZ) {
    NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetScale(Vector3 scale) {
    NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void ScaleBy(Vector3 relativeScale) {
    NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector3 GetCurrentScale() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Vector3 GetCurrentWorldScale() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetInheritScale(bool inherit) {
    NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public bool IsScaleInherited() {
    bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Matrix GetCurrentWorldMatrix() {
    Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetVisible(bool visible) {
    NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public bool IsVisible() {
    bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetOpacity(float opacity) {
    NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public float GetCurrentOpacity() {
    float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

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

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

  public void SetColorMode(ColorMode colorMode) {
    NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public ColorMode GetColorMode() {
    ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

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

  public void SetDrawMode(DrawModeType drawMode) {
    NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public DrawModeType GetDrawMode() {
    DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetSensitive(bool sensitive) {
    NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public bool IsSensitive() {
    bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY) {
    bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetLeaveRequired(bool required) {
    NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public bool GetLeaveRequired() {
    bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetKeyboardFocusable(bool focusable) {
    NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public bool IsKeyboardFocusable() {
    bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetResizePolicy(ResizePolicyType policy, DimensionType dimension) {
    NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public ResizePolicyType GetResizePolicy(DimensionType dimension) {
    ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetSizeScalePolicy(SizeScalePolicyType policy) {
    NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public SizeScalePolicyType GetSizeScalePolicy() {
    SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetSizeModeFactor(Vector3 factor) {
    NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public Vector3 GetSizeModeFactor() {
    Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public float GetHeightForWidth(float width) {
    float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public float GetWidthForHeight(float height) {
    float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public float GetRelayoutSize(DimensionType dimension) {
    float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void SetPadding(PaddingType padding) {
    NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void GetPadding(PaddingType paddingOut) {
    NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetMinimumSize(Vector2 size) {
    NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

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

  public void SetMaximumSize(Vector2 size) {
    NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

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

  public int GetHierarchyDepth() {
    int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public uint AddRenderer(Renderer renderer) {
    uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

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

  public Renderer GetRendererAt(uint index) {
    Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void RemoveRenderer(Renderer renderer) {
    NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

  public void RemoveRenderer(uint index) {
    NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }

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

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

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

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

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

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

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

  public Vector3 ParentOrigin
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.PARENT_ORIGIN).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.PARENT_ORIGIN, new Dali.Property.Value( value ) );
    }
  }
  public float ParentOriginX
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.PARENT_ORIGIN_X).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.PARENT_ORIGIN_X, new Dali.Property.Value( value ) );
    }
  }
  public float ParentOriginY
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.PARENT_ORIGIN_Y).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.PARENT_ORIGIN_Y, new Dali.Property.Value( value ) );
    }
  }
  public float ParentOriginZ
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.PARENT_ORIGIN_Z).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.PARENT_ORIGIN_Z, new Dali.Property.Value( value ) );
    }
  }
  public Vector3 AnchorPoint
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.ANCHOR_POINT).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.ANCHOR_POINT, new Dali.Property.Value( value ) );
    }
  }
  public float AnchorPointX
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.ANCHOR_POINT_X).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.ANCHOR_POINT_X, new Dali.Property.Value( value ) );
    }
  }
  public float AnchorPointY
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.ANCHOR_POINT_Y).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.ANCHOR_POINT_Y, new Dali.Property.Value( value ) );
    }
  }
  public float AnchorPointZ
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.ANCHOR_POINT_Z).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.ANCHOR_POINT_Z, new Dali.Property.Value( value ) );
    }
  }
  public Vector3 Size
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.SIZE).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SIZE, new Dali.Property.Value( value ) );
    }
  }
  public float SizeWidth
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.SIZE_WIDTH).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SIZE_WIDTH, new Dali.Property.Value( value ) );
    }
  }
  public float SizeHeight
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.SIZE_HEIGHT).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SIZE_HEIGHT, new Dali.Property.Value( value ) );
    }
  }
  public float SizeDepth
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.SIZE_DEPTH).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SIZE_DEPTH, new Dali.Property.Value( value ) );
    }
  }
  public Vector3 Position
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.POSITION).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.POSITION, new Dali.Property.Value( value ) );
    }
  }
  public float PositionX
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.POSITION_X).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.POSITION_X, new Dali.Property.Value( value ) );
    }
  }
  public float PositionY
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.POSITION_Y).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.POSITION_Y, new Dali.Property.Value( value ) );
    }
  }
  public float PositionZ
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.POSITION_Z).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.POSITION_Z, new Dali.Property.Value( value ) );
    }
  }
  public Vector3 WorldPosition
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.WORLD_POSITION).Get(  temp );
      return temp;
    }
}  public float WorldPositionX
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.WORLD_POSITION_X).Get( ref temp );
      return temp;
    }
}  public float WorldPositionY
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.WORLD_POSITION_Y).Get( ref temp );
      return temp;
    }
}  public float WorldPositionZ
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.WORLD_POSITION_Z).Get( ref temp );
      return temp;
    }
}  public Rotation Orientation
  {
    get
    {
      Rotation temp = new Rotation();
      GetProperty( Actor.Property.ORIENTATION).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.ORIENTATION, new Dali.Property.Value( value ) );
    }
  }
  public Rotation WorldOrientation
  {
    get
    {
      Rotation temp = new Rotation();
      GetProperty( Actor.Property.WORLD_ORIENTATION).Get(  temp );
      return temp;
    }
}  public Vector3 Scale
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.SCALE).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SCALE, new Dali.Property.Value( value ) );
    }
  }
  public float ScaleX
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.SCALE_X).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SCALE_X, new Dali.Property.Value( value ) );
    }
  }
  public float ScaleY
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.SCALE_Y).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SCALE_Y, new Dali.Property.Value( value ) );
    }
  }
  public float ScaleZ
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.SCALE_Z).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SCALE_Z, new Dali.Property.Value( value ) );
    }
  }
  public Vector3 WorldScale
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.WORLD_SCALE).Get(  temp );
      return temp;
    }
}  public bool Visible
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.VISIBLE).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.VISIBLE, new Dali.Property.Value( value ) );
    }
  }
  public float ColorRed
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.COLOR_RED).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.COLOR_RED, new Dali.Property.Value( value ) );
    }
  }
  public float ColorGreen
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.COLOR_GREEN).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.COLOR_GREEN, new Dali.Property.Value( value ) );
    }
  }
  public float ColorBlue
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.COLOR_BLUE).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.COLOR_BLUE, new Dali.Property.Value( value ) );
    }
  }
  public float ColorAlpha
  {
    get
    {
      float temp = 0.0f;
      GetProperty( Actor.Property.COLOR_ALPHA).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.COLOR_ALPHA, new Dali.Property.Value( value ) );
    }
  }
  public Vector4 WorldColor
  {
    get
    {
      Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.WORLD_COLOR).Get(  temp );
      return temp;
    }
}  public Matrix WorldMatrix
  {
    get
    {
      Matrix temp = new Matrix();
      GetProperty( Actor.Property.WORLD_MATRIX).Get(  temp );
      return temp;
    }
}  public string Name
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.NAME).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.NAME, new Dali.Property.Value( value ) );
    }
  }
  public bool Sensitive
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.SENSITIVE).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SENSITIVE, new Dali.Property.Value( value ) );
    }
  }
  public bool LeaveRequired
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.LEAVE_REQUIRED).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.LEAVE_REQUIRED, new Dali.Property.Value( value ) );
    }
  }
  public bool InheritOrientation
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.INHERIT_ORIENTATION).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.INHERIT_ORIENTATION, new Dali.Property.Value( value ) );
    }
  }
  public bool InheritScale
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.INHERIT_SCALE).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.INHERIT_SCALE, new Dali.Property.Value( value ) );
    }
  }
  public string ColorMode
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.COLOR_MODE).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.COLOR_MODE, new Dali.Property.Value( value ) );
    }
  }
  public string PositionInheritance
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.POSITION_INHERITANCE).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.POSITION_INHERITANCE, new Dali.Property.Value( value ) );
    }
  }
  public string DrawMode
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.DRAW_MODE).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.DRAW_MODE, new Dali.Property.Value( value ) );
    }
  }
  public Vector3 SizeModeFactor
  {
    get
    {
      Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.SIZE_MODE_FACTOR).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SIZE_MODE_FACTOR, new Dali.Property.Value( value ) );
    }
  }
  public string WidthResizePolicy
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.WIDTH_RESIZE_POLICY).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.WIDTH_RESIZE_POLICY, new Dali.Property.Value( value ) );
    }
  }
  public string HeightResizePolicy
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.HEIGHT_RESIZE_POLICY).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.HEIGHT_RESIZE_POLICY, new Dali.Property.Value( value ) );
    }
  }
  public string SizeScalePolicy
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.SIZE_SCALE_POLICY).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.SIZE_SCALE_POLICY, new Dali.Property.Value( value ) );
    }
  }
  public bool WidthForHeight
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.WIDTH_FOR_HEIGHT).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.WIDTH_FOR_HEIGHT, new Dali.Property.Value( value ) );
    }
  }
  public bool HeightForWidth
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.HEIGHT_FOR_WIDTH).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.HEIGHT_FOR_WIDTH, new Dali.Property.Value( value ) );
    }
  }
  public Vector4 Padding
  {
    get
    {
      Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
      GetProperty( Actor.Property.PADDING).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.PADDING, new Dali.Property.Value( value ) );
    }
  }
  public Vector2 MinimumSize
  {
    get
    {
      Vector2 temp = new Vector2(0.0f,0.0f);
      GetProperty( Actor.Property.MINIMUM_SIZE).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.MINIMUM_SIZE, new Dali.Property.Value( value ) );
    }
  }
  public Vector2 MaximumSize
  {
    get
    {
      Vector2 temp = new Vector2(0.0f,0.0f);
      GetProperty( Actor.Property.MAXIMUM_SIZE).Get(  temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.MAXIMUM_SIZE, new Dali.Property.Value( value ) );
    }
  }
  public bool InheritPosition
  {
    get
    {
      bool temp = false;
      GetProperty( Actor.Property.INHERIT_POSITION).Get( ref temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.INHERIT_POSITION, new Dali.Property.Value( value ) );
    }
  }
  public string ClippingMode
  {
    get
    {
      string temp;
      GetProperty( Actor.Property.CLIPPING_MODE).Get( out temp );
      return temp;
    }
    set
    {
      SetProperty( Actor.Property.CLIPPING_MODE, new Dali.Property.Value( value ) );
    }
  }

}

}