- AnimateBetween() API re-define, KeyFrames class Add() API re-define.
- Size3D (high level class) newly added.
- Vector2/3/4 class's variables => Pascal case naming changed.
- FocusManger: some naming which contained "Keyborad" changed.
- ImageView: sample code newly added, "PixelArea" property and AnimateBetween() are tested.
image view reloading tested.
- Stage: single-tone pattern Instance property newly added. GetDefaultLayer(), AddLayer(),
and RemoveLayer() are newly added. GetRootLayer(), Add() and Remove() will be moved to 'internal' folder.
TouchEvent, WheelEvent, KeyEvent naming changed.
- Layer: Behavior property changed to use 'LayerBehavior enum' (not use string),
MoveAbove() and MoveBelow() will be moved to 'internal' folder.
- Application: naming changed from AUIApplication to NUIApplication.
- SWIG build break: tooltip removed by property-wrapper.rb.
- miss spelling fixed (property).
- Animation enum value naming changed. add "name-changed.i". EndAction.Stop is changed to EndActions.StopFinal =>
This is because, if I use 'EndAction' then the newly added 'EndAction property' has overlapped with enum itself.
and if I use 'Stop' then the Stop() method's name is overlapped so SWIG doesn't generate Stop() method.
Change-Id: I519eb592e8d002fefa72b5bf78f830beae3f8d20
Signed-off-by: dongsug.song <dongsug.song@samsung.com>
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
*/
%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();
%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;
%include events/videoview-event.i
%include alphafunction.i
+%include name-changed.i
%include dali-operator.i
%include dali-core.i
}
}
- public Dali.Constants.Animation.State Status
+ public Animation.State Status
{
get
{
- return (Dali.Constants.Animation.State)GetState();
+ return GetState();
}
}
}
}
- 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;
}
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 );
}
}
}
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 );
}
}
}
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 );
}
}
}
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 );
}
}
}
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 );
}
}
}
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 );
}
}
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;
}
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 );
}
}
}
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 );
}
}
}
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 );
}
}
}
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 );
}
}
}
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 );
}
}
}
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.
*
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);
+ }
+
+%}
+
}
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;
}
}
+ 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
--- /dev/null
+%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;
+
_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();
{
// 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;
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));
}
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
_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;
Console.WriteLine( "InitSignal connection count = " + _application.InitSignal().GetConnectionCount() );
}
- public void Initialize(object source, AUIApplicationInitEventArgs e)
+ public void Initialize(object source, NUIApplicationInitEventArgs e)
{
OperatorTests();
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();
_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");
// 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);
}
}
- 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)
{
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();
--- /dev/null
+/*
+* 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 ();
+ }
+ }
+}
}
- public void Initialize(object source, AUIApplicationInitEventArgs e)
+ public void Initialize(object source, NUIApplicationInitEventArgs e)
{
CreateScrollView();
}
_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;
_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;
[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();
_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();
}
{
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
{
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;
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
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
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);
}
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);
}
[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
{
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);
}
}
}
{
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;
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();
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);
}
}
}
{
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();
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);
}
}
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);
}
}
}
{
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();
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);
}
}
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);
}
}
}
{
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();
// 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;
}
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);
}
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);
}
}
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();
}
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();
*/
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)
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);
}
}
}
*/
public Size(Vector2 o)
{
- width = o.x;
- height = o.y;
+ width = o.X;
+ height = o.Y;
}
/**
set { height = value; }
}
+ public float Width
+ {
+ get { return width; }
+ set { width = value; }
+ }
+
+ public float Height
+ {
+ get { return height; }
+ set { height = value; }
+ }
+
/**
* @brief operator+
*
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);
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);
+ }
+
+ }
+
}
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
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 )