Merge "Dali C#: Common Interface Define related changes" into devel/master
authordongsug.song <dongsug.song@samsung.com>
Mon, 2 Jan 2017 01:06:40 +0000 (17:06 -0800)
committerGerrit Code Review <gerrit@review.vlan103.tizen.org>
Mon, 2 Jan 2017 01:06:41 +0000 (17:06 -0800)
24 files changed:
plugins/dali-swig/Makefile.am
plugins/dali-swig/SWIG/alphafunction.i
plugins/dali-swig/SWIG/dali-core.i
plugins/dali-swig/SWIG/dali.i
plugins/dali-swig/SWIG/events/animation-event.i
plugins/dali-swig/SWIG/events/application-event.i
plugins/dali-swig/SWIG/events/stage-event.i
plugins/dali-swig/SWIG/name-changed.i [new file with mode: 0644]
plugins/dali-swig/examples/control-dashboard.cs
plugins/dali-swig/examples/custom-control.cs
plugins/dali-swig/examples/dali-test.cs
plugins/dali-swig/examples/hello-world.cs
plugins/dali-swig/examples/image-view.cs [new file with mode: 0755]
plugins/dali-swig/examples/scroll-view.cs
plugins/dali-swig/examples/spin-control.cs
plugins/dali-swig/examples/user-alphafunction.cs
plugins/dali-swig/manual/csharp/DaliEnumConstants.cs
plugins/dali-swig/manual/csharp/DaliEventHandler.cs
plugins/dali-swig/manual/csharp/FocusManager.cs
plugins/dali-swig/manual/csharp/KeyboardPreFocusChangeSignal.cs
plugins/dali-swig/manual/csharp/ManualPINVOKE.cs
plugins/dali-swig/manual/csharp/Position.cs
plugins/dali-swig/manual/csharp/Size.cs
plugins/dali-swig/property-wrapper.rb

index 1e437ce..991c0ee 100755 (executable)
@@ -48,6 +48,7 @@ check-local: examples/dali-test.exe \
              examples/spin-control.exe \
              examples/control-dashboard.exe \
              examples/user-alphafunction.exe \
+             examples/image-view.exe \
              examples/libNDalic.so examples/NDali.dll
 
 examples/%.exe: examples/%.cs
index 154641c..c9173f6 100755 (executable)
  */
 
 %typemap(cscode) Dali::AlphaFunction %{
-  public AlphaFunction(Dali.Constants.AlphaFunction.BuiltinFunction function) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_1((int)function), true)
-  {
-    if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-  }
-
   public AlphaFunction(System.Delegate func) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_2(SWIGTYPE_p_f_float__float.getCPtr(new SWIGTYPE_p_f_float__float(System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func), true))), true)
   {
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
index 1eb729a..5535ee9 100755 (executable)
 %rename(BlendingEquationType) Dali::BlendingEquation::Type;
 %rename(CameraType) Dali::Camera::Type;
 %rename(LayerBehavior) Dali::Layer::Behavior;
-%rename(DaliEndAction) Dali::Animation::EndAction;
+%rename(X) Dali::Vector2::x;
+%rename(Y) Dali::Vector2::y;
+%rename(Width) Dali::Vector2::width;
+%rename(Height) Dali::Vector2::height;
+%rename(X) Dali::Vector3::x;
+%rename(Y) Dali::Vector3::y;
+%rename(Z) Dali::Vector3::z;
+%rename(Width) Dali::Vector3::width;
+%rename(Height) Dali::Vector3::height;
+%rename(Depth) Dali::Vector3::depth;
+%rename(X) Dali::Vector4::x;
+%rename(Y) Dali::Vector4::y;
+%rename(Z) Dali::Vector4::z;
+%rename(W) Dali::Vector4::w;
+
 
 typedef std::pair<std::string, Dali::Property::Value> StringValuePair;
 typedef std::vector<Dali::TouchPoint> TouchPointContainer;
index ee70716..1f5149b 100755 (executable)
@@ -218,6 +218,7 @@ using namespace Dali::Toolkit;
 %include events/videoview-event.i
 
 %include alphafunction.i
+%include name-changed.i
 
 %include dali-operator.i
 %include dali-core.i
index 2bbc118..41e816a 100755 (executable)
@@ -109,11 +109,11 @@ using System.Runtime.InteropServices;
     }
   }
 
-  public Dali.Constants.Animation.State Status
+  public Animation.State Status
   {
     get
     {
-       return (Dali.Constants.Animation.State)GetState();
+       return GetState();
     }
   }
 
@@ -143,74 +143,36 @@ using System.Runtime.InteropServices;
     }
   }
 
-  public Dali.Constants.Animation.EndAction EndAction
+  public Animation.EndActions EndAction
   {
     set
     {
-        switch(value)
-        {
-          case Dali.Constants.Animation.EndAction.Cancel :
-            SetEndAction(Dali.Animation.DaliEndAction.Bake);
-            break;
-          case Dali.Constants.Animation.EndAction.Discard :
-            SetEndAction(Dali.Animation.DaliEndAction.Discard);
-            break;
-          case Dali.Constants.Animation.EndAction.Stop :
-            SetEndAction(Dali.Animation.DaliEndAction.BakeFinal);
-            break;
-          default :
-            SetEndAction(Dali.Animation.DaliEndAction.Bake);
-            break;
-        }
+      SetEndAction(value);
     }
     get
     {
-        Dali.Animation.DaliEndAction temp = GetEndAction();
-        switch(temp)
-        {
-          case Dali.Animation.DaliEndAction.Bake :
-            return Dali.Constants.Animation.EndAction.Cancel;
-          case Dali.Animation.DaliEndAction.Discard :
-            return Dali.Constants.Animation.EndAction.Discard;
-          case Dali.Animation.DaliEndAction.BakeFinal :
-            return Dali.Constants.Animation.EndAction.Stop;
-          default :
-            return Dali.Constants.Animation.EndAction.Cancel;
-        }
+      return GetEndAction();
     }
   }
 
-  public void Stop(Dali.Constants.Animation.EndAction action) {
-    switch( action )
-    {
-      case Dali.Constants.Animation.EndAction.Cancel :
-        SetEndAction(Dali.Animation.DaliEndAction.Bake);
-        break;
-      case Dali.Constants.Animation.EndAction.Discard :
-        SetEndAction(Dali.Animation.DaliEndAction.Discard);
-        break;
-      case Dali.Constants.Animation.EndAction.Stop :
-        SetEndAction(Dali.Animation.DaliEndAction.BakeFinal);
-        break;
-      default :
-        SetEndAction(Dali.Animation.DaliEndAction.Bake);
-        break;
-    }
+  public void Stop(Animation.EndActions action) 
+  {
+    SetEndAction(action);
     NDalicPINVOKE.Animation_Stop(swigCPtr);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
   }
 
   public int StartTime { set; get; }
   public int EndTime { set; get; }
-  public string TargetPoperty { set; get; }
+  public string TargetProperty { set; get; }
   public object Destination { set; get; }
   public Dali.AlphaFunction AlphaFunction { set; get; }
 
 
   public void AnimateBy(Actor target)
   {
-    string _str1 = TargetPoperty.Substring(0, 1);
-    string _str2 = TargetPoperty.Substring(1);
+    string _str1 = TargetProperty.Substring(0, 1);
+    string _str2 = TargetProperty.Substring(1);
     string _str = _str1.ToLower() + _str2;
 
     dynamic obj = (object)Destination;
@@ -223,7 +185,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
       }
     }
@@ -235,7 +197,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateBy(new Property(target, _str), new Property.Value(obj), time );
       }
     }
@@ -257,7 +219,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
       }
     }
@@ -269,7 +231,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateBy(new Property(target, _str), new Property.Value(obj), time );
       }
     }
@@ -291,7 +253,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateBy(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
       }
     }
@@ -303,7 +265,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateBy(new Property(target, _str), new Property.Value(obj), time );
       }
     }
@@ -311,8 +273,8 @@ using System.Runtime.InteropServices;
 
   public void AnimateTo(Actor target)
   {
-    string _str1 = TargetPoperty.Substring(0, 1);
-    string _str2 = TargetPoperty.Substring(1);
+    string _str1 = TargetProperty.Substring(0, 1);
+    string _str2 = TargetProperty.Substring(1);
     string _str = _str1.ToLower() + _str2;
 
     dynamic obj = (object)Destination;
@@ -325,7 +287,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
       }
     }
@@ -337,7 +299,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateTo(new Property(target, _str), new Property.Value(obj), time );
       }
     }
@@ -359,7 +321,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
       }
     }
@@ -371,7 +333,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateTo(new Property(target, _str), new Property.Value(obj), time );
       }
     }
@@ -393,7 +355,7 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateTo(new Property(target, _str), new Property.Value(obj), this.AlphaFunction, time );
       }
     }
@@ -405,12 +367,79 @@ using System.Runtime.InteropServices;
       }
       else
       {
-        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime ) );
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
         AnimateTo(new Property(target, _str), new Property.Value(obj), time );
       }
     }
   }
 
+  public void AnimateBetween(Actor target, KeyFrames keyFrames)
+  {
+    string _str1 = TargetProperty.Substring(0, 1);
+    string _str2 = TargetProperty.Substring(1);
+    string _str = _str1.ToLower() + _str2;
+
+
+    if( this.AlphaFunction != null )
+    {
+      if( this.StartTime == 0 && this.EndTime == 0 )
+      {
+        AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction);
+      }
+      else
+      {
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
+        AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, time);
+      }
+    }
+    else
+    {
+      if( this.StartTime == 0 && this.EndTime == 0 )
+      {
+        AnimateBetween(new Property(target, _str), keyFrames);
+      }
+      else
+      {
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
+        AnimateBetween(new Property(target, _str), keyFrames, time);
+      }
+    }
+  }
+
+  public void AnimateBetween(Actor target, KeyFrames keyFrames, Animation.Interpolation interpolation)
+  {
+    string _str1 = TargetProperty.Substring(0, 1);
+    string _str2 = TargetProperty.Substring(1);
+    string _str = _str1.ToLower() + _str2;
+
+
+    if( this.AlphaFunction != null )
+    {
+      if( this.StartTime == 0 && this.EndTime == 0 )
+      {
+        AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, interpolation);
+      }
+      else
+      {
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
+        AnimateBetween(new Property(target, _str), keyFrames, this.AlphaFunction, time, interpolation);
+      }
+    }
+    else
+    {
+      if( this.StartTime == 0 && this.EndTime == 0 )
+      {
+        AnimateBetween(new Property(target, _str), keyFrames, interpolation);
+      }
+      else
+      {
+        Dali.TimePeriod time = new Dali.TimePeriod( MilliSecondsToSeconds( this.StartTime ), MilliSecondsToSeconds( this.EndTime - this.StartTime ) );
+        AnimateBetween(new Property(target, _str), keyFrames, time, interpolation);
+      }
+    }
+  }
+
+
   /**
    * @brief Create an initialized Animation.
    *
@@ -443,4 +472,21 @@ using System.Runtime.InteropServices;
   namespace Dali
 {
   DALI_animation_EVENTHANDLER_PARAM( Dali, Animation);
+
+%typemap(cscode) Dali::KeyFrames %{
+
+  public void Add(float progress, object value)
+  {
+    dynamic obj = value;
+    Add(progress, new Property.Value(obj));
+  }
+
+  public void Add(float progress, object value, AlphaFunction alpha)
+  {
+    dynamic obj = value;
+    Add(progress, new Property.Value(obj), alpha);
+  }
+
+%}
+
 }
index b6acb9d..bc81dec 100644 (file)
     using System.Runtime.InteropServices;
 
     /**
-      * @brief Event arguments that passed via AUIApplicationInit signal
+      * @brief Event arguments that passed via NUIApplicationInit signal
       *
       */
-    public class AUIApplicationInitEventArgs : EventArgs
+    public class NUIApplicationInitEventArgs : EventArgs
     {
     private Application _application;
 
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationTerminate signal
+      * @brief Event arguments that passed via NUIApplicationTerminate signal
       *
       */
-    public class AUIApplicationTerminateEventArgs : EventArgs
+    public class NUIApplicationTerminateEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationPause signal
+      * @brief Event arguments that passed via NUIApplicationPause signal
       *
       */
-    public class AUIApplicationPauseEventArgs : EventArgs
+    public class NUIApplicationPauseEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationResume signal
+      * @brief Event arguments that passed via NUIApplicationResume signal
       *
       */
-    public class AUIApplicationResumeEventArgs : EventArgs
+    public class NUIApplicationResumeEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationReset signal
+      * @brief Event arguments that passed via NUIApplicationReset signal
       *
       */
-    public class AUIApplicationResetEventArgs : EventArgs
+    public class NUIApplicationResetEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationResize signal
+      * @brief Event arguments that passed via NUIApplicationResize signal
       *
       */
-    public class AUIApplicationResizeEventArgs : EventArgs
+    public class NUIApplicationResizeEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationLanguageChanged signal
+      * @brief Event arguments that passed via NUIApplicationLanguageChanged signal
       *
       */
-    public class AUIApplicationLanguageChangedEventArgs : EventArgs
+    public class NUIApplicationLanguageChangedEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationRegionChanged signal
+      * @brief Event arguments that passed via NUIApplicationRegionChanged signal
       *
       */
-    public class AUIApplicationRegionChangedEventArgs : EventArgs
+    public class NUIApplicationRegionChangedEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationBatteryLow signal
+      * @brief Event arguments that passed via NUIApplicationBatteryLow signal
       *
       */
-    public class AUIApplicationBatteryLowEventArgs : EventArgs
+    public class NUIApplicationBatteryLowEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationMemoryLow signal
+      * @brief Event arguments that passed via NUIApplicationMemoryLow signal
       *
       */
-    public class AUIApplicationMemoryLowEventArgs : EventArgs
+    public class NUIApplicationMemoryLowEventArgs : EventArgs
     {
     private Application _application;
       /**
     }
 
     /**
-      * @brief Event arguments that passed via AUIApplicationAppControl         signal
+      * @brief Event arguments that passed via NUIApplicationAppControl         signal
       *
       */
-    public class AUIApplicationAppControlEventArgs : EventArgs
+    public class NUIApplicationAppControlEventArgs : EventArgs
     {
     private Application _application;
     private IntPtr _voidp;
 %define APPLICATION_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
   %typemap(cscode) NameSpace::ClassName %{
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationInitEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationInitEventArgs> _applicationInitEventHandler;
-    private AUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
+    private delegate void NUIApplicationInitEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationInitEventArgs> _applicationInitEventHandler;
+    private NUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
 
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationTerminateEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationTerminateEventArgs> _applicationTerminateEventHandler;
-    private AUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
+    private delegate void NUIApplicationTerminateEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationTerminateEventArgs> _applicationTerminateEventHandler;
+    private NUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
 
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationPauseEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationPauseEventArgs> _applicationPauseEventHandler;
-    private AUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
+    private delegate void NUIApplicationPauseEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationPauseEventArgs> _applicationPauseEventHandler;
+    private NUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationResumeEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationResumeEventArgs> _applicationResumeEventHandler;
-    private AUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
+    private delegate void NUIApplicationResumeEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationResumeEventArgs> _applicationResumeEventHandler;
+    private NUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationResetEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationResetEventArgs> _applicationResetEventHandler;
-    private AUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
+    private delegate void NUIApplicationResetEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationResetEventArgs> _applicationResetEventHandler;
+    private NUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationResizeEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationResizeEventArgs> _applicationResizeEventHandler;
-    private AUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
+    private delegate void NUIApplicationResizeEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationResizeEventArgs> _applicationResizeEventHandler;
+    private NUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs> _applicationLanguageChangedEventHandler;
-    private AUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
+    private delegate void NUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationLanguageChangedEventArgs> _applicationLanguageChangedEventHandler;
+    private NUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
 
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationRegionChangedEventArgs> _applicationRegionChangedEventHandler;
-    private AUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
+    private delegate void NUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationRegionChangedEventArgs> _applicationRegionChangedEventHandler;
+    private NUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationBatteryLowEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationBatteryLowEventArgs> _applicationBatteryLowEventHandler;
-    private AUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
+    private delegate void NUIApplicationBatteryLowEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationBatteryLowEventArgs> _applicationBatteryLowEventHandler;
+    private NUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationMemoryLowEventCallbackDelegate(IntPtr application);
-    private DaliEventHandler<object,AUIApplicationMemoryLowEventArgs> _applicationMemoryLowEventHandler;
-    private AUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
+    private delegate void NUIApplicationMemoryLowEventCallbackDelegate(IntPtr application);
+    private DaliEventHandler<object,NUIApplicationMemoryLowEventArgs> _applicationMemoryLowEventHandler;
+    private NUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    private delegate void AUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
-    private DaliEventHandler<object,AUIApplicationAppControlEventArgs> _applicationAppControlEventHandler;
-    private AUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
+    private delegate void NUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
+    private DaliEventHandler<object,NUIApplicationAppControlEventArgs> _applicationAppControlEventHandler;
+    private NUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
 
     /**
       * @brief Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationInitEventHandler - DaliEventHandler<object,AUIApplicationInitEventArgs>)
+      * (in the type of NUIApplicationInitEventHandler - DaliEventHandler<object,NUIApplicationInitEventArgs>)
       *  provided by the user. Initialized signal is emitted when application is initialised
       */
-    public event DaliEventHandler<object,AUIApplicationInitEventArgs> Initialized
+    public event DaliEventHandler<object,NUIApplicationInitEventArgs> Initialized
     {
       add
       {
           {
             _applicationInitEventHandler += value;
 
-            _applicationInitEventCallbackDelegate = new AUIApplicationInitEventCallbackDelegate(OnApplicationInit);
+            _applicationInitEventCallbackDelegate = new NUIApplicationInitEventCallbackDelegate(OnApplicationInit);
             this.InitSignal().Connect(_applicationInitEventCallbackDelegate);
           }
         }
     // Callback for Application InitSignal
     private void OnApplicationInit(IntPtr data)
     {
-      AUIApplicationInitEventArgs e = new AUIApplicationInitEventArgs();
+      NUIApplicationInitEventArgs e = new NUIApplicationInitEventArgs();
 
-      // Populate all members of "e" (AUIApplicationInitEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationInitEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationInitEventHandler != null)
 
     /**
       * @brief Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationTerminateEventHandler-DaliEventHandler<object,AUIApplicationTerminateEventArgs>)
+      * (in the type of NUIApplicationTerminateEventHandler-DaliEventHandler<object,NUIApplicationTerminateEventArgs>)
       *  provided by the user. Terminated signal is emitted when application is terminated
       */
-    public event DaliEventHandler<object,AUIApplicationTerminateEventArgs> Terminated
+    public event DaliEventHandler<object,NUIApplicationTerminateEventArgs> Terminated
     {
       add
       {
           {
             _applicationTerminateEventHandler += value;
 
-            _applicationTerminateEventCallbackDelegate = new AUIApplicationTerminateEventCallbackDelegate(OnAUIApplicationTerminate);
+            _applicationTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTerminate);
             this.TerminateSignal().Connect(_applicationTerminateEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application TerminateSignal
-    private void OnAUIApplicationTerminate(IntPtr data)
+    private void OnNUIApplicationTerminate(IntPtr data)
     {
-      AUIApplicationTerminateEventArgs e = new AUIApplicationTerminateEventArgs();
+      NUIApplicationTerminateEventArgs e = new NUIApplicationTerminateEventArgs();
 
-      // Populate all members of "e" (AUIApplicationTerminateEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationTerminateEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationTerminateEventHandler != null)
 
     /**
       * @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationPauseEventHandler-DaliEventHandler<object,AUIApplicationPauseEventArgs>)
+      * (in the type of NUIApplicationPauseEventHandler-DaliEventHandler<object,NUIApplicationPauseEventArgs>)
       * provided by the user. Paused signal is emitted when application is paused
       */
-    public event DaliEventHandler<object,AUIApplicationPauseEventArgs> Paused
+    public event DaliEventHandler<object,NUIApplicationPauseEventArgs> Paused
     {
       add
       {
           {
             _applicationPauseEventHandler += value;
 
-            _applicationPauseEventCallbackDelegate = new AUIApplicationPauseEventCallbackDelegate(OnAUIApplicationPause);
+            _applicationPauseEventCallbackDelegate = new NUIApplicationPauseEventCallbackDelegate(OnNUIApplicationPause);
             this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application PauseSignal
-    private void OnAUIApplicationPause(IntPtr data)
+    private void OnNUIApplicationPause(IntPtr data)
     {
-      AUIApplicationPauseEventArgs e = new AUIApplicationPauseEventArgs();
+      NUIApplicationPauseEventArgs e = new NUIApplicationPauseEventArgs();
 
-      // Populate all members of "e" (AUIApplicationPauseEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationPauseEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationPauseEventHandler != null)
 
     /**
       * @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationResumeEventHandler-DaliEventHandler<object,AUIApplicationResumeEventArgs>)
+      * (in the type of NUIApplicationResumeEventHandler-DaliEventHandler<object,NUIApplicationResumeEventArgs>)
       *  provided by the user. Resumed signal is emitted when application is resumed
       */
-    public event DaliEventHandler<object,AUIApplicationResumeEventArgs> Resumed
+    public event DaliEventHandler<object,NUIApplicationResumeEventArgs> Resumed
     {
       add
       {
           {
             _applicationResumeEventHandler += value;
 
-            _applicationResumeEventCallbackDelegate = new AUIApplicationResumeEventCallbackDelegate(OnAUIApplicationResume);
+            _applicationResumeEventCallbackDelegate = new NUIApplicationResumeEventCallbackDelegate(OnNUIApplicationResume);
             this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application ResumeSignal
-    private void OnAUIApplicationResume(IntPtr data)
+    private void OnNUIApplicationResume(IntPtr data)
     {
-      AUIApplicationResumeEventArgs e = new AUIApplicationResumeEventArgs();
+      NUIApplicationResumeEventArgs e = new NUIApplicationResumeEventArgs();
 
-      // Populate all members of "e" (AUIApplicationResumeEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationResumeEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationResumeEventHandler != null)
 
     /**
       * @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationResetEventHandler-DaliEventHandler<object,AUIApplicationResetEventArgs>)
+      * (in the type of NUIApplicationResetEventHandler-DaliEventHandler<object,NUIApplicationResetEventArgs>)
       *  provided by the user. Reset signal is emitted when application is reset
       */
-    public event DaliEventHandler<object,AUIApplicationResetEventArgs> Reset
+    public event DaliEventHandler<object,NUIApplicationResetEventArgs> Reset
     {
       add
       {
           {
             _applicationResetEventHandler += value;
 
-            _applicationResetEventCallbackDelegate = new AUIApplicationResetEventCallbackDelegate(OnAUIApplicationReset);
+            _applicationResetEventCallbackDelegate = new NUIApplicationResetEventCallbackDelegate(OnNUIApplicationReset);
             this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application ResetSignal
-    private void OnAUIApplicationReset(IntPtr data)
+    private void OnNUIApplicationReset(IntPtr data)
     {
-      AUIApplicationResetEventArgs e = new AUIApplicationResetEventArgs();
+      NUIApplicationResetEventArgs e = new NUIApplicationResetEventArgs();
 
-      // Populate all members of "e" (AUIApplicationResetEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationResetEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationResetEventHandler != null)
 
     /**
       * @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationResizeEventHandler-DaliEventHandler<object,AUIApplicationResizeEventArgs>)
+      * (in the type of NUIApplicationResizeEventHandler-DaliEventHandler<object,NUIApplicationResizeEventArgs>)
       *  provided by the user. Resized signal is emitted when application is resized
       */
-    public event DaliEventHandler<object,AUIApplicationResizeEventArgs> Resized
+    public event DaliEventHandler<object,NUIApplicationResizeEventArgs> Resized
     {
       add
       {
           {
             _applicationResizeEventHandler += value;
 
-            _applicationResizeEventCallbackDelegate = new AUIApplicationResizeEventCallbackDelegate(OnAUIApplicationResize);
+            _applicationResizeEventCallbackDelegate = new NUIApplicationResizeEventCallbackDelegate(OnNUIApplicationResize);
             this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application ResizeSignal
-    private void OnAUIApplicationResize(IntPtr data)
+    private void OnNUIApplicationResize(IntPtr data)
     {
-      AUIApplicationResizeEventArgs e = new AUIApplicationResizeEventArgs();
+      NUIApplicationResizeEventArgs e = new NUIApplicationResizeEventArgs();
 
-      // Populate all members of "e" (AUIApplicationResizeEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationResizeEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationResizeEventHandler != null)
 
     /**
       * @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationLanguageChangedEventHandler-DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs>)
+      * (in the type of NUIApplicationLanguageChangedEventHandler-DaliEventHandler<object,NUIApplicationLanguageChangedEventArgs>)
       *  provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
       */
-    public event DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs> LanguageChanged
+    public event DaliEventHandler<object,NUIApplicationLanguageChangedEventArgs> LanguageChanged
     {
       add
       {
           {
             _applicationLanguageChangedEventHandler += value;
 
-            _applicationLanguageChangedEventCallbackDelegate = new AUIApplicationLanguageChangedEventCallbackDelegate(OnAUIApplicationLanguageChanged);
+            _applicationLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationLanguageChanged);
             this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application LanguageChangedSignal
-    private void OnAUIApplicationLanguageChanged(IntPtr data)
+    private void OnNUIApplicationLanguageChanged(IntPtr data)
     {
-      AUIApplicationLanguageChangedEventArgs e = new AUIApplicationLanguageChangedEventArgs();
+      NUIApplicationLanguageChangedEventArgs e = new NUIApplicationLanguageChangedEventArgs();
 
-      // Populate all members of "e" (AUIApplicationLanguageChangedEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationLanguageChangedEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationLanguageChangedEventHandler != null)
 
     /**
       * @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationRegionChangedEventHandler-DaliEventHandler<object,AUIApplicationRegionChangedEventArgs>)
+      * (in the type of NUIApplicationRegionChangedEventHandler-DaliEventHandler<object,NUIApplicationRegionChangedEventArgs>)
       *  provided by the user. RegionChanged signal is emitted when the region of the device is changed.
       */
-    public event DaliEventHandler<object,AUIApplicationRegionChangedEventArgs> RegionChanged
+    public event DaliEventHandler<object,NUIApplicationRegionChangedEventArgs> RegionChanged
     {
       add
       {
           {
             _applicationRegionChangedEventHandler += value;
 
-            _applicationRegionChangedEventCallbackDelegate = new AUIApplicationRegionChangedEventCallbackDelegate(OnAUIApplicationRegionChanged);
+            _applicationRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationRegionChanged);
             this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application RegionChangedSignal
-    private void OnAUIApplicationRegionChanged(IntPtr data)
+    private void OnNUIApplicationRegionChanged(IntPtr data)
     {
-      AUIApplicationRegionChangedEventArgs e = new AUIApplicationRegionChangedEventArgs();
+      NUIApplicationRegionChangedEventArgs e = new NUIApplicationRegionChangedEventArgs();
 
-      // Populate all members of "e" (AUIApplicationRegionChangedEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationRegionChangedEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationRegionChangedEventHandler != null)
 
     /**
       * @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationBatteryLowEventHandler-DaliEventHandler<object,AUIApplicationBatteryLowEventArgs>) 
+      * (in the type of NUIApplicationBatteryLowEventHandler-DaliEventHandler<object,NUIApplicationBatteryLowEventArgs>) 
       * provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
       */
-    public event DaliEventHandler<object,AUIApplicationBatteryLowEventArgs> BatteryLow
+    public event DaliEventHandler<object,NUIApplicationBatteryLowEventArgs> BatteryLow
     {
       add
       {
           {
             _applicationBatteryLowEventHandler += value;
 
-            _applicationBatteryLowEventCallbackDelegate = new AUIApplicationBatteryLowEventCallbackDelegate(OnAUIApplicationBatteryLow);
+            _applicationBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationBatteryLow);
             this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application BatteryLowSignal
-    private void OnAUIApplicationBatteryLow(IntPtr data)
+    private void OnNUIApplicationBatteryLow(IntPtr data)
     {
-      AUIApplicationBatteryLowEventArgs e = new AUIApplicationBatteryLowEventArgs();
+      NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
 
-      // Populate all members of "e" (AUIApplicationBatteryLowEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationBatteryLowEventHandler != null)
 
     /**
       * @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationMemoryLowEventHandler-DaliEventHandler<object,AUIApplicationMemoryLowEventArgs>)
+      * (in the type of NUIApplicationMemoryLowEventHandler-DaliEventHandler<object,NUIApplicationMemoryLowEventArgs>)
       *  provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
       */
-    public event DaliEventHandler<object,AUIApplicationMemoryLowEventArgs> MemoryLow
+    public event DaliEventHandler<object,NUIApplicationMemoryLowEventArgs> MemoryLow
     {
       add
       {
           {
             _applicationMemoryLowEventHandler += value;
 
-            _applicationMemoryLowEventCallbackDelegate = new AUIApplicationMemoryLowEventCallbackDelegate(OnAUIApplicationMemoryLow);
+            _applicationMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationMemoryLow);
             this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application MemoryLowSignal
-    private void OnAUIApplicationMemoryLow(IntPtr data)
+    private void OnNUIApplicationMemoryLow(IntPtr data)
     {
-      AUIApplicationMemoryLowEventArgs e = new AUIApplicationMemoryLowEventArgs();
+      NUIApplicationMemoryLowEventArgs e = new NUIApplicationMemoryLowEventArgs();
 
-      // Populate all members of "e" (AUIApplicationMemoryLowEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationMemoryLowEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(data);
 
       if (_applicationMemoryLowEventHandler != null)
 
     /**
       * @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
-      * (in the type of AUIApplicationAppControlEventHandler-DaliEventHandler<object,AUIApplicationAppControlEventArgs>)
+      * (in the type of NUIApplicationAppControlEventHandler-DaliEventHandler<object,NUIApplicationAppControlEventArgs>)
       *  provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
       */
-    public event DaliEventHandler<object,AUIApplicationAppControlEventArgs> AppControl
+    public event DaliEventHandler<object,NUIApplicationAppControlEventArgs> AppControl
     {
       add
       {
           {
             _applicationAppControlEventHandler += value;
 
-            _applicationAppControlEventCallbackDelegate = new AUIApplicationAppControlEventCallbackDelegate(OnAUIApplicationAppControl);
+            _applicationAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationAppControl);
             this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
           }
         }
     }
 
     // Callback for Application AppControlSignal
-    private void OnAUIApplicationAppControl(IntPtr application, IntPtr voidp)
+    private void OnNUIApplicationAppControl(IntPtr application, IntPtr voidp)
     {
-      AUIApplicationAppControlEventArgs e = new AUIApplicationAppControlEventArgs();
+      NUIApplicationAppControlEventArgs e = new NUIApplicationAppControlEventArgs();
 
-      // Populate all members of "e" (AUIApplicationAppControlEventArgs) with real data
+      // Populate all members of "e" (NUIApplicationAppControlEventArgs) with real data
       e.Application = Application.GetApplicationFromPtr(application);
       e.VoidP = voidp;
 
index ed2dabc..6b2329b 100755 (executable)
@@ -442,6 +442,32 @@ using System.Runtime.InteropServices;
      }
    }
 
+  private static readonly Stage instance = Stage.GetCurrent();
+
+  public static Stage Instance
+  {
+      get
+      {
+          return instance;
+      }
+  }
+
+  public Layer GetDefaultLayer()
+  {
+    return this.GetRootLayer();
+  }
+
+  public void AddLayer(Layer layer)
+  {
+    this.Add( (Actor)layer );
+  }
+
+  public void RemoveLayer(Layer layer)
+  {
+    this.Remove( (Actor)layer );
+  }
+
+
 %}
 
 %enddef
diff --git a/plugins/dali-swig/SWIG/name-changed.i b/plugins/dali-swig/SWIG/name-changed.i
new file mode 100644 (file)
index 0000000..c8dbb94
--- /dev/null
@@ -0,0 +1,26 @@
+%rename( EndActions ) Dali::Animation::EndAction;
+%rename( Cancel ) Dali::Animation::Bake;
+%rename( StopFinal ) Dali::Animation::BakeFinal;
+%rename( Stopped ) Dali::Animation::STOPPED;
+%rename( Playing ) Dali::Animation::PLAYING;
+%rename( Paused ) Dali::Animation::PAUSED;
+
+%rename( Default ) Dali::AlphaFunction::DEFAULT;
+%rename( Linear ) Dali::AlphaFunction::LINEAR;
+%rename( Reverse ) Dali::AlphaFunction::REVERSE;
+%rename( EaseInSquare ) Dali::AlphaFunction::EASE_IN_SQUARE;
+%rename( EaseOutSquare ) Dali::AlphaFunction::EASE_OUT_SQUARE;
+%rename( EaseIn ) Dali::AlphaFunction::EASE_IN;
+%rename( EaseOut ) Dali::AlphaFunction::EASE_OUT;
+%rename( EaseInOut ) Dali::AlphaFunction::EASE_IN_OUT;
+%rename( EaseInSine ) Dali::AlphaFunction::EASE_IN_SINE;
+%rename( EaseOutSine) Dali::AlphaFunction::EASE_OUT_SINE;
+%rename( EaseInOutSine ) Dali::AlphaFunction::EASE_IN_OUT_SINE;
+%rename( Bounce ) Dali::AlphaFunction::BOUNCE;
+%rename( Sin ) Dali::AlphaFunction::SIN;
+%rename( EaseOutBack) Dali::AlphaFunction::EASE_OUT_BACK;
+%rename( Count) Dali::AlphaFunction::COUNT;
+%rename( BuiltinFunction ) Dali::AlphaFunction::BUILTIN_FUNCTION;
+%rename( CustomFunction ) Dali::AlphaFunction::CUSTOM_FUNCTION;
+%rename( Bezier ) Dali::AlphaFunction::BEZIER;
+
index bdd3d5d..8fe3c70 100755 (executable)
@@ -58,7 +58,7 @@ namespace MyCSharpExample
             _application.Initialized += OnInitialize;
         }
 
-        public void OnInitialize(object source, AUIApplicationInitEventArgs e)
+        public void OnInitialize(object source, NUIApplicationInitEventArgs e)
         {
             Console.WriteLine("Customized Application Initialize event handler");
             _stage = Stage.GetCurrent();
@@ -122,7 +122,7 @@ namespace MyCSharpExample
         {
             // Make label for item
             TextLabel itemLabel = new TextLabel("    " + item.name);
-            itemLabel.Size = new Vector3(_stage.GetSize().width * 0.2f, _stage.GetSize().height * 0.05f, 0.0f);
+            itemLabel.Size = new Vector3(_stage.GetSize().Width * 0.2f, _stage.GetSize().Height * 0.05f, 0.0f);
             itemLabel.HorizontalAlignment = "BEGIN";
             itemLabel.VerticalAlignment = "BOTTOM";
             itemLabel.PointSize = 18.0f;
@@ -270,7 +270,7 @@ namespace MyCSharpExample
             else
             {
                 ImageView notSupportView = new ImageView("images/not_yet_sign.png");
-                notSupportView.Size = new Vector3(_stage.GetSize().width * 0.2f, _stage.GetSize().height * 0.25f, 0.0f);
+                notSupportView.Size = new Vector3(_stage.GetSize().Width * 0.2f, _stage.GetSize().Height * 0.25f, 0.0f);
                 notSupportView.SetKeyboardFocusable(true);
                 _contentContainer.AddChild(notSupportView, new TableView.CellPosition(((uint)idx / 5) * 2 + 1, (uint)idx % 5));
             }
index 92b0610..adf3a42 100644 (file)
@@ -83,8 +83,8 @@ namespace MyCSharpExample
                     case Gesture.State.Continuing:
                     {
                         // Calculate the rating according to pan desture displacement
-                        _gestureDisplacement.x += gesture.displacement.x;
-                        int delta = (int)Math.Ceiling(_gestureDisplacement.x / 40.0f);
+                        _gestureDisplacement.X += gesture.displacement.X;
+                        int delta = (int)Math.Ceiling(_gestureDisplacement.X / 40.0f);
                         _currentValue = _myRating + delta;
 
                         // Clamp the rating
@@ -163,7 +163,7 @@ namespace MyCSharpExample
             _application.Initialized += Initialize;
         }
 
-        public void Initialize(object source, AUIApplicationInitEventArgs e)
+        public void Initialize(object source, NUIApplicationInitEventArgs e)
         {
             Stage stage = Stage.GetCurrent();
             stage.BackgroundColor = Color.White;
index b6396f7..9c02eee 100644 (file)
@@ -37,7 +37,7 @@ namespace MyCSharpExample
       Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
     }
 
-    public void Initialize(object source, AUIApplicationInitEventArgs e)
+    public void Initialize(object source, NUIApplicationInitEventArgs e)
     {
 
       OperatorTests();
@@ -58,7 +58,7 @@ namespace MyCSharpExample
       actor.Name = "MyActor";
       actor.Color = new Color(1.0f, 0.0f, 1.0f, 0.8f);
       Console.WriteLine("Actor id: {0}", actor.GetId());
-      Console.WriteLine("Actor size: " + actor.Size.x + ", " + actor.Size.y);
+      Console.WriteLine("Actor size: " + actor.Size.X + ", " + actor.Size.Y);
       Console.WriteLine("Actor name: " + actor.Name);
 
       Stage stage = Stage.GetCurrent();
index 8437e3a..324d5dd 100755 (executable)
@@ -34,15 +34,12 @@ namespace MyCSharpExample
       _application.Initialized += Initialize;
     }
 
-    public void Initialize(object source, AUIApplicationInitEventArgs e)
+    public void Initialize(object source, NUIApplicationInitEventArgs e)
     {
       Console.WriteLine("Customized Application Initialize event handler");
-      Stage stage = Stage.GetCurrent();
-      stage.BackgroundColor = Color.Cyan;
+      Stage stage = Stage.Instance;
+      stage.BackgroundColor = Color.White;
       stage.TouchEvent += OnStageTouched;
-      stage.WheelEvent += OnStageWheelMoved;
-      stage.KeyEvent += OnStageKeyPressed;
-      stage.EventProcessingFinished += OnStageEventProcessingFinished;
 
       // Add a _text label to the stage
       _text = new TextLabel("Hello Mono World");
@@ -57,13 +54,7 @@ namespace MyCSharpExample
     // Callback for _animation finished signal handling
     public void AnimationFinished(object sender, EventArgs e)
     {
-        Console.WriteLine("AnimationFinished()!");
-    }
-
-    // Callback for _animation finished signal handling
-    public void AnimationFinished2(object sender, EventArgs e)
-    {
-      Console.WriteLine("AnimationFinished2()!");
+      Console.WriteLine("AnimationFinished()!");
       if(_animation)
       {
         Console.WriteLine("Duration= " + _animation.Duration);
@@ -71,29 +62,6 @@ namespace MyCSharpExample
       }
     }
 
-    public void OnStageEventProcessingFinished(object sender, EventArgs e)
-    {
-      Console.WriteLine("OnStageEventProcessingFinished()!");
-      if( e != null)
-      {
-        Console.WriteLine("e != null !");
-      }
-    }
-
-    public void OnStageKeyPressed(object sender, Stage.KeyEventArgs e)
-    {
-      Console.WriteLine("OnStageKeyEventOccured()!");
-      Console.WriteLine("keyPressedName=" + e.KeyEvent.keyPressedName);
-      Console.WriteLine("state=" + e.KeyEvent.state);
-    }
-
-    public void OnStageWheelMoved(object sender, Stage.WheelEventArgs e)
-    {
-      Console.WriteLine("OnStageWheelEventOccured()!");
-      Console.WriteLine("direction=" + e.WheelEvent.direction);
-      Console.WriteLine("type=" + e.WheelEvent.type);
-    }
-
     // Callback for stage touched signal handling
     public void OnStageTouched(object sender, Stage.TouchEventArgs e)
     {
@@ -112,34 +80,33 @@ namespace MyCSharpExample
           Duration = 2000,
           StartTime = 0,
           EndTime = 500,
-          TargetPoperty = "Orientation",
+          TargetProperty = "Orientation",
           Destination = new Quaternion( new Radian( new Degree( 180.0f ) ), Vect3.Xaxis)
         };
         _animation.AnimateTo(_text);
 
         _animation.StartTime = 500;
         _animation.EndTime = 1000;
-        _animation.TargetPoperty = "Orientation";
+        _animation.TargetProperty = "Orientation";
         _animation.Destination = new Quaternion( new Radian( new Degree( 0.0f ) ), Vect3.Xaxis );
         _animation.AnimateTo(_text);
 
         _animation.StartTime = 1000;
         _animation.EndTime = 1500;
-        _animation.TargetPoperty = "ScaleX";
+        _animation.TargetProperty = "ScaleX";
         _animation.Destination = 3.0f;
         _animation.AnimateBy(_text);
 
         _animation.StartTime = 1500;
         _animation.EndTime = 2000;
-        _animation.TargetPoperty = "ScaleY";
+        _animation.TargetProperty = "ScaleY";
         _animation.Destination = 4.0f;
         _animation.AnimateBy(_text);
 
-        _animation.EndAction = Dali.Constants.Animation.EndAction.Discard;
+        _animation.EndAction = Animation.EndActions.Discard;
 
         // Connect the signal callback for animaiton finished signal
         _animation.Finished += AnimationFinished;
-        _animation.Finished += AnimationFinished2;
 
         // Play the _animation
         _animation.Play();
diff --git a/plugins/dali-swig/examples/image-view.cs b/plugins/dali-swig/examples/image-view.cs
new file mode 100755 (executable)
index 0000000..43656a2
--- /dev/null
@@ -0,0 +1,239 @@
+/*
+* Copyright (c) 2016 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.
+*
+*/
+
+using System;
+using System.Runtime.InteropServices;
+using Dali;
+using Dali.Constants;
+
+namespace ImageViewExample
+{
+
+  class Example
+  {
+    public static void Log(string str)
+    {
+      Console.WriteLine("[DALI C# SAMPLE] " + str);
+    }
+
+    private Dali.Application _application;
+    private Animation _animation;
+    private ImageView _imageView;
+    private bool _isAniFinised = true;
+    private Layer layer, _layer1, _layer2;
+    private PushButton _pushButton1, _pushButton2;
+    private Stage stage;
+
+    public Example(Dali.Application application)
+    {
+      _application = application;
+      _application.Initialized += Initialize;
+    }
+
+    public void Initialize(object source, NUIApplicationInitEventArgs e)
+    {
+      Log("Customized Application Initialize event handler");
+      stage = Stage.Instance;
+      stage.BackgroundColor = Color.Cyan;
+      stage.TouchEvent += OnStageTouched;
+      stage.WheelEvent += OnStageWheelMoved;
+      stage.KeyEvent += OnStageKeyPressed;
+      //stage.EventProcessingFinished += OnStageEventProcessingFinished;
+
+      layer = stage.GetDefaultLayer();
+      _layer1 = new Layer();
+      _layer2 = new Layer();
+      stage.AddLayer(_layer1);
+      stage.AddLayer(_layer2);
+      Log("_layer1.Behavior =" + _layer1.Behavior );
+      if( _layer1.Behavior == Layer.LayerBehavior.LAYER_UI )
+      {
+        _layer1.Behavior = Layer.LayerBehavior.LAYER_2D;
+        Log("again _layer1.Behavior =" + _layer1.Behavior );
+      }
+      // Add a ImageView to the stage
+      _imageView = new ImageView();
+      _imageView.ResourceUrl = "./images/gallery-3.jpg";
+      _imageView.ParentOrigin = ParentOrigin.Center;
+      _imageView.AnchorPoint = AnchorPoint.Center;
+      _imageView.PixelArea = new Vector4(0.0f, 0.0f, 0.5f, 0.5f);
+      //_imageView.SetResizePolicy(ResizePolicyType.USE_NATURAL_SIZE, DimensionType.ALL_DIMENSIONS);
+      layer.Add(_imageView);
+
+      _pushButton1 = new PushButton();
+      _pushButton1.ParentOrigin = ParentOrigin.BottomLeft;
+      _pushButton1.AnchorPoint = AnchorPoint.BottomLeft;
+      _pushButton1.LabelText = "start animation";
+      _pushButton1.Position = new Vector3(0.0f, stage.Size.Height * 0.1f, 0.0f);
+      _pushButton1.Clicked += OnPushButtonClicked1;
+      _layer1.Add(_pushButton1);
+
+      _pushButton2 = new PushButton();
+      _pushButton2.ParentOrigin = ParentOrigin.BottomLeft;
+      _pushButton2.AnchorPoint = AnchorPoint.BottomLeft;
+      _pushButton2.LabelText = "reload image with same URL";
+      _pushButton2.Position = new Vector3(0.0f, stage.Size.Height * 0.2f, 0.0f);
+      _pushButton2.Clicked += OnPushButtonClicked2;
+      _layer2.Add(_pushButton2);
+
+    }
+
+    public bool OnPushButtonClicked2(object sender, Button.ClickedEventArgs e)
+    {
+      if( _imageView )
+      {
+        Log("OnPushButtonClicked2()!");
+        layer.Remove(_imageView);
+        _imageView = new ImageView();
+        _imageView.ResourceUrl = "./images/gallery-3.jpg";
+        _imageView.ParentOrigin = ParentOrigin.Center;
+        _imageView.AnchorPoint = AnchorPoint.Center;
+        _imageView.PixelArea = new Vector4(0.0f, 0.0f, 0.5f, 0.5f);
+        //_imageView.SetResizePolicy(ResizePolicyType.USE_NATURAL_SIZE, DimensionType.ALL_DIMENSIONS);
+        layer.Add(_imageView);
+      }
+
+      return true;
+    }
+
+
+    public bool OnPushButtonClicked1(object sender, Button.ClickedEventArgs e)
+    {
+      if( _isAniFinised == true )
+      {
+        _isAniFinised = false;
+        Log("OnPushButtonClicked1()!");
+
+        // Create a new _animation
+        if( _animation )
+        {
+          //_animation.Stop(Dali.Constants.Animation.EndAction.Stop);
+          _animation.Reset();
+        }
+
+        _animation = new Animation();
+        _animation.StartTime = 0;
+        _animation.EndTime = 1000;
+        _animation.TargetProperty = "PixelArea";
+        _animation.Destination = new Vector4(0.5f, 0.0f, 0.5f, 0.5f);
+        _animation.AnimateTo(_imageView);
+
+        _animation.StartTime = 1000;
+        _animation.EndTime = 2000;
+        _animation.TargetProperty = "PixelArea";
+        _animation.Destination = new Vector4(0.5f, 0.5f, 0.5f, 0.5f);
+        _animation.AnimateTo(_imageView);
+
+        _animation.StartTime = 2000;
+        _animation.EndTime = 3000;
+        _animation.TargetProperty = "PixelArea";
+        _animation.Destination = new Vector4(0.0f, 0.0f, 1.0f, 1.0f);
+        _animation.AnimateTo(_imageView);
+
+        _animation.StartTime = 3000;
+        _animation.EndTime = 4000;
+        _animation.TargetProperty = "PixelArea";
+        _animation.Destination = new Vector4(0.5f, 0.5f, 0.5f, 0.5f);
+        _animation.AnimateTo(_imageView);
+
+        _animation.StartTime = 4000;
+        _animation.EndTime = 6000;
+        _animation.TargetProperty = "Size";
+        KeyFrames _keyFrames = new KeyFrames();
+        _keyFrames.Add(0.0f, new Size3D(0.0f, 0.0f, 0.0f) );
+        _keyFrames.Add(0.3f, new Size3D( (stage.Size * 0.7f) ) );
+        _keyFrames.Add(1.0f, new Size3D( stage.Size ) );
+        _animation.AnimateBetween(_imageView, _keyFrames, Animation.Interpolation.Linear);
+
+        _animation.EndAction = Animation.EndActions.Discard;
+
+        // Connect the signal callback for animaiton finished signal
+        _animation.Finished += AnimationFinished;
+        _animation.Finished += AnimationFinished2;
+
+        // Play the _animation
+        _animation.Play();
+      }
+
+      return true;
+    }
+
+    // Callback for _animation finished signal handling
+    public void AnimationFinished(object sender, EventArgs e)
+    {
+        Log("AnimationFinished()!");
+    }
+
+    // Callback for second _animation finished signal handling
+    public void AnimationFinished2(object sender, EventArgs e)
+    {
+      Log("AnimationFinished2()!");
+      if(_animation)
+      {
+        Log("Duration= " + _animation.Duration);
+        Log("EndAction= " + _animation.EndAction);
+        _isAniFinised = true;
+      }
+    }
+
+    public void OnStageEventProcessingFinished(object sender, EventArgs e)
+    {
+      Log("OnStageEventProcessingFinished()!");
+      if( e != null)
+      {
+        Log("e != null !");
+      }
+    }
+
+    public void OnStageKeyPressed(object sender, Stage.KeyEventArgs e)
+    {
+      Log("OnStageKeyEventOccured()!");
+      Log("keyPressedName=" + e.KeyEvent.keyPressedName);
+      Log("state=" + e.KeyEvent.state);
+    }
+
+    public void OnStageWheelMoved(object sender, Stage.WheelEventArgs e)
+    {
+      Log("OnStageWheelEventOccured()!");
+      Log("direction=" + e.WheelEvent.direction);
+      Log("type=" + e.WheelEvent.type);
+    }
+
+    // Callback for stage touched signal handling
+    public void OnStageTouched(object sender, Stage.TouchEventArgs e)
+    {
+      Log("OnStageTouched()! e.TouchData.GetState(0)=" + e.TouchData.GetState(0) );
+    }
+
+    public void MainLoop()
+    {
+      _application.MainLoop ();
+    }
+
+    /// <summary>
+    /// The main entry point for the application.
+    /// </summary>
+    [STAThread]
+    static void Main(string[] args)
+    {
+      Log("Main() called!");
+
+      Example example = new Example(Application.NewApplication());
+      example.MainLoop ();
+    }
+  }
+}
index e922f1f..71e7ff0 100755 (executable)
@@ -42,7 +42,7 @@ namespace MyCSharpExample
     }
 
 
-    public void Initialize(object source, AUIApplicationInitEventArgs e)
+    public void Initialize(object source, NUIApplicationInitEventArgs e)
     {
       CreateScrollView();
     }
@@ -165,8 +165,8 @@ namespace MyCSharpExample
 
         _animation = new Animation(1.0f); // 1 second of duration
 
-        _animation.AnimateTo(new Property(_text, Actor.Property.ORIENTATION), new Property.Value(new Quaternion( new Radian( new Degree( 180.0f ) ), Vector3.XAXIS )), new AlphaFunction(AlphaFunction.BuiltinFunction.LINEAR), new TimePeriod(0.0f, 0.5f));
-        _animation.AnimateTo(new Property(_text, Actor.Property.ORIENTATION), new Property.Value(new Quaternion( new Radian( new Degree( 0.0f ) ), Vector3.XAXIS )), new AlphaFunction(AlphaFunction.BuiltinFunction.LINEAR), new TimePeriod(0.5f, 0.5f));
+        _animation.AnimateTo(new Property(_text, Actor.Property.ORIENTATION), new Property.Value(new Quaternion( new Radian( new Degree( 180.0f ) ), Vector3.XAXIS )), new AlphaFunction(AlphaFunction.BuiltinFunction.Linear), new TimePeriod(0.0f, 0.5f));
+        _animation.AnimateTo(new Property(_text, Actor.Property.ORIENTATION), new Property.Value(new Quaternion( new Radian( new Degree( 0.0f ) ), Vector3.XAXIS )), new AlphaFunction(AlphaFunction.BuiltinFunction.Linear), new TimePeriod(0.5f, 0.5f));
 
         // Connect the signal callback for animaiton finished signal
         _animation.Finished += AnimationFinished;
index 8e5826b..f385852 100755 (executable)
@@ -302,7 +302,7 @@ namespace MyCSharpExample
             _application.Initialized += Initialize;
         }
 
-        public void Initialize(object source, AUIApplicationInitEventArgs e)
+        public void Initialize(object source, NUIApplicationInitEventArgs e)
         {
             Stage stage = Stage.GetCurrent();
             stage.BackgroundColor = Color.White;
index 0605706..cd11e87 100755 (executable)
@@ -46,7 +46,7 @@ namespace MyCSharpExample
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
     delegate float UserAlphaFunctionDelegate(float progress);
 
-    public void Initialize(object source, AUIApplicationInitEventArgs e)
+    public void Initialize(object source, NUIApplicationInitEventArgs e)
     {
       Log("Initialize() is called!");
       Stage stage = Stage.GetCurrent();
@@ -127,13 +127,13 @@ namespace MyCSharpExample
       _animation = new Animation(10000); // 10000 milli-second of duration
       _animation.StartTime = 5000;
       _animation.EndTime = 10000;
-      _animation.TargetPoperty = "Position";
+      _animation.TargetProperty = "Position";
       _animation.AlphaFunction = new AlphaFunction(_user_alpha_func);
       _animation.Destination = new Vector3(150.0f, 150.0f, 0.0f);
       _animation.AnimateTo(_view2);
       // Connect the signal callback for animaiton finished signal
       _animation.Finished += AnimationFinished;
-      _animation.EndAction = Dali.Constants.Animation.EndAction.Discard;
+      _animation.EndAction = Animation.EndActions.Discard;
       // Play the _animation
       _animation.Play();
     }
index 71b0ddb..375445d 100755 (executable)
@@ -19,47 +19,6 @@ namespace Dali
 {
   namespace Constants
   {
-    namespace AlphaFunction
-    {
-      public enum BuiltinFunction
-      {
-        Default       = Dali.AlphaFunction.BuiltinFunction.DEFAULT,
-        Linear        = Dali.AlphaFunction.BuiltinFunction.LINEAR,
-        Reverse       = Dali.AlphaFunction.BuiltinFunction.REVERSE,
-        EaseInSquare  = Dali.AlphaFunction.BuiltinFunction.EASE_IN_SQUARE,
-        EaseOutSquare = Dali.AlphaFunction.BuiltinFunction.EASE_OUT_SQUARE,
-        EaseIn        = Dali.AlphaFunction.BuiltinFunction.EASE_IN,
-        EaseOut       = Dali.AlphaFunction.BuiltinFunction.EASE_OUT,
-        EaseInOut     = Dali.AlphaFunction.BuiltinFunction.EASE_IN_OUT,
-        EaseInSine    = Dali.AlphaFunction.BuiltinFunction.EASE_IN_SINE,
-        EaseOutSine   = Dali.AlphaFunction.BuiltinFunction.EASE_OUT_SINE,
-        EaseInOutSine = Dali.AlphaFunction.BuiltinFunction.EASE_IN_OUT_SINE,
-        Bounce        = Dali.AlphaFunction.BuiltinFunction.BOUNCE,
-        Sin           = Dali.AlphaFunction.BuiltinFunction.SIN,
-        EaseOutBack   = Dali.AlphaFunction.BuiltinFunction.EASE_OUT_BACK,
-        Count         = Dali.AlphaFunction.BuiltinFunction.COUNT
-      }
-      public enum Mode
-      {
-        BuiltinFunction  = Dali.AlphaFunction.Mode.BUILTIN_FUNCTION,
-        CustomFunction   = Dali.AlphaFunction.Mode.CUSTOM_FUNCTION,
-        Bezier           = Dali.AlphaFunction.Mode.BEZIER
-      }
-    } // namespace AlphaFunction
-
-    namespace FrameBuffer
-    {
-      namespace Attachment
-      {
-        public enum Mask 
-        {
-          None          = Dali.FrameBuffer.Attachment.Mask.NONE,          ///< No attachments are created initially                            @SINCE_1_1.45
-          Depth         = Dali.FrameBuffer.Attachment.Mask.DEPTH,         ///< Depth buffer bit-mask value                                     @SINCE_1_1.45
-          Stencil       = Dali.FrameBuffer.Attachment.Mask.STENCIL ,      ///< Stencil buffer bit-mask value                                   @SINCE_1_1.45
-          DepthStencil  = Dali.FrameBuffer.Attachment.Mask.DEPTH_STENCIL  ///< The Framebuffer will be created with depth and stencil buffer   @SINCE_1_1.45
-        }
-      } //namespace Attachment
-    } // namespace FrameBuffer
 
     public enum TextureType 
     {
@@ -88,27 +47,6 @@ namespace Dali
       OrthographicProjection = Dali.ProjectionMode.ORTHOGRAPHIC_PROJECTION      ///< Relative distance from the camera does not affect the size of objects @SINCE_1_0.0
     }
 
-    namespace Animation
-    {
-      public enum EndAction
-      {
-        Cancel = Dali.Animation.DaliEndAction.Bake,
-        Discard = Dali.Animation.DaliEndAction.Discard,
-        Stop = Dali.Animation.DaliEndAction.BakeFinal
-      }
-      public enum Interpolation
-      {
-        Linear = Dali.Animation.Interpolation.Linear,
-        Cubic = Dali.Animation.Interpolation.Cubic
-      }
-      public enum State
-      {
-        Stopped = Dali.Animation.State.STOPPED,
-        Playing = Dali.Animation.State.PLAYING,
-        Paused = Dali.Animation.State.PAUSED
-      }
-    } //namespace Animation
-
     public struct ParentOrigin
     {
       public static readonly float Top = NDalic.ParentOriginTop;
@@ -157,5 +95,55 @@ namespace Dali
       public static readonly Dali.Vector3 Zero = Dali.Vector3.ZERO;
     }
 
+    public struct Visual
+    {
+      public static readonly int PropertyType = NDalic.VISUAL_PROPERTY_TYPE;
+      public static readonly int PropertyShader = NDalic.VISUAL_PROPERTY_SHADER;
+
+      public static readonly int VertexShader = NDalic.VERTEX_SHADER;
+      public static readonly int FragmentShader = NDalic.FRAGMENT_SHADER;
+      public static readonly int SubdivideGridX = NDalic.SUBDIVIDE_GRID_X;
+      public static readonly int SubdivideGridY = NDalic.SUBDIVIDE_GRID_Y;
+      public static readonly int Hints = NDalic.HINTS;
+
+      public static readonly int Color = NDalic.COLOR;
+      public static readonly int Size = NDalic.SIZE;
+      public static readonly int AntiAliasing = NDalic.ANTI_ALIASING;
+
+      public static readonly int MixColor = NDalic.MIX_COLOR;
+
+      public static readonly int StartPosition = NDalic.START_POSITION;
+      public static readonly int EndPosition = NDalic.END_POSITION;
+      public static readonly int Center = NDalic.CENTER;
+      public static readonly int Radius = NDalic.RADIUS;
+      public static readonly int StopOffset = NDalic.STOP_OFFSET;
+      public static readonly int StopColor = NDalic.STOP_COLOR;
+      public static readonly int Units = NDalic.UNITS;
+      public static readonly int SpreadMethod = NDalic.SPREAD_METHOD;
+
+      public static readonly int ImageVisualURL = NDalic.IMAGE_VISUAL_URL;
+      public static readonly int ImageVisualFittingMode = NDalic.IMAGE_VISUAL_FITTING_MODE;
+      public static readonly int ImageVisualSamplingMode = NDalic.IMAGE_VISUAL_SAMPLING_MODE;
+      public static readonly int ImageVisualDesiredWidth = NDalic.IMAGE_VISUAL_DESIRED_WIDTH;
+      public static readonly int ImageVisualDesiredHeight = NDalic.IMAGE_VISUAL_DESIRED_HEIGHT;
+      public static readonly int ImageVisualSynchronousLoading = NDalic.IMAGE_VISUAL_SYNCHRONOUS_LOADING;
+      public static readonly int ImageVisualBorderOnly = NDalic.IMAGE_VISUAL_BORDER_ONLY;
+      public static readonly int ImageVisualBatchingEnabled = NDalic.IMAGE_VISUAL_BATCHING_ENABLED;
+      public static readonly int ImageVisualPixelArea = NDalic.IMAGE_VISUAL_PIXEL_AREA;
+      public static readonly int ImageVisualWrapModeU = NDalic.IMAGE_VISUAL_WRAP_MODE_U;
+      public static readonly int ImageVisualWrapModeV = NDalic.IMAGE_VISUAL_WRAP_MODE_V;
+
+      public enum Type
+      {
+        Border = Dali.VisualType.BORDER,
+        Color = Dali.VisualType.COLOR,
+        Gradient = Dali.VisualType.GRADIENT,
+        Image = Dali.VisualType.IMAGE,
+        Mesh = Dali.VisualType.MESH,
+        Primitive = Dali.VisualType.PRIMITIVE,
+        WireFrame = Dali.VisualType.WIREFRAME
+      }
+    }
+
   } // namespace Constants
 } // namesapce Dali
index 53e8321..f35c1de 100755 (executable)
@@ -23,13 +23,13 @@ namespace Dali {
     public delegate R DaliEventHandlerWithReturnType<T,U,R>(T source, U e);
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    public delegate void EventCallbackDelegateType0();
+    internal delegate void EventCallbackDelegateType0();
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    public delegate void EventCallbackDelegateType1<T>(T arg1);
+    internal delegate void EventCallbackDelegateType1<T>(T arg1);
 
     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
-    public delegate void EventCallbackDelegateType2<T,U>(T arg1, U arg2);
+    internal delegate void EventCallbackDelegateType2<T,U>(T arg1, U arg2);
 
 
     //this should be removed with EventHandler from .NET
index 17e7685..cb7ae8f 100755 (executable)
@@ -23,7 +23,7 @@ using System.Runtime.InteropServices;
 public class FocusManager : BaseHandle {
   private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 
-  internal FocusManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.KeyboardFocusManager_SWIGUpcast(cPtr), cMemoryOwn) {
+  internal FocusManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.FocusManager_SWIGUpcast(cPtr), cMemoryOwn) {
     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
   }
 
@@ -45,7 +45,7 @@ public class FocusManager : BaseHandle {
       if (swigCPtr.Handle != global::System.IntPtr.Zero) {
         if (swigCMemOwn) {
           swigCMemOwn = false;
-          NDalicManualPINVOKE.delete_KeyboardFocusManager(swigCPtr);
+          NDalicManualPINVOKE.delete_FocusManager(swigCPtr);
         }
         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
       }
@@ -237,23 +237,23 @@ public class PreFocusChangeEventArgs : EventArgs
 
   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
   public delegate IntPtr PreFocusChangeEventCallbackDelegate(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction);
-  private PreFocusChangeEventHandler _keyboardFocusManagerPreFocusChangeEventHandler;
-  private PreFocusChangeEventCallbackDelegate _keyboardFocusManagerPreFocusChangeEventCallbackDelegate;
+  private PreFocusChangeEventHandler _FocusManagerPreFocusChangeEventHandler;
+  private PreFocusChangeEventCallbackDelegate _FocusManagerPreFocusChangeEventCallbackDelegate;
 
   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
   private delegate void FocusChangedEventCallbackDelegate(IntPtr actorCurrent, IntPtr actorNext);
-  private FocusChangedEventHandler _keyboardFocusManagerFocusChangedEventHandler;
-  private FocusChangedEventCallbackDelegate _keyboardFocusManagerFocusChangedEventCallbackDelegate;
+  private FocusChangedEventHandler _FocusManagerFocusChangedEventHandler;
+  private FocusChangedEventCallbackDelegate _FocusManagerFocusChangedEventCallbackDelegate;
 
   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
   private delegate void FocusGroupChangedEventCallbackDelegate(IntPtr currentFocusedActor, bool forwardDirection);
-  private FocusGroupChangedEventHandler _keyboardFocusManagerFocusGroupChangedEventHandler;
-  private FocusGroupChangedEventCallbackDelegate _keyboardFocusManagerFocusGroupChangedEventCallbackDelegate;
+  private FocusGroupChangedEventHandler _FocusManagerFocusGroupChangedEventHandler;
+  private FocusGroupChangedEventCallbackDelegate _FocusManagerFocusGroupChangedEventCallbackDelegate;
 
   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
   private delegate void FocusedActorEnterKeyEventCallbackDelegate(IntPtr actor);
-  private FocusedActorEnterKeyEventHandler _keyboardFocusManagerFocusedActorEnterKeyEventHandler;
-  private FocusedActorEnterKeyEventCallbackDelegate _keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate;
+  private FocusedActorEnterKeyEventHandler _FocusManagerFocusedActorEnterKeyEventHandler;
+  private FocusedActorEnterKeyEventCallbackDelegate _FocusManagerFocusedActorEnterKeyEventCallbackDelegate;
 
   public event PreFocusChangeEventHandler PreFocusChange
   {
@@ -262,12 +262,12 @@ public class PreFocusChangeEventArgs : EventArgs
         lock(this)
         {
            // Restricted to only one listener
-           if (_keyboardFocusManagerPreFocusChangeEventHandler == null)
+           if (_FocusManagerPreFocusChangeEventHandler == null)
            {
-               _keyboardFocusManagerPreFocusChangeEventHandler += value;
+               _FocusManagerPreFocusChangeEventHandler += value;
 
-               _keyboardFocusManagerPreFocusChangeEventCallbackDelegate = new PreFocusChangeEventCallbackDelegate(OnPreFocusChange);
-              this.PreFocusChangeSignal().Connect(_keyboardFocusManagerPreFocusChangeEventCallbackDelegate);
+               _FocusManagerPreFocusChangeEventCallbackDelegate = new PreFocusChangeEventCallbackDelegate(OnPreFocusChange);
+              this.PreFocusChangeSignal().Connect(_FocusManagerPreFocusChangeEventCallbackDelegate);
            }
         }
      }
@@ -276,17 +276,17 @@ public class PreFocusChangeEventArgs : EventArgs
      {
         lock(this)
         {
-           if (_keyboardFocusManagerPreFocusChangeEventHandler != null)
+           if (_FocusManagerPreFocusChangeEventHandler != null)
            {
-              this.PreFocusChangeSignal().Disconnect(_keyboardFocusManagerPreFocusChangeEventCallbackDelegate);
+              this.PreFocusChangeSignal().Disconnect(_FocusManagerPreFocusChangeEventCallbackDelegate);
            }
 
-           _keyboardFocusManagerPreFocusChangeEventHandler -= value;
+           _FocusManagerPreFocusChangeEventHandler -= value;
         }
      }
   }
 
-  // Callback for KeyboardFocusManager PreFocusChangeSignal
+  // Callback for FocusManager PreFocusChangeSignal
   private IntPtr OnPreFocusChange(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction)
   {
       Actor actor = null;
@@ -297,10 +297,10 @@ public class PreFocusChangeEventArgs : EventArgs
       e.Proposed = Actor.GetActorFromPtr(proposed);
       e.Direction = direction;
 
-      if (_keyboardFocusManagerPreFocusChangeEventHandler != null)
+      if (_FocusManagerPreFocusChangeEventHandler != null)
       {
         //here we send all data to user event handlers
-          actor = _keyboardFocusManagerPreFocusChangeEventHandler(this, e);
+          actor = _FocusManagerPreFocusChangeEventHandler(this, e);
       }
 
       return actor.GetPtrfromActor();
@@ -318,12 +318,12 @@ public class PreFocusChangeEventArgs : EventArgs
         lock(this)
         {
            // Restricted to only one listener
-           if (_keyboardFocusManagerFocusChangedEventHandler == null)
+           if (_FocusManagerFocusChangedEventHandler == null)
            {
-              _keyboardFocusManagerFocusChangedEventHandler += value;
+              _FocusManagerFocusChangedEventHandler += value;
 
-              _keyboardFocusManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
-              this.FocusChangedSignal().Connect(_keyboardFocusManagerFocusChangedEventCallbackDelegate);
+              _FocusManagerFocusChangedEventCallbackDelegate = new FocusChangedEventCallbackDelegate(OnFocusChanged);
+              this.FocusChangedSignal().Connect(_FocusManagerFocusChangedEventCallbackDelegate);
            }
         }
      }
@@ -332,17 +332,17 @@ public class PreFocusChangeEventArgs : EventArgs
      {
         lock(this)
         {
-           if (_keyboardFocusManagerFocusChangedEventHandler != null)
+           if (_FocusManagerFocusChangedEventHandler != null)
            {
-              this.FocusChangedSignal().Disconnect(_keyboardFocusManagerFocusChangedEventCallbackDelegate);
+              this.FocusChangedSignal().Disconnect(_FocusManagerFocusChangedEventCallbackDelegate);
            }
 
-           _keyboardFocusManagerFocusChangedEventHandler -= value;
+           _FocusManagerFocusChangedEventHandler -= value;
         }
      }
   }
 
-  // Callback for KeyboardFocusManager FocusChangedSignal
+  // Callback for FocusManager FocusChangedSignal
   private void OnFocusChanged(IntPtr actorCurrent, IntPtr actorNext)
   {
      FocusChangedEventArgs e = new FocusChangedEventArgs();
@@ -351,10 +351,10 @@ public class PreFocusChangeEventArgs : EventArgs
      e.ActorCurrent = Actor.GetActorFromPtr(actorCurrent);
      e.ActorNext = Actor.GetActorFromPtr(actorNext);
 
-     if (_keyboardFocusManagerFocusChangedEventHandler != null)
+     if (_FocusManagerFocusChangedEventHandler != null)
      {
         //here we send all data to user event handlers
-        _keyboardFocusManagerFocusChangedEventHandler(this, e);
+        _FocusManagerFocusChangedEventHandler(this, e);
      }
   }
 
@@ -370,12 +370,12 @@ public class PreFocusChangeEventArgs : EventArgs
         lock(this)
         {
            // Restricted to only one listener
-           if (_keyboardFocusManagerFocusGroupChangedEventHandler == null)
+           if (_FocusManagerFocusGroupChangedEventHandler == null)
            {
-              _keyboardFocusManagerFocusGroupChangedEventHandler += value;
+              _FocusManagerFocusGroupChangedEventHandler += value;
 
-              _keyboardFocusManagerFocusGroupChangedEventCallbackDelegate = new FocusGroupChangedEventCallbackDelegate(OnFocusGroupChanged);
-              this.FocusGroupChangedSignal().Connect(_keyboardFocusManagerFocusGroupChangedEventCallbackDelegate);
+              _FocusManagerFocusGroupChangedEventCallbackDelegate = new FocusGroupChangedEventCallbackDelegate(OnFocusGroupChanged);
+              this.FocusGroupChangedSignal().Connect(_FocusManagerFocusGroupChangedEventCallbackDelegate);
            }
         }
      }
@@ -384,17 +384,17 @@ public class PreFocusChangeEventArgs : EventArgs
      {
         lock(this)
         {
-           if (_keyboardFocusManagerFocusGroupChangedEventHandler != null)
+           if (_FocusManagerFocusGroupChangedEventHandler != null)
            {
-              this.FocusGroupChangedSignal().Disconnect(_keyboardFocusManagerFocusGroupChangedEventCallbackDelegate);
+              this.FocusGroupChangedSignal().Disconnect(_FocusManagerFocusGroupChangedEventCallbackDelegate);
            }
 
-           _keyboardFocusManagerFocusGroupChangedEventHandler -= value;
+           _FocusManagerFocusGroupChangedEventHandler -= value;
         }
      }
   }
 
-  // Callback for KeyboardFocusManager FocusGroupChangedSignal
+  // Callback for FocusManager FocusGroupChangedSignal
   private void OnFocusGroupChanged(IntPtr currentFocusedActor, bool forwardDirection)
   {
      FocusGroupChangedEventArgs e = new FocusGroupChangedEventArgs();
@@ -403,10 +403,10 @@ public class PreFocusChangeEventArgs : EventArgs
      e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
      e.ForwardDirection = forwardDirection;
 
-     if (_keyboardFocusManagerFocusGroupChangedEventHandler != null)
+     if (_FocusManagerFocusGroupChangedEventHandler != null)
      {
         //here we send all data to user event handlers
-        _keyboardFocusManagerFocusGroupChangedEventHandler(this, e);
+        _FocusManagerFocusGroupChangedEventHandler(this, e);
      }
   }
 
@@ -422,12 +422,12 @@ public class PreFocusChangeEventArgs : EventArgs
         lock(this)
         {
            // Restricted to only one listener
-           if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler == null)
+           if (_FocusManagerFocusedActorEnterKeyEventHandler == null)
            {
-              _keyboardFocusManagerFocusedActorEnterKeyEventHandler += value;
+              _FocusManagerFocusedActorEnterKeyEventHandler += value;
 
-              _keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate = new FocusedActorEnterKeyEventCallbackDelegate(OnFocusedActorEnterKey);
-              this.FocusedActorEnterKeySignal().Connect(_keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+              _FocusManagerFocusedActorEnterKeyEventCallbackDelegate = new FocusedActorEnterKeyEventCallbackDelegate(OnFocusedActorEnterKey);
+              this.FocusedActorEnterKeySignal().Connect(_FocusManagerFocusedActorEnterKeyEventCallbackDelegate);
            }
         }
      }
@@ -436,17 +436,17 @@ public class PreFocusChangeEventArgs : EventArgs
      {
         lock(this)
         {
-           if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler != null)
+           if (_FocusManagerFocusedActorEnterKeyEventHandler != null)
            {
-              this.FocusedActorEnterKeySignal().Disconnect(_keyboardFocusManagerFocusedActorEnterKeyEventCallbackDelegate);
+              this.FocusedActorEnterKeySignal().Disconnect(_FocusManagerFocusedActorEnterKeyEventCallbackDelegate);
            }
 
-           _keyboardFocusManagerFocusedActorEnterKeyEventHandler -= value;
+           _FocusManagerFocusedActorEnterKeyEventHandler -= value;
         }
      }
   }
 
-  // Callback for KeyboardFocusManager FocusedActorEnterKeySignal
+  // Callback for FocusManager FocusedActorEnterKeySignal
   private void OnFocusedActorEnterKey(IntPtr actor)
   {
      FocusedActorEnterKeyEventArgs e = new FocusedActorEnterKeyEventArgs();
@@ -454,105 +454,105 @@ public class PreFocusChangeEventArgs : EventArgs
      // Populate all members of "e" (FocusedActorEnterKeyEventArgs) with real data
      e.Actor = Actor.GetActorFromPtr(actor);
 
-     if (_keyboardFocusManagerFocusedActorEnterKeyEventHandler != null)
+     if (_FocusManagerFocusedActorEnterKeyEventHandler != null)
      {
         //here we send all data to user event handlers
-        _keyboardFocusManagerFocusedActorEnterKeyEventHandler(this, e);
+        _FocusManagerFocusedActorEnterKeyEventHandler(this, e);
      }
   }
 
-  public FocusManager() : this(NDalicManualPINVOKE.new_KeyboardFocusManager(), true) {
+  public FocusManager() : this(NDalicManualPINVOKE.new_FocusManager(), true) {
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
   }
 
   public static FocusManager Get() {
-    FocusManager ret = new FocusManager(NDalicManualPINVOKE.KeyboardFocusManager_Get(), true);
+    FocusManager ret = new FocusManager(NDalicManualPINVOKE.FocusManager_Get(), true);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public bool SetCurrentFocusActor(Actor actor) {
-    bool ret = NDalicManualPINVOKE.KeyboardFocusManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));
+    bool ret = NDalicManualPINVOKE.FocusManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public Actor GetCurrentFocusActor() {
-    Actor ret = new Actor(NDalicManualPINVOKE.KeyboardFocusManager_GetCurrentFocusActor(swigCPtr), true);
+    Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetCurrentFocusActor(swigCPtr), true);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public bool MoveFocus(View.KeyboardFocus.Direction direction) {
-    bool ret = NDalicManualPINVOKE.KeyboardFocusManager_MoveFocus(swigCPtr, (int)direction);
+    bool ret = NDalicManualPINVOKE.FocusManager_MoveFocus(swigCPtr, (int)direction);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public void ClearFocus() {
-    NDalicManualPINVOKE.KeyboardFocusManager_ClearFocus(swigCPtr);
+    NDalicManualPINVOKE.FocusManager_ClearFocus(swigCPtr);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
   }
 
   public void SetFocusGroupLoop(bool enabled) {
-    NDalicManualPINVOKE.KeyboardFocusManager_SetFocusGroupLoop(swigCPtr, enabled);
+    NDalicManualPINVOKE.FocusManager_SetFocusGroupLoop(swigCPtr, enabled);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
   }
 
   public bool GetFocusGroupLoop() {
-    bool ret = NDalicManualPINVOKE.KeyboardFocusManager_GetFocusGroupLoop(swigCPtr);
+    bool ret = NDalicManualPINVOKE.FocusManager_GetFocusGroupLoop(swigCPtr);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public void SetAsFocusGroup(Actor actor, bool isFocusGroup) {
-    NDalicManualPINVOKE.KeyboardFocusManager_SetAsFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);
+    NDalicManualPINVOKE.FocusManager_SetAsFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
   }
 
   public bool IsFocusGroup(Actor actor) {
-    bool ret = NDalicManualPINVOKE.KeyboardFocusManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));
+    bool ret = NDalicManualPINVOKE.FocusManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public Actor GetFocusGroup(Actor actor) {
-    Actor ret = new Actor(NDalicManualPINVOKE.KeyboardFocusManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);
+    Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public void SetFocusIndicatorActor(Actor indicator) {
-    NDalicManualPINVOKE.KeyboardFocusManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
+    NDalicManualPINVOKE.FocusManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
   }
 
   public Actor GetFocusIndicatorActor() {
-    Actor ret = new Actor(NDalicManualPINVOKE.KeyboardFocusManager_GetFocusIndicatorActor(swigCPtr), true);
+    Actor ret = new Actor(NDalicManualPINVOKE.FocusManager_GetFocusIndicatorActor(swigCPtr), true);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
-  public KeyboardPreFocusChangeSignal PreFocusChangeSignal() {
-    KeyboardPreFocusChangeSignal ret = new KeyboardPreFocusChangeSignal(NDalicManualPINVOKE.KeyboardFocusManager_PreFocusChangeSignal(swigCPtr), false);
+  public PreFocusChangeSignal PreFocusChangeSignal() {
+    PreFocusChangeSignal ret = new PreFocusChangeSignal(NDalicManualPINVOKE.FocusManager_PreFocusChangeSignal(swigCPtr), false);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public FocusChangedSignal FocusChangedSignal() {
-    FocusChangedSignal ret = new FocusChangedSignal(NDalicManualPINVOKE.KeyboardFocusManager_FocusChangedSignal(swigCPtr), false);
+    FocusChangedSignal ret = new FocusChangedSignal(NDalicManualPINVOKE.FocusManager_FocusChangedSignal(swigCPtr), false);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public FocusGroupChangedSignal FocusGroupChangedSignal() {
-    FocusGroupChangedSignal ret = new FocusGroupChangedSignal(NDalicManualPINVOKE.KeyboardFocusManager_FocusGroupChangedSignal(swigCPtr), false);
+    FocusGroupChangedSignal ret = new FocusGroupChangedSignal(NDalicManualPINVOKE.FocusManager_FocusGroupChangedSignal(swigCPtr), false);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public ActorSignal FocusedActorEnterKeySignal() {
-    ActorSignal ret = new ActorSignal(NDalicManualPINVOKE.KeyboardFocusManager_FocusedActorEnterKeySignal(swigCPtr), false);
+    ActorSignal ret = new ActorSignal(NDalicManualPINVOKE.FocusManager_FocusedActorEnterKeySignal(swigCPtr), false);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
index bd49666..69484ef 100755 (executable)
@@ -19,22 +19,22 @@ using System;
 
 namespace Dali {
 
-public delegate IntPtr SwigDelegateKeyboardPreFocusChangeSignal(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction);
+public delegate IntPtr SwigDelegatePreFocusChangeSignal(IntPtr current, IntPtr proposed, View.KeyboardFocus.Direction direction);
 
-public class KeyboardPreFocusChangeSignal : global::System.IDisposable {
+public class PreFocusChangeSignal : global::System.IDisposable {
   private global::System.Runtime.InteropServices.HandleRef swigCPtr;
   protected bool swigCMemOwn;
 
-  internal KeyboardPreFocusChangeSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+  internal PreFocusChangeSignal(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(KeyboardPreFocusChangeSignal obj) {
+  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PreFocusChangeSignal obj) {
     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
   }
 
-  ~KeyboardPreFocusChangeSignal() {
+  ~PreFocusChangeSignal() {
     DisposeQueue.Instance.Add(this);
   }
 
@@ -48,7 +48,7 @@ public class KeyboardPreFocusChangeSignal : global::System.IDisposable {
       if (swigCPtr.Handle != global::System.IntPtr.Zero) {
         if (swigCMemOwn) {
           swigCMemOwn = false;
-          NDalicManualPINVOKE.delete_KeyboardPreFocusChangeSignal(swigCPtr);
+          NDalicManualPINVOKE.delete_PreFocusChangeSignal(swigCPtr);
         }
         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
       }
@@ -57,37 +57,37 @@ public class KeyboardPreFocusChangeSignal : global::System.IDisposable {
   }
 
   public bool Empty() {
-    bool ret = NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Empty(swigCPtr);
+    bool ret = NDalicManualPINVOKE.PreFocusChangeSignal_Empty(swigCPtr);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public uint GetConnectionCount() {
-    uint ret = NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_GetConnectionCount(swigCPtr);
+    uint ret = NDalicManualPINVOKE.PreFocusChangeSignal_GetConnectionCount(swigCPtr);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
   public void Connect(FocusManager.PreFocusChangeEventCallbackDelegate func) {
-     NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Connect(swigCPtr, func);
+     NDalicManualPINVOKE.PreFocusChangeSignal_Connect(swigCPtr, func);
      if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  }
 
   public void Disconnect(System.Delegate func) {
     System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func);
     {
-      NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Disconnect(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip));
+      NDalicManualPINVOKE.PreFocusChangeSignal_Disconnect(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip));
       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     }
   }
 
   public Actor Emit(Actor arg1, Actor arg2, View.KeyboardFocus.Direction arg3) {
-    Actor ret = new Actor(NDalicManualPINVOKE.KeyboardPreFocusChangeSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Actor.getCPtr(arg2), (int)arg3), true);
+    Actor ret = new Actor(NDalicManualPINVOKE.PreFocusChangeSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Actor.getCPtr(arg2), (int)arg3), true);
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
-  public KeyboardPreFocusChangeSignal() : this(NDalicManualPINVOKE.new_KeyboardPreFocusChangeSignal(), true) {
+  public PreFocusChangeSignal() : this(NDalicManualPINVOKE.new_PreFocusChangeSignal(), true) {
     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
   }
 
index 77937dc..9a88a14 100755 (executable)
@@ -20,82 +20,82 @@ namespace Dali
     class NDalicManualPINVOKE
     {
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardFocusManager")]
-        public static extern global::System.IntPtr new_KeyboardFocusManager();
+        public static extern global::System.IntPtr new_FocusManager();
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardFocusManager")]
-        public static extern void delete_KeyboardFocusManager(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern void delete_FocusManager(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_Get")]
-        public static extern global::System.IntPtr KeyboardFocusManager_Get();
+        public static extern global::System.IntPtr FocusManager_Get();
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetCurrentFocusActor")]
-        public static extern bool KeyboardFocusManager_SetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+        public static extern bool FocusManager_SetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetCurrentFocusActor")]
-        public static extern global::System.IntPtr KeyboardFocusManager_GetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern global::System.IntPtr FocusManager_GetCurrentFocusActor(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_MoveFocus")]
-        public static extern bool KeyboardFocusManager_MoveFocus(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);
+        public static extern bool FocusManager_MoveFocus(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_ClearFocus")]
-        public static extern void KeyboardFocusManager_ClearFocus(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern void FocusManager_ClearFocus(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusGroupLoop")]
-        public static extern void KeyboardFocusManager_SetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2);
+        public static extern void FocusManager_SetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroupLoop")]
-        public static extern bool KeyboardFocusManager_GetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern bool FocusManager_GetFocusGroupLoop(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetAsFocusGroup")]
-        public static extern void KeyboardFocusManager_SetAsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, bool jarg3);
+        public static extern void FocusManager_SetAsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, bool jarg3);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_IsFocusGroup")]
-        public static extern bool KeyboardFocusManager_IsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+        public static extern bool FocusManager_IsFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusGroup")]
-        public static extern global::System.IntPtr KeyboardFocusManager_GetFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+        public static extern global::System.IntPtr FocusManager_GetFocusGroup(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SetFocusIndicatorActor")]
-        public static extern void KeyboardFocusManager_SetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+        public static extern void FocusManager_SetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_GetFocusIndicatorActor")]
-        public static extern global::System.IntPtr KeyboardFocusManager_GetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern global::System.IntPtr FocusManager_GetFocusIndicatorActor(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_PreFocusChangeSignal")]
-        public static extern global::System.IntPtr KeyboardFocusManager_PreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern global::System.IntPtr FocusManager_PreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusChangedSignal")]
-        public static extern global::System.IntPtr KeyboardFocusManager_FocusChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern global::System.IntPtr FocusManager_FocusChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusGroupChangedSignal")]
-        public static extern global::System.IntPtr KeyboardFocusManager_FocusGroupChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern global::System.IntPtr FocusManager_FocusGroupChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_FocusedActorEnterKeySignal")]
-        public static extern global::System.IntPtr KeyboardFocusManager_FocusedActorEnterKeySignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern global::System.IntPtr FocusManager_FocusedActorEnterKeySignal(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Empty")]
-        public static extern bool KeyboardPreFocusChangeSignal_Empty(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern bool PreFocusChangeSignal_Empty(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_GetConnectionCount")]
-        public static extern uint KeyboardPreFocusChangeSignal_GetConnectionCount(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern uint PreFocusChangeSignal_GetConnectionCount(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Connect")]
-        public static extern void KeyboardPreFocusChangeSignal_Connect(global::System.Runtime.InteropServices.HandleRef jarg1, FocusManager.PreFocusChangeEventCallbackDelegate delegate1);
+        public static extern void PreFocusChangeSignal_Connect(global::System.Runtime.InteropServices.HandleRef jarg1, FocusManager.PreFocusChangeEventCallbackDelegate delegate1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Disconnect")]
-        public static extern void KeyboardPreFocusChangeSignal_Disconnect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+        public static extern void PreFocusChangeSignal_Disconnect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardPreFocusChangeSignal_Emit")]
-        public static extern global::System.IntPtr KeyboardPreFocusChangeSignal_Emit(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, int jarg4);
+        public static extern global::System.IntPtr PreFocusChangeSignal_Emit(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, int jarg4);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_new_KeyboardPreFocusChangeSignal")]
-        public static extern global::System.IntPtr new_KeyboardPreFocusChangeSignal();
+        public static extern global::System.IntPtr new_PreFocusChangeSignal();
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_delete_KeyboardPreFocusChangeSignal")]
-        public static extern void delete_KeyboardPreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+        public static extern void delete_PreFocusChangeSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_KeyboardFocusManager_SWIGUpcast")]
-        public static extern global::System.IntPtr KeyboardFocusManager_SWIGUpcast(global::System.IntPtr jarg1);
+        public static extern global::System.IntPtr FocusManager_SWIGUpcast(global::System.IntPtr jarg1);
 
         [global::System.Runtime.InteropServices.DllImport("NDalic", EntryPoint="CSharp_Dali_ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get")]
         public static extern int ViewWrapperImpl_CONTROL_BEHAVIOUR_FLAG_COUNT_get();
index 2e58ab4..e7c72a9 100644 (file)
@@ -44,9 +44,9 @@ namespace Dali
      */
     public Position(Vector3 o)
     {
-      x = o.x;
-      y = o.y;
-      z = o.z;
+      x = o.X;
+      y = o.Y;
+      z = o.Z;
     }
 
     ///< name "X", type float (Position X value)
@@ -182,7 +182,7 @@ namespace Dali
 
     public static implicit operator Position(Vector3 vec)
     {
-      return new Position(vec.x, vec.y, vec.z);
+      return new Position(vec.X, vec.Y, vec.Z);
     }
   }
 }
index f89172a..d238d36 100644 (file)
@@ -38,8 +38,8 @@ namespace Dali
      */
     public Size(Vector2 o)
     {
-      width = o.x;
-      height = o.y;
+      width = o.X;
+      height = o.Y;
     }
 
     /**
@@ -70,6 +70,18 @@ namespace Dali
       set { height = value; }
     }
 
+    public float Width
+    {
+      get { return width; }
+      set { width = value; }
+    }
+
+    public float Height
+    {
+      get { return height; }
+      set { height = value; }
+    }
+
     /**
      * @brief operator+
      *
@@ -171,7 +183,7 @@ namespace Dali
       return copy;
     }
 
-    // User-defined conversion from Position to Vector3
+    // User-defined conversion from Position to Vector2
     public static implicit operator Vector2(Size size)
     {
       return new Vector2(size.width, size.height);
@@ -179,7 +191,116 @@ namespace Dali
 
     public static implicit operator Size(Vector2 vec)
     {
-      return new Size(vec.x, vec.y);
+      return new Size(vec.X, vec.Y);
     }
   }
+
+  public class Size3D
+  {
+    private float width;
+    private float height;
+    private float depth;
+
+    public Size3D(float a, float b, float c)
+    {
+      width = a;
+      height = b;
+      depth = c;
+    }
+
+    public Size3D()
+    {
+      width = 0.0f;
+      height = 0.0f;
+      depth = 0.0f;
+    }
+
+    public Size3D(Vector3 o)
+    {
+      width = o.X;
+      height = o.Y;
+      depth = o.Z;
+    }
+
+    public Size3D(Vector2 o)
+    {
+      width = o.X;
+      height = o.Y;
+      depth = 0.0f;
+    }
+
+    public Size3D(Size3D a)
+    {
+      width = a.width;
+      height = a.height;
+      depth = a.depth;
+    }
+
+    public float W
+    {
+      get { return width; }
+      set { width = value; }
+    }
+
+    public float H
+    {
+      get { return height; }
+      set { height = value; }
+    }
+
+    public float D
+    {
+      get { return depth; }
+      set { depth = value; }
+    }
+
+    public float Width
+    {
+      get { return width; }
+      set { width = value; }
+    }
+
+    public float Height
+    {
+      get { return height; }
+      set { height = value; }
+    }
+
+    public float Depth
+    {
+      get { return depth; }
+      set { depth = value; }
+    }
+
+    public float X
+    {
+      get { return width; }
+      set { width = value; }
+    }
+
+    public float Y
+    {
+      get { return height; }
+      set { height = value; }
+    }
+
+    public float Z
+    {
+      get { return depth; }
+      set { depth = value; }
+    }
+
+    // User-defined conversion from Position to Vector3
+    public static implicit operator Vector3(Size3D size)
+    {
+      return new Vector3(size.width, size.height, size.depth);
+    }
+
+    public static implicit operator Size3D(Vector3 vec)
+    {
+      return new Size3D(vec.X, vec.Y, vec.Z);
+    }
+
+  }
+
 }
index 37a8cf9..4abc698 100755 (executable)
@@ -312,6 +312,13 @@ def writeCSharpData
                 next
             end
 
+            #exception case <<<
+            #Tooltip gives swig build error
+            if( property.name == "Tooltip" )
+                next
+            end
+            #exception case >>>
+
             $totalProperties+=1  #  keep track of total
 
             propertyType = propertyInfo[1]    # e.g. bool or int
@@ -347,6 +354,23 @@ def writeCSharpData
             else
                    property.csharpSetter = "}"  # close the opening property declaration
             end
+
+            #exception case <<<
+            if( property.name == "Behavior" )
+                property.csharpGetter ="  public Layer.LayerBehavior #{property.name} \n"\
+                     "  { \n"\
+                     "    get \n" \
+                     "    {\n"\
+                     "      return GetBehavior();\n"\
+                     "    }\n"
+
+                property.csharpSetter = "    set \n" \
+                     "    { \n"\
+                     "      SetBehavior( value );\n" \
+                     "    }\n"\
+                     "  }\n"
+            end
+            #exception case >>>
         end
         # write normal properties to the class's own csharp file
         writePropertiesToCSharpFile( daliClass )