//------------------------------------------------------------------------------
//
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 3.0.9
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
namespace Dali {
using System;
using System.Runtime.InteropServices;
/**
* @brief Event arguments that passed via AUIApplicationInit signal
*
*/
public class AUIApplicationInitEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being initialized
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationTerminate signal
*
*/
public class AUIApplicationTerminateEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being Terminated
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationPause signal
*
*/
public class AUIApplicationPauseEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being Paused
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationResume signal
*
*/
public class AUIApplicationResumeEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being Resumed
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationReset signal
*
*/
public class AUIApplicationResetEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being Reset
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationResize signal
*
*/
public class AUIApplicationResizeEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being Resized
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationLanguageChanged signal
*
*/
public class AUIApplicationLanguageChangedEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being affected with Device's language change
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationRegionChanged signal
*
*/
public class AUIApplicationRegionChangedEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being affected with Device's region change
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationBatteryLow signal
*
*/
public class AUIApplicationBatteryLowEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being affected when the battery level of the device is low
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationMemoryLow signal
*
*/
public class AUIApplicationMemoryLowEventArgs : EventArgs
{
private Application _application;
/**
* @brief Application - is the application that is being affected when the memory level of the device is low
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
}
/**
* @brief Event arguments that passed via AUIApplicationAppControl signal
*
*/
public class AUIApplicationAppControlEventArgs : EventArgs
{
private Application _application;
private IntPtr _voidp;
/**
* @brief Application - is the application that is receiving the launch request from another application
*
*/
public Application Application
{
get
{
return _application;
}
set
{
_application = value;
}
}
/**
* @brief VoidP - contains the information about why the application is launched
*
*/
public IntPtr VoidP
{
get
{
return _voidp;
}
set
{
_voidp = value;
}
}
}
public class Application : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Application(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Application_SWIGUpcast(cPtr), cMemoryOwn) {
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Application obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
~Application() {
Dispose();
}
public override void Dispose() {
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
NDalicPINVOKE.delete_Application(swigCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
global::System.GC.SuppressFinalize(this);
base.Dispose();
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationInitEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationInitEventHandler;
private AUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationTerminateEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationTerminateEventHandler;
private AUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationPauseEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationPauseEventHandler;
private AUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationResumeEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationResumeEventHandler;
private AUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationResetEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationResetEventHandler;
private AUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationResizeEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationResizeEventHandler;
private AUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationLanguageChangedEventHandler;
private AUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationRegionChangedEventHandler;
private AUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationBatteryLowEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationBatteryLowEventHandler;
private AUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationMemoryLowEventCallbackDelegate(IntPtr application);
private DaliEventHandler _applicationMemoryLowEventHandler;
private AUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
private DaliEventHandler _applicationAppControlEventHandler;
private AUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
/**
* @brief Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationInitEventHandler - DaliEventHandler)
* provided by the user. Initialized signal is emitted when application is initialised
*/
public event DaliEventHandler Initialized
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationInitEventHandler == null)
{
_applicationInitEventHandler += value;
_applicationInitEventCallbackDelegate = new AUIApplicationInitEventCallbackDelegate(OnApplicationInit);
this.InitSignal().Connect(_applicationInitEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationInitEventHandler != null)
{
this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
}
_applicationInitEventHandler -= value;
}
}
}
// Callback for Application InitSignal
private void OnApplicationInit(IntPtr data)
{
AUIApplicationInitEventArgs e = new AUIApplicationInitEventArgs();
// Populate all members of "e" (AUIApplicationInitEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationInitEventHandler != null)
{
//here we send all data to user event handlers
_applicationInitEventHandler(this, e);
}
}
/**
* @brief Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationTerminateEventHandler-DaliEventHandler)
* provided by the user. Terminated signal is emitted when application is terminated
*/
public event DaliEventHandler Terminated
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationTerminateEventHandler == null)
{
_applicationTerminateEventHandler += value;
_applicationTerminateEventCallbackDelegate = new AUIApplicationTerminateEventCallbackDelegate(OnAUIApplicationTerminate);
this.TerminateSignal().Connect(_applicationTerminateEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationTerminateEventHandler != null)
{
this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
}
_applicationTerminateEventHandler -= value;
}
}
}
// Callback for Application TerminateSignal
private void OnAUIApplicationTerminate(IntPtr data)
{
AUIApplicationTerminateEventArgs e = new AUIApplicationTerminateEventArgs();
// Populate all members of "e" (AUIApplicationTerminateEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationTerminateEventHandler != null)
{
//here we send all data to user event handlers
_applicationTerminateEventHandler(this, e);
}
}
/**
* @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationPauseEventHandler-DaliEventHandler)
* provided by the user. Paused signal is emitted when application is paused
*/
public event DaliEventHandler Paused
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationPauseEventHandler == null)
{
_applicationPauseEventHandler += value;
_applicationPauseEventCallbackDelegate = new AUIApplicationPauseEventCallbackDelegate(OnAUIApplicationPause);
this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationPauseEventHandler != null)
{
this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
}
_applicationPauseEventHandler -= value;
}
}
}
// Callback for Application PauseSignal
private void OnAUIApplicationPause(IntPtr data)
{
AUIApplicationPauseEventArgs e = new AUIApplicationPauseEventArgs();
// Populate all members of "e" (AUIApplicationPauseEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationPauseEventHandler != null)
{
//here we send all data to user event handlers
_applicationPauseEventHandler(this, e);
}
}
/**
* @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationResumeEventHandler-DaliEventHandler)
* provided by the user. Resumed signal is emitted when application is resumed
*/
public event DaliEventHandler Resumed
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationResumeEventHandler == null)
{
_applicationResumeEventHandler += value;
_applicationResumeEventCallbackDelegate = new AUIApplicationResumeEventCallbackDelegate(OnAUIApplicationResume);
this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationResumeEventHandler != null)
{
this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
}
_applicationResumeEventHandler -= value;
}
}
}
// Callback for Application ResumeSignal
private void OnAUIApplicationResume(IntPtr data)
{
AUIApplicationResumeEventArgs e = new AUIApplicationResumeEventArgs();
// Populate all members of "e" (AUIApplicationResumeEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationResumeEventHandler != null)
{
//here we send all data to user event handlers
_applicationResumeEventHandler(this, e);
}
}
/**
* @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationResetEventHandler-DaliEventHandler)
* provided by the user. Reset signal is emitted when application is reset
*/
public event DaliEventHandler Reset
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationResetEventHandler == null)
{
_applicationResetEventHandler += value;
_applicationResetEventCallbackDelegate = new AUIApplicationResetEventCallbackDelegate(OnAUIApplicationReset);
this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationResetEventHandler != null)
{
this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
}
_applicationResetEventHandler -= value;
}
}
}
// Callback for Application ResetSignal
private void OnAUIApplicationReset(IntPtr data)
{
AUIApplicationResetEventArgs e = new AUIApplicationResetEventArgs();
// Populate all members of "e" (AUIApplicationResetEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationResetEventHandler != null)
{
//here we send all data to user event handlers
_applicationResetEventHandler(this, e);
}
}
/**
* @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationResizeEventHandler-DaliEventHandler)
* provided by the user. Resized signal is emitted when application is resized
*/
public event DaliEventHandler Resized
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationResizeEventHandler == null)
{
_applicationResizeEventHandler += value;
_applicationResizeEventCallbackDelegate = new AUIApplicationResizeEventCallbackDelegate(OnAUIApplicationResize);
this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationResizeEventHandler != null)
{
this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
}
_applicationResizeEventHandler -= value;
}
}
}
// Callback for Application ResizeSignal
private void OnAUIApplicationResize(IntPtr data)
{
AUIApplicationResizeEventArgs e = new AUIApplicationResizeEventArgs();
// Populate all members of "e" (AUIApplicationResizeEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationResizeEventHandler != null)
{
//here we send all data to user event handlers
_applicationResizeEventHandler(this, e);
}
}
/**
* @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationLanguageChangedEventHandler-DaliEventHandler)
* provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
*/
public event DaliEventHandler LanguageChanged
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationLanguageChangedEventHandler == null)
{
_applicationLanguageChangedEventHandler += value;
_applicationLanguageChangedEventCallbackDelegate = new AUIApplicationLanguageChangedEventCallbackDelegate(OnAUIApplicationLanguageChanged);
this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationLanguageChangedEventHandler != null)
{
this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
}
_applicationLanguageChangedEventHandler -= value;
}
}
}
// Callback for Application LanguageChangedSignal
private void OnAUIApplicationLanguageChanged(IntPtr data)
{
AUIApplicationLanguageChangedEventArgs e = new AUIApplicationLanguageChangedEventArgs();
// Populate all members of "e" (AUIApplicationLanguageChangedEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationLanguageChangedEventHandler != null)
{
//here we send all data to user event handlers
_applicationLanguageChangedEventHandler(this, e);
}
}
/**
* @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationRegionChangedEventHandler-DaliEventHandler)
* provided by the user. RegionChanged signal is emitted when the region of the device is changed.
*/
public event DaliEventHandler RegionChanged
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationRegionChangedEventHandler == null)
{
_applicationRegionChangedEventHandler += value;
_applicationRegionChangedEventCallbackDelegate = new AUIApplicationRegionChangedEventCallbackDelegate(OnAUIApplicationRegionChanged);
this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationRegionChangedEventHandler != null)
{
this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
}
_applicationRegionChangedEventHandler -= value;
}
}
}
// Callback for Application RegionChangedSignal
private void OnAUIApplicationRegionChanged(IntPtr data)
{
AUIApplicationRegionChangedEventArgs e = new AUIApplicationRegionChangedEventArgs();
// Populate all members of "e" (AUIApplicationRegionChangedEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationRegionChangedEventHandler != null)
{
//here we send all data to user event handlers
_applicationRegionChangedEventHandler(this, e);
}
}
/**
* @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationBatteryLowEventHandler-DaliEventHandler)
* provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
*/
public event DaliEventHandler BatteryLow
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationBatteryLowEventHandler == null)
{
_applicationBatteryLowEventHandler += value;
_applicationBatteryLowEventCallbackDelegate = new AUIApplicationBatteryLowEventCallbackDelegate(OnAUIApplicationBatteryLow);
this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationBatteryLowEventHandler != null)
{
this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
}
_applicationBatteryLowEventHandler -= value;
}
}
}
// Callback for Application BatteryLowSignal
private void OnAUIApplicationBatteryLow(IntPtr data)
{
AUIApplicationBatteryLowEventArgs e = new AUIApplicationBatteryLowEventArgs();
// Populate all members of "e" (AUIApplicationBatteryLowEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationBatteryLowEventHandler != null)
{
//here we send all data to user event handlers
_applicationBatteryLowEventHandler(this, e);
}
}
/**
* @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationMemoryLowEventHandler-DaliEventHandler)
* provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
*/
public event DaliEventHandler MemoryLow
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationMemoryLowEventHandler == null)
{
_applicationMemoryLowEventHandler += value;
_applicationMemoryLowEventCallbackDelegate = new AUIApplicationMemoryLowEventCallbackDelegate(OnAUIApplicationMemoryLow);
this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationMemoryLowEventHandler != null)
{
this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
}
_applicationMemoryLowEventHandler -= value;
}
}
}
// Callback for Application MemoryLowSignal
private void OnAUIApplicationMemoryLow(IntPtr data)
{
AUIApplicationMemoryLowEventArgs e = new AUIApplicationMemoryLowEventArgs();
// Populate all members of "e" (AUIApplicationMemoryLowEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(data);
if (_applicationMemoryLowEventHandler != null)
{
//here we send all data to user event handlers
_applicationMemoryLowEventHandler(this, e);
}
}
/**
* @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
* (in the type of AUIApplicationAppControlEventHandler-DaliEventHandler)
* provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
*/
public event DaliEventHandler AppControl
{
add
{
lock(this)
{
// Restricted to only one listener
if (_applicationAppControlEventHandler == null)
{
_applicationAppControlEventHandler += value;
_applicationAppControlEventCallbackDelegate = new AUIApplicationAppControlEventCallbackDelegate(OnAUIApplicationAppControl);
this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
}
}
}
remove
{
lock(this)
{
if (_applicationAppControlEventHandler != null)
{
this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
}
_applicationAppControlEventHandler -= value;
}
}
}
// Callback for Application AppControlSignal
private void OnAUIApplicationAppControl(IntPtr application, IntPtr voidp)
{
AUIApplicationAppControlEventArgs e = new AUIApplicationAppControlEventArgs();
// Populate all members of "e" (AUIApplicationAppControlEventArgs) with real data
e.Application = Application.GetApplicationFromPtr(application);
e.VoidP = voidp;
if (_applicationAppControlEventHandler != null)
{
//here we send all data to user event handlers
_applicationAppControlEventHandler(this, e);
}
}
private static Application instance; // singleton
public delegate void InitDelegate();
public delegate void TerminateDelegate();
public delegate void PauseDelegate();
public delegate void ResumeDelegate();
public delegate void ResizeDelegate();
public delegate void AppControlDelegate();
public delegate void LanguageChangedDelegate();
public delegate void RegionChangedDelegate();
public delegate void BatteryLowDelegate();
public delegate void MemoryLowDelegate();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void InitDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void TerminateDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void PauseDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void ResumeDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void ResizeDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void AppControlDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void LanguageChangedDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void RegionChangedDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void BatteryLowDelegateInternal();
[System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
internal delegate void MemoryLowDelegateInternal();
static void Initialize()
{
// instance.InitDelegate();
}
public static Application GetApplicationFromPtr(global::System.IntPtr cPtr) {
Application ret = new Application(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
internal void SetupDelegates() {
InitDelegateInternal initializeCallback = new InitDelegateInternal( Initialize );
System.Console.WriteLine( "InitSignal connection count");
this.InitSignal().Connect( initializeCallback );
//Console.WriteLine( "InitSignal connection count = " + app.InitSignal().GetConnectionCount() );
}
public static Application NewApplication() {
return NewApplication("",Application.WINDOW_MODE.OPAQUE);
}
public static Application NewApplication(string stylesheet) {
return NewApplication(stylesheet, Application.WINDOW_MODE.OPAQUE);
}
public static Application NewApplication(string stylesheet, Application.WINDOW_MODE windowMode) {
Application ret = New(1, stylesheet, windowMode);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
// we've got an application now connect the signals
ret.SetupDelegates();
// set the singleton
return ret;
}
/**
* Outer::outer_method(int)
*/
public static Application New() {
Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_0(), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static Application New(int argc) {
Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_1(argc), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static Application New(int argc, string stylesheet) {
Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_2(argc, stylesheet), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static Application New(int argc, string stylesheet, Application.WINDOW_MODE windowMode) {
Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_3(argc, stylesheet, (int)windowMode), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public Application() : this(NDalicPINVOKE.new_Application__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public Application(Application application) : this(NDalicPINVOKE.new_Application__SWIG_1(Application.getCPtr(application)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public Application Assign(Application application) {
Application ret = new Application(NDalicPINVOKE.Application_Assign(swigCPtr, Application.getCPtr(application)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void MainLoop() {
NDalicPINVOKE.Application_MainLoop__SWIG_0(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public void MainLoop(SWIGTYPE_p_Configuration__ContextLoss configuration) {
NDalicPINVOKE.Application_MainLoop__SWIG_1(swigCPtr, SWIGTYPE_p_Configuration__ContextLoss.getCPtr(configuration));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public void Lower() {
NDalicPINVOKE.Application_Lower(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public void Quit() {
NDalicPINVOKE.Application_Quit(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public bool AddIdle(SWIGTYPE_p_Dali__CallbackBase callback) {
bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, SWIGTYPE_p_Dali__CallbackBase.getCPtr(callback));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public Window GetWindow() {
Window ret = new Window(NDalicPINVOKE.Application_GetWindow(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void ReplaceWindow(RectInteger windowPosition, string name) {
NDalicPINVOKE.Application_ReplaceWindow(swigCPtr, RectInteger.getCPtr(windowPosition), name);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public static string GetResourcePath() {
string ret = NDalicPINVOKE.Application_GetResourcePath();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void SetViewMode(ViewMode viewMode) {
NDalicPINVOKE.Application_SetViewMode(swigCPtr, (int)viewMode);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public ViewMode GetViewMode() {
ViewMode ret = (ViewMode)NDalicPINVOKE.Application_GetViewMode(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void SetStereoBase(float stereoBase) {
NDalicPINVOKE.Application_SetStereoBase(swigCPtr, stereoBase);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public float GetStereoBase() {
float ret = NDalicPINVOKE.Application_GetStereoBase(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal InitSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_InitSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal TerminateSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_TerminateSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal PauseSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_PauseSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal ResumeSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResumeSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal ResetSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResetSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal ResizeSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResizeSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationControlSignal AppControlSignal() {
ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.Application_AppControlSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal LanguageChangedSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_LanguageChangedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal RegionChangedSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_RegionChangedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal BatteryLowSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_BatteryLowSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public ApplicationSignal MemoryLowSignal() {
ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_MemoryLowSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public enum WINDOW_MODE {
OPAQUE = 0,
TRANSPARENT = 1
}
}
}