/** Copyright (c) 2017 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
using System;
using System.Runtime.InteropServices;
using Tizen.Applications;
namespace Tizen.NUI
{
///
/// Widget object should be created by WidgetApplication.
///
public class Widget : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Widget(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.Widget_SWIGUpcast(cPtr), cMemoryOwn)
{
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Widget obj)
{
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
///
/// To make Widget instance be disposed.
///
protected override void Dispose(DisposeTypes type)
{
if(disposed)
{
return;
}
if(type == DisposeTypes.Explicit)
{
//Called by User
//Release your own managed resources here.
//You should release all of your own disposable objects here.
}
//Release your own unmanaged resources here.
//You should not access any managed member here except static instance.
//because the execution order of Finalizes is non-deterministic.
if (swigCPtr.Handle != global::System.IntPtr.Zero)
{
if (swigCMemOwn)
{
swigCMemOwn = false;
NDalicManualPINVOKE.delete_Widget(swigCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
base.Dispose(type);
}
///
/// This is the constructor for Widget.
///
/// for widget instance
public Widget(string id) : this(NDalicManualPINVOKE.Widget_New(id), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal Widget(Widget widget) : this(NDalicManualPINVOKE.new_Widget__SWIG_1(Widget.getCPtr(widget)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal Widget Assign(Widget widget)
{
Widget ret = new Widget(NDalicManualPINVOKE.Widget_Assign(swigCPtr, Widget.getCPtr(widget)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
///
/// Event arguments that passed via KeyEvent signal.
///
public class CreateEventArgs : EventArgs
{
///
/// widget data.
///
public WidgetData WidgetData
{
get;
set;
}
///
/// a bundle.
///
public SWIGTYPE_p_bundle Bundle
{
get;
set;
}
///
/// window size.
///
public Size2D WindowSize
{
get;
set;
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void CreateCallbackType(IntPtr widgetData, IntPtr bundle, IntPtr windowSize);
private CreateCallbackType _createCallback;
private EventHandler _createEventHandler;
///
/// Create event.
///
public event EventHandler Create
{
add
{
if (_createEventHandler == null)
{
_createCallback = OnCreate;
CreateSignal().Connect(_createCallback);
}
_createEventHandler += value;
}
remove
{
_createEventHandler -= value;
if (_createEventHandler == null && CreateSignal().Empty() == false)
{
CreateSignal().Disconnect(_createCallback);
}
}
}
private void OnCreate(IntPtr widgetData, IntPtr bundle, IntPtr windowSize)
{
CreateEventArgs e = new CreateEventArgs();
if (widgetData != null)
{
e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
}
if (bundle != null)
{
e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
}
if (windowSize != null)
{
var val = new Uint16Pair(windowSize, false);
e.WindowSize = val;
val.Dispose();
}
_createEventHandler?.Invoke(this, e);
}
internal WidgetInstanceCreateSignalType CreateSignal()
{
WidgetInstanceCreateSignalType ret = new WidgetInstanceCreateSignalType(NDalicManualPINVOKE.Widget_CreateSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
///
/// Event arguments that passed via terminate event signal.
///
public class TerminateEventArgs : EventArgs
{
///
/// widget data.
///
public WidgetData WidgetData
{
get;
set;
}
///
/// a bundle.
///
public SWIGTYPE_p_bundle Bundle
{
get;
set;
}
///
/// widget terminate type.
///
public WidgetTerminateType WidgetTerminateType
{
get;
set;
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void TerminateCallbackType(IntPtr widgetData, IntPtr bundle, WidgetTerminateType widgetTerminateType);
private TerminateCallbackType _terminateCallback;
private EventHandler _terminateEventHandler;
///
/// Terminate event.
///
public event EventHandler Terminate
{
add
{
if (_terminateEventHandler == null)
{
_terminateCallback = OnTerminate;
TerminateSignal().Connect(_terminateCallback);
}
_terminateEventHandler += value;
}
remove
{
_terminateEventHandler -= value;
if (_terminateEventHandler == null && TerminateSignal().Empty() == false)
{
TerminateSignal().Disconnect(_terminateCallback);
}
}
}
private void OnTerminate(IntPtr widgetData, IntPtr bundle, WidgetTerminateType widgetTerminateType)
{
TerminateEventArgs e = new TerminateEventArgs();
if (widgetData != null)
{
e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
}
if (bundle != null)
{
e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
}
e.WidgetTerminateType = widgetTerminateType;
_terminateEventHandler?.Invoke(this, e);
}
internal WidgetInstanceTerminateSignalType TerminateSignal()
{
WidgetInstanceTerminateSignalType ret = new WidgetInstanceTerminateSignalType(NDalicManualPINVOKE.Widget_TerminateSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
///
/// Event arguments that passed via pause event signal.
///
public class PauseEventArgs : EventArgs
{
///
/// widget data.
///
public WidgetData WidgetData
{
get;
set;
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void PauseCallbackType(IntPtr widgetData);
private PauseCallbackType _pauseCallback;
private EventHandler _pauseEventHandler;
///
/// Pause event.
///
public event EventHandler Pause
{
add
{
if (_pauseEventHandler == null)
{
_pauseCallback = OnPause;
PauseSignal().Connect(_pauseCallback);
}
_pauseEventHandler += value;
}
remove
{
_pauseEventHandler -= value;
if (_pauseEventHandler == null && PauseSignal().Empty() == false)
{
PauseSignal().Disconnect(_pauseCallback);
}
}
}
private void OnPause(IntPtr widgetData)
{
PauseEventArgs e = new PauseEventArgs();
if (widgetData != null)
{
e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
}
_pauseEventHandler?.Invoke(this, e);
}
internal WidgetInstancePauseOrResumeSignalType PauseSignal()
{
WidgetInstancePauseOrResumeSignalType ret = new WidgetInstancePauseOrResumeSignalType(NDalicManualPINVOKE.Widget_PauseSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
///
/// Event arguments that passed via pause event signal.
///
public class ResumeEventArgs : EventArgs
{
///
/// widget data.
///
public WidgetData WidgetData
{
get;
set;
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ResumeCallbackType(IntPtr widgetData);
private ResumeCallbackType _resumeCallback;
private EventHandler _resumeEventHandler;
///
/// Resume event.
///
public event EventHandler Resume
{
add
{
if (_resumeEventHandler == null)
{
_resumeCallback = OnResume;
ResumeSignal().Connect(_resumeCallback);
}
_resumeEventHandler += value;
}
remove
{
_resumeEventHandler -= value;
if (_resumeEventHandler == null && ResumeSignal().Empty() == false)
{
ResumeSignal().Disconnect(_resumeCallback);
}
}
}
private void OnResume(IntPtr widgetData)
{
ResumeEventArgs e = new ResumeEventArgs();
if (widgetData != null)
{
e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
}
_resumeEventHandler?.Invoke(this, e);
}
internal WidgetInstancePauseOrResumeSignalType ResumeSignal()
{
WidgetInstancePauseOrResumeSignalType ret = new WidgetInstancePauseOrResumeSignalType(NDalicManualPINVOKE.Widget_ResumeSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
///
/// Event arguments that passed via resize signal.
///
public class ResizeEventArgs : EventArgs
{
///
/// widget data.
///
public WidgetData WidgetData
{
get;
set;
}
///
/// window size.
///
public Size2D WindowSize
{
get;
set;
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void ResizeCallbackType(IntPtr widgetData, IntPtr windowSize);
private ResizeCallbackType _resizeCallback;
private EventHandler _resizeEventHandler;
///
/// Resize event.
///
public event EventHandler Resize
{
add
{
if (_resizeEventHandler == null)
{
_resizeCallback = OnResize;
ResizeSignal().Connect(_resizeCallback);
}
_resizeEventHandler += value;
}
remove
{
_resizeEventHandler -= value;
if (_resizeEventHandler == null && ResizeSignal().Empty() == false)
{
ResizeSignal().Disconnect(_resizeCallback);
}
}
}
private void OnResize(IntPtr widgetData, IntPtr windowSize)
{
ResizeEventArgs e = new ResizeEventArgs();
if (widgetData != null)
{
e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
}
if (windowSize != null)
{
var val = new Uint16Pair(windowSize, false);
e.WindowSize = val;
val.Dispose();
}
_resizeEventHandler?.Invoke(this, e);
}
internal WidgetInstanceResizeSignalType ResizeSignal()
{
WidgetInstanceResizeSignalType ret = new WidgetInstanceResizeSignalType(NDalicManualPINVOKE.Widget_ResizeSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
///
/// Event arguments that passed via update event signal.
///
public class UpdateEventArgs : EventArgs
{
///
/// widget data.
///
public WidgetData WidgetData
{
get;
set;
}
///
/// A bundle.
///
public SWIGTYPE_p_bundle Bundle
{
get;
set;
}
///
/// It means several steps.
///
///
/// 0 -> no force
/// 1 -> force but do someting
/// 2 -> force
///
public int Force
{
get;
set;
}
}
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void UpdateCallbackType(IntPtr widgetData, IntPtr bundle, int force);
private UpdateCallbackType _updateCallback;
private EventHandler _updateEventHandler;
///
/// Update event.
///
public event EventHandler Update
{
add
{
if (_updateEventHandler == null)
{
_updateCallback = OnUpdate;
UpdateSignal().Connect(_updateCallback);
}
_updateEventHandler += value;
}
remove
{
_updateEventHandler -= value;
if (_updateEventHandler == null && UpdateSignal().Empty() == false)
{
UpdateSignal().Disconnect(_updateCallback);
}
}
}
private void OnUpdate(IntPtr widgetData, IntPtr bundle, int force)
{
UpdateEventArgs e = new UpdateEventArgs();
if (widgetData != null)
{
e.WidgetData = WidgetData.GetWidgetDataFromPtr(widgetData);
}
if (bundle != null)
{
e.Bundle = new SWIGTYPE_p_bundle(bundle, false);
}
e.Force = force;
_updateEventHandler?.Invoke(this, e);
}
internal WidgetInstanceUpdateSignalType UpdateSignal()
{
WidgetInstanceUpdateSignalType ret = new WidgetInstanceUpdateSignalType(NDalicManualPINVOKE.Widget_UpdateSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
///
/// Enumeration for terminate type of widget instance.
///
public enum WidgetTerminateType
{
///
/// User deleted this widget from the viewer
///
Permanent,
///
/// Widget is deleted because of other reasons (e.g. widget process is terminated temporarily by the system)
///
Temporary
}
///
/// Enumeration for lifecycle event type of widget instance.
///
public enum WidgetLifecycleEventType
{
///
/// The widget is dead.
///
AppDead = 0,
///
/// The widget is dead.
///
Create = 1,
///
/// The widget is destroyed.
///
Destroy = 2,
///
/// The widget is paused.
///
Pause = 3,
///
/// The widget is resumed.
///
Resume = 4
}
}
}