Some directives '#pragma warning disable CA2000' are removed too.
if (ret != null)
{
Interop.BaseHandle.DeleteBaseHandle(new global::System.Runtime.InteropServices.HandleRef(this, cPtr));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ return ret;
}
else
{
ret = new TextureSet(cPtr, true);
+ return ret;
}
- NDalicPINVOKE.ThrowExceptionIfExists();
- return ret;
}
/// <summary>
Interop.Watch.DeleteWatchApplication(swigCPtr);
}
- private void DisConnectFromSignals()
- {
- if (timeTickCallback != null)
- {
- this.TimeTickSignal().Disconnect(timeTickCallback);
- }
- if (ambientTickCallback != null)
- {
- this.AmbientTickSignal().Disconnect(ambientTickCallback);
- }
- if (ambientChangedCallback != null)
- {
- this.AmbientChangedSignal().Disconnect(ambientChangedCallback);
- }
- }
-
public static WatchApplication NewWatchApplication()
{
WatchApplication ret = New();
if (timeTickEventHandler == null)
{
timeTickCallback = new TimeTickCallbackType(OnTimeTick);
- TimeTickSignal().Connect(timeTickCallback);
+ using var signal = TimeTickSignal();
+ signal.Connect(timeTickCallback);
}
timeTickEventHandler += value;
if (timeTickEventHandler == null && timeTickCallback != null)
{
- TimeTickSignal().Disconnect(timeTickCallback);
+ using var signal = TimeTickSignal();
+ signal.Disconnect(timeTickCallback);
timeTickCallback = null;
}
}
if (ambientTickEventHandler == null)
{
ambientTickCallback = new AmbientTickCallbackType(OnAmbientTick);
- AmbientTickSignal().Connect(ambientTickCallback);
+ using var signal = AmbientTickSignal();
+ signal.Connect(ambientTickCallback);
}
ambientTickEventHandler += value;
if (ambientTickEventHandler == null && ambientTickCallback != null)
{
- AmbientTickSignal().Disconnect(ambientTickCallback);
+ using var signal = AmbientTickSignal();
+ signal.Disconnect(ambientTickCallback);
ambientTickCallback = null;
}
}
if (ambientChangedEventHandler == null)
{
ambientChangedCallback = new AmbientChangedCallbackType(OnAmbientChanged);
- AmbientChangedSignal().Connect(ambientChangedCallback);
+ using var signal = AmbientChangedSignal();
+ signal.Connect(ambientChangedCallback);
}
ambientChangedEventHandler += value;
if (ambientChangedEventHandler == null && ambientChangedCallback != null)
{
- AmbientChangedSignal().Disconnect(ambientChangedCallback);
+ using var signal = AmbientChangedSignal();
+ signal.Disconnect(ambientChangedCallback);
ambientChangedCallback = null;
}
}
public static ulong Register(string stateName)
{
if (stateName == null)
- throw new ArgumentNullException($"{nameof(stateName)} cannot be null.", nameof(stateName));
+ throw new ArgumentNullException(nameof(stateName), $"{nameof(stateName)} cannot be null.");
if (string.IsNullOrWhiteSpace(stateName))
throw new ArgumentException($"{nameof(stateName)} cannot be whitespace.", nameof(stateName));
if (ret != null)
{
Interop.BaseHandle.DeleteBaseHandle(new global::System.Runtime.InteropServices.HandleRef(this, cPtr));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ return ret;
}
else
{
ret = new Texture(cPtr, true);
+ return ret;
}
- NDalicPINVOKE.ThrowExceptionIfExists();
- return ret;
}
/// <summary>
global::System.Runtime.InteropServices.HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(dummyObect, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new KeyInputFocusManager(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
protected override void Dispose(bool disposing)
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- Tizen.NUI.Object.GetProperty(SwigCPtr, LinearConstrainer.Property.VALUE).Get(temp);
+ using (var prop = Tizen.NUI.Object.GetProperty(SwigCPtr, LinearConstrainer.Property.VALUE))
+ {
+ prop.Get(temp);
+ }
return temp;
}
set
{
- Tizen.NUI.Object.SetProperty(SwigCPtr, LinearConstrainer.Property.VALUE, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ Tizen.NUI.Object.SetProperty(SwigCPtr, LinearConstrainer.Property.VALUE, pv);
}
}
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- Tizen.NUI.Object.GetProperty(SwigCPtr, LinearConstrainer.Property.PROGRESS).Get(temp);
+ using (var prop = Tizen.NUI.Object.GetProperty(SwigCPtr, LinearConstrainer.Property.PROGRESS))
+ {
+ prop.Get(temp);
+ }
return temp;
}
set
{
- Tizen.NUI.Object.SetProperty(SwigCPtr, LinearConstrainer.Property.PROGRESS, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ Tizen.NUI.Object.SetProperty(SwigCPtr, LinearConstrainer.Property.PROGRESS, pv);
}
}
}
public void InitializeWindow(int width, int height)
{
- window.WindowSize = new Size(width, height);
+ using var size = new Size(width, height);
+ window.WindowSize = size;
}
/// <summary>
get
{
Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
- Tizen.NUI.Object.GetProperty(SwigCPtr, PathConstrainer.Property.FORWARD).Get(temp);
+ using (var prop = Tizen.NUI.Object.GetProperty(SwigCPtr, PathConstrainer.Property.FORWARD))
+ {
+ prop.Get(temp);
+ }
return temp;
}
set
{
- Tizen.NUI.Object.SetProperty(SwigCPtr, PathConstrainer.Property.FORWARD, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ Tizen.NUI.Object.SetProperty(SwigCPtr, PathConstrainer.Property.FORWARD, pv);
}
}
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- Tizen.NUI.Object.GetProperty(SwigCPtr, PathConstrainer.Property.POINTS).Get(temp);
+ using (var prop = Tizen.NUI.Object.GetProperty(SwigCPtr, PathConstrainer.Property.POINTS))
+ {
+ prop.Get(temp);
+ }
return temp;
}
set
{
- Tizen.NUI.Object.SetProperty(SwigCPtr, PathConstrainer.Property.POINTS, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ Tizen.NUI.Object.SetProperty(SwigCPtr, PathConstrainer.Property.POINTS, pv);
}
}
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- Tizen.NUI.Object.GetProperty(SwigCPtr, PathConstrainer.Property.ControlPoints).Get(temp);
+ using (var prop = Tizen.NUI.Object.GetProperty(SwigCPtr, PathConstrainer.Property.ControlPoints))
+ {
+ prop.Get(temp);
+ }
return temp;
}
set
{
- Tizen.NUI.Object.SetProperty(SwigCPtr, PathConstrainer.Property.ControlPoints, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ Tizen.NUI.Object.SetProperty(SwigCPtr, PathConstrainer.Property.ControlPoints, pv);
}
}
}
if (ret != null)
{
Interop.BaseHandle.DeleteBaseHandle(new global::System.Runtime.InteropServices.HandleRef(this, cPtr));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new View(cPtr, true);
+ return ret;
}
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
public void SetExclusive(bool exclusive)
[EditorBrowsable(EditorBrowsableState.Never)]
public static RenderTaskList DownCast(BaseHandle handle)
{
+ _ = handle ?? throw new System.ArgumentNullException(nameof(handle));
RenderTaskList ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as RenderTaskList;
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
HandleRef CPtr = new HandleRef(this, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new RenderTask(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
}
}
if (ret != null)
{
Interop.BaseHandle.DeleteBaseHandle(new HandleRef(this, cPtr));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ return ret;
}
else
{
ret = new TransitionItemBase(cPtr, true);
+ return ret;
}
- NDalicPINVOKE.ThrowExceptionIfExists();
- return ret;
}
public uint GetTransitionCount()
global::System.Runtime.InteropServices.HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new PathConstrainer(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
internal LinearConstrainer GetLinearConstrainer(string linearConstrainerName)
global::System.Runtime.InteropServices.HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new LinearConstrainer(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
public enum UIFormat
//because the execution order of Finalizes is non-deterministic.
if (finishedCallback != null)
{
- FinishedSignal().Disconnect(finishedCallback);
+ using var signal = FinishedSignal();
+ signal.Disconnect(finishedCallback);
}
base.Dispose(type);
if (finishedEventHandler == null)
{
finishedCallback = new FinishedCallbackType(OnFinished);
- FinishedSignal().Connect(finishedCallback);
+ using var signal = FinishedSignal();
+ signal.Connect(finishedCallback);
}
finishedEventHandler += value;
if (finishedEventHandler == null && finishedCallback != null)
{
- FinishedSignal().Disconnect(finishedCallback);
+ using var signal = FinishedSignal();
+ signal.Disconnect(finishedCallback);
finishedCallback = null;
}
}
{
internal class PageTurnView : View
{
-
internal PageTurnView(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
{
}
pageTurnViewPagePanStartedEventHandler += value;
pageTurnViewPagePanStartedCallbackDelegate = new PagePanStartedCallbackDelegate(OnPagePanStarted);
- this.PagePanStartedSignal().Connect(pageTurnViewPagePanStartedCallbackDelegate);
+ using var signal = PagePanStartedSignal();
+ signal.Connect(pageTurnViewPagePanStartedCallbackDelegate);
}
}
{
if (pageTurnViewPagePanStartedEventHandler != null)
{
- this.PagePanStartedSignal().Disconnect(pageTurnViewPagePanStartedCallbackDelegate);
+ using var signal = PagePanStartedSignal();
+ signal.Disconnect(pageTurnViewPagePanStartedCallbackDelegate);
}
pageTurnViewPagePanStartedEventHandler -= value;
pageTurnViewPagePanFinishedEventHandler += value;
pageTurnViewPagePanFinishedCallbackDelegate = new PagePanFinishedCallbackDelegate(OnPagePanFinished);
- this.PagePanFinishedSignal().Connect(pageTurnViewPagePanFinishedCallbackDelegate);
+ using var signal = PagePanFinishedSignal();
+ signal.Connect(pageTurnViewPagePanFinishedCallbackDelegate);
}
}
{
if (pageTurnViewPagePanFinishedEventHandler != null)
{
- this.PagePanFinishedSignal().Disconnect(pageTurnViewPagePanFinishedCallbackDelegate);
+ using var signal = PagePanFinishedSignal();
+ signal.Disconnect(pageTurnViewPagePanFinishedCallbackDelegate);
}
pageTurnViewPagePanFinishedEventHandler -= value;
pageTurnViewPageTurnStartedEventHandler += value;
pageTurnViewPageTurnStartedCallbackDelegate = new PageTurnStartedCallbackDelegate(OnPageTurnStarted);
- this.PageTurnStartedSignal().Connect(pageTurnViewPageTurnStartedCallbackDelegate);
+ using var signal = PageTurnStartedSignal();
+ signal.Connect(pageTurnViewPageTurnStartedCallbackDelegate);
}
}
{
if (pageTurnViewPageTurnStartedEventHandler != null)
{
- this.PageTurnStartedSignal().Disconnect(pageTurnViewPageTurnStartedCallbackDelegate);
+ using var signal = PageTurnStartedSignal();
+ signal.Disconnect(pageTurnViewPageTurnStartedCallbackDelegate);
}
pageTurnViewPageTurnStartedEventHandler -= value;
pageTurnViewPageTurnFinishedEventHandler += value;
pageTurnViewPageTurnFinishedCallbackDelegate = new PageTurnFinishedCallbackDelegate(OnPageTurnFinished);
- this.PageTurnFinishedSignal().Connect(pageTurnViewPageTurnFinishedCallbackDelegate);
+ using var signal = PageTurnFinishedSignal();
+ signal.Connect(pageTurnViewPageTurnFinishedCallbackDelegate);
}
}
{
if (pageTurnViewPageTurnFinishedEventHandler != null)
{
- this.PageTurnFinishedSignal().Disconnect(pageTurnViewPageTurnFinishedCallbackDelegate);
+ using var signal = PageTurnFinishedSignal();
+ signal.Disconnect(pageTurnViewPageTurnFinishedCallbackDelegate);
}
pageTurnViewPageTurnFinishedEventHandler -= value;
get
{
Vector2 temp = new Vector2(0.0f, 0.0f);
- GetProperty(PageTurnView.Property.ViewPageSize).Get(temp);
+ using (var prop = GetProperty(PageTurnView.Property.ViewPageSize))
+ {
+ prop.Get(temp);
+ }
return temp;
}
set
{
- SetProperty(PageTurnView.Property.ViewPageSize, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ SetProperty(PageTurnView.Property.ViewPageSize, pv);
}
}
public int CurrentPageId
get
{
int temp = 0;
- GetProperty(PageTurnView.Property.CurrentPageId).Get(out temp);
+ using var prop = GetProperty(PageTurnView.Property.CurrentPageId);
+ prop.Get(out temp);
return temp;
}
set
{
- SetProperty(PageTurnView.Property.CurrentPageId, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ SetProperty(PageTurnView.Property.CurrentPageId, pv);
}
}
public Vector2 SpineShadow
get
{
Vector2 temp = new Vector2(0.0f, 0.0f);
- GetProperty(PageTurnView.Property.SpineShadow).Get(temp);
+ using (var prop = GetProperty(PageTurnView.Property.SpineShadow))
+ {
+ prop.Get(temp);
+ }
return temp;
}
set
{
- SetProperty(PageTurnView.Property.SpineShadow, new Tizen.NUI.PropertyValue(value));
+ using var pv = new Tizen.NUI.PropertyValue(value);
+ SetProperty(PageTurnView.Property.SpineShadow, pv);
}
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public static Size2D GetOriginalImageSize(string filename, bool orientationCorrection)
{
- var val = new Uint16Pair(Interop.ImageLoading.GetOriginalImageSize(filename, orientationCorrection), true);
- Size2D ret = new Size2D(val.GetWidth(), val.GetHeight());
+ using var val = new Uint16Pair(Interop.ImageLoading.GetOriginalImageSize(filename, orientationCorrection), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ Size2D ret = new Size2D(val.GetWidth(), val.GetHeight());
return ret;
}
/// <since_tizen> 3 </since_tizen>
public void GetBezierControlPoints(out Vector2 controlPoint0, out Vector2 controlPoint1)
{
- Vector4 ret = new Vector4(Interop.AlphaFunction.GetBezierControlPoints(SwigCPtr), true);
+ using Vector4 ret = new Vector4(Interop.AlphaFunction.GetBezierControlPoints(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
controlPoint0 = new Vector2(ret.X, ret.Y);
// Sync as current properties
UpdateImage();
- DoAction(Property.IMAGE, ActionJumpTo, new PropertyValue(value));
+ using var pv = new PropertyValue(value);
+ DoAction(Property.IMAGE, ActionJumpTo, pv);
}
get
{
UpdateImage();
// Get current properties force.
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap returnValue = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.IMAGE);
- prop.Get(returnValue);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.IMAGE))
+ {
+ prop.Get(returnValue);
+ }
// Update cached property map
if (returnValue != null)
transition.Add("initialValue", initValue);
transition.Add("targetValue", destValue);
- SetProperty(ImageView.Property.TransitionEffectOption, new Tizen.NUI.PropertyValue(transition));
+ using var pv = new Tizen.NUI.PropertyValue(transition);
+ SetProperty(ImageView.Property.TransitionEffectOption, pv);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
// Unregist and detach process only if previous resourceUrl was not empty
if (!string.IsNullOrEmpty(_resourceUrl))
{
- PropertyValue emptyValue = new PropertyValue();
+ using PropertyValue emptyValue = new PropertyValue();
// Remove current registed Image.
SetProperty(ImageView.Property.IMAGE, emptyValue);
}
}
- SetProperty(ImageView.Property.IMAGE, new Tizen.NUI.PropertyValue(map));
+ using var pv = new Tizen.NUI.PropertyValue(map);
+ SetProperty(ImageView.Property.IMAGE, pv);
}
else
{
scrollableStartedEventHandler += value;
scrollableStartedCallbackDelegate = new StartedCallbackDelegate(OnStarted);
- this.ScrollStartedSignal().Connect(scrollableStartedCallbackDelegate);
+ using var signal = ScrollStartedSignal();
+ signal.Connect(scrollableStartedCallbackDelegate);
}
}
{
if (scrollableStartedEventHandler != null)
{
- this.ScrollStartedSignal().Disconnect(scrollableStartedCallbackDelegate);
+ using var signal = ScrollStartedSignal();
+ signal.Disconnect(scrollableStartedCallbackDelegate);
}
scrollableStartedEventHandler -= value;
scrollableUpdatedEventHandler += value;
scrollableUpdatedCallbackDelegate = new UpdatedCallbackDelegate(OnUpdated);
- this.ScrollUpdatedSignal().Connect(scrollableUpdatedCallbackDelegate);
+ using var signal = ScrollUpdatedSignal();
+ signal.Connect(scrollableUpdatedCallbackDelegate);
}
}
{
if (scrollableUpdatedEventHandler != null)
{
- this.ScrollUpdatedSignal().Disconnect(scrollableUpdatedCallbackDelegate);
+ using var signal = ScrollUpdatedSignal();
+ signal.Disconnect(scrollableUpdatedCallbackDelegate);
}
scrollableUpdatedEventHandler -= value;
scrollableCompletedEventHandler += value;
scrollableCompletedCallbackDelegate = new CompletedCallbackDelegate(OnCompleted);
- this.ScrollCompletedSignal().Connect(scrollableCompletedCallbackDelegate);
+ using var signal = ScrollCompletedSignal();
+ signal.Connect(scrollableCompletedCallbackDelegate);
}
}
{
if (scrollableCompletedEventHandler != null)
{
- this.ScrollCompletedSignal().Disconnect(scrollableCompletedCallbackDelegate);
+ using var signal = ScrollCompletedSignal();
+ signal.Disconnect(scrollableCompletedCallbackDelegate);
}
scrollableCompletedEventHandler -= value;
private Vector4 GetInternalOvershootEffectColor()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.OvershootEffectColor);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.OvershootEffectColor))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private Vector2 GetInternalOvershootSize()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector2 temp = new Vector2(0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.OvershootSize);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.OvershootSize))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private Vector2 GetInternalScrollRelativePosition()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector2 temp = new Vector2(0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.ScrollRelativePosition);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.ScrollRelativePosition))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private Vector2 GetInternalScrollPositionMin()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector2 temp = new Vector2(0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.ScrollPositionMin);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.ScrollPositionMin))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private Vector2 GetInternalScrollPositionMax()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector2 temp = new Vector2(0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.ScrollPositionMax);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.ScrollPositionMax))
+ {
+ prop?.Get(temp);
+ }
return temp;
}
[EditorBrowsable(EditorBrowsableState.Never)]
public static TOut Merge<TOut>(this TOut value, TOut other) where TOut : Tizen.NUI.BaseComponents.ViewStyle
{
+ _ = value ?? throw new ArgumentNullException(nameof(value));
var newStyle = value.Clone() as TOut;
- newStyle?.CopyFrom(other);
+ newStyle.CopyFrom(other);
return newStyle;
}
private Vector2 GetInternalCellPadding()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector2 temp = new Vector2(0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.CellPadding);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.CellPadding))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalLayoutRows()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.LayoutRows);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.LayoutRows))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalLayoutColumns()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.LayoutColumns);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.LayoutColumns))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalFontStyle()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.FontStyle);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.FontStyle))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionPopupStyle()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionPopupStyle);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionPopupStyle))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleImageLeft()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageLeft);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageLeft))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleImageRight()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageRight);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageRight))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandlePressedImageLeft()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageLeft);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageLeft))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandlePressedImageRight()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageRight);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageRight))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleMarkerImageLeft()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageLeft);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageLeft))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleMarkerImageRight()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageRight);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageRight))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private Rectangle GetInternalDecorationBoundingBox()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Rectangle temp = new Rectangle(0, 0, 0, 0);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.DecorationBoundingBox);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.DecorationBoundingBox))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalInputFontStyle()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.InputFontStyle);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.InputFontStyle))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalUnderline()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.UNDERLINE);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.UNDERLINE))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalShadow()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SHADOW);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SHADOW))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalOutline()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.OUTLINE);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.OUTLINE))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalPlaceholder()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap map = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.PLACEHOLDER);
- prop.Get(map);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.PLACEHOLDER))
+ {
+ prop.Get(map);
+ }
string defalutText = "";
private PropertyMap GetInternalInputMethodSettings()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.InputMethodSettings);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.InputMethodSettings))
+ {
+ prop.Get(temp);
+ }
return temp;
}
{
if (textEditorTextChangedCallbackDelegate != null)
{
- TextChangedSignal().Disconnect(textEditorTextChangedCallbackDelegate);
+ using var signal = TextChangedSignal();
+ signal.Disconnect(textEditorTextChangedCallbackDelegate);
}
if (textEditorMaxLengthReachedCallbackDelegate != null)
{
- this.MaxLengthReachedSignal().Disconnect(textEditorMaxLengthReachedCallbackDelegate);
+ using var signal = MaxLengthReachedSignal();
+ signal.Disconnect(textEditorMaxLengthReachedCallbackDelegate);
}
if (textEditorSelectionStartedCallbackDelegate != null)
{
- this.SelectionStartedSignal().Disconnect(textEditorSelectionStartedCallbackDelegate);
+ using var signal = SelectionStartedSignal();
+ signal.Disconnect(textEditorSelectionStartedCallbackDelegate);
}
if (textEditorSelectionClearedCallbackDelegate != null)
{
- this.SelectionClearedSignal().Disconnect(textEditorSelectionClearedCallbackDelegate);
+ using var signal = SelectionClearedSignal();
+ signal.Disconnect(textEditorSelectionClearedCallbackDelegate);
}
if (textEditorCursorPositionChangedCallbackDelegate != null)
{
- this.CursorPositionChangedSignal().Disconnect(textEditorCursorPositionChangedCallbackDelegate);
+ using var signal = CursorPositionChangedSignal();
+ signal.Disconnect(textEditorCursorPositionChangedCallbackDelegate);
}
if (textEditorSelectionChangedCallbackDelegate != null)
{
- this.SelectionChangedSignal().Disconnect(textEditorSelectionChangedCallbackDelegate);
+ using var signal = SelectionChangedSignal();
+ signal.Disconnect(textEditorSelectionChangedCallbackDelegate);
}
}
internal void SetTextWithoutTextChanged(string text)
{
invokeTextChanged = false;
- Tizen.NUI.Object.SetProperty((System.Runtime.InteropServices.HandleRef)SwigCPtr, TextEditor.Property.TEXT, new Tizen.NUI.PropertyValue(text));
+ using var pv = new Tizen.NUI.PropertyValue(text);
+ Tizen.NUI.Object.SetProperty((System.Runtime.InteropServices.HandleRef)SwigCPtr, TextEditor.Property.TEXT, pv);
invokeTextChanged = true;
}
if (textEditorTextChangedEventHandler == null)
{
textEditorTextChangedCallbackDelegate = (OnTextChanged);
- TextChangedSignal().Connect(textEditorTextChangedCallbackDelegate);
+ using var signal = TextChangedSignal();
+ signal.Connect(textEditorTextChangedCallbackDelegate);
}
textEditorTextChangedEventHandler += value;
}
remove
{
textEditorTextChangedEventHandler -= value;
- if (textEditorTextChangedEventHandler == null && TextChangedSignal().Empty() == false)
+ using var signal = TextChangedSignal();
+ if (textEditorTextChangedEventHandler == null && signal.Empty() == false)
{
- TextChangedSignal().Disconnect(textEditorTextChangedCallbackDelegate);
+ signal.Disconnect(textEditorTextChangedCallbackDelegate);
}
}
}
if (textEditorScrollStateChangedEventHandler == null)
{
textEditorScrollStateChangedCallbackDelegate = OnScrollStateChanged;
- ScrollStateChangedSignal(this).Connect(textEditorScrollStateChangedCallbackDelegate);
+ using var signal = ScrollStateChangedSignal(this);
+ signal.Connect(textEditorScrollStateChangedCallbackDelegate);
}
textEditorScrollStateChangedEventHandler += value;
}
remove
{
textEditorScrollStateChangedEventHandler -= value;
- if (textEditorScrollStateChangedEventHandler == null && ScrollStateChangedSignal(this).Empty() == false)
+ using var signal = ScrollStateChangedSignal(this);
+ if (textEditorScrollStateChangedEventHandler == null && signal.Empty() == false)
{
- ScrollStateChangedSignal(this).Disconnect(textEditorScrollStateChangedCallbackDelegate);
+ signal.Disconnect(textEditorScrollStateChangedCallbackDelegate);
}
}
}
if (textEditorCursorPositionChangedEventHandler == null)
{
textEditorCursorPositionChangedCallbackDelegate = (OnCursorPositionChanged);
- CursorPositionChangedSignal().Connect(textEditorCursorPositionChangedCallbackDelegate);
+ using var signal = CursorPositionChangedSignal();
+ signal.Connect(textEditorCursorPositionChangedCallbackDelegate);
}
textEditorCursorPositionChangedEventHandler += value;
}
remove
{
- if (textEditorCursorPositionChangedEventHandler == null && CursorPositionChangedSignal().Empty() == false)
+ using var signal = CursorPositionChangedSignal();
+ if (textEditorCursorPositionChangedEventHandler == null && signal.Empty() == false)
{
- this.CursorPositionChangedSignal().Disconnect(textEditorCursorPositionChangedCallbackDelegate);
+ signal.Disconnect(textEditorCursorPositionChangedCallbackDelegate);
}
textEditorCursorPositionChangedEventHandler -= value;
}
if (textEditorMaxLengthReachedEventHandler == null)
{
textEditorMaxLengthReachedCallbackDelegate = (OnMaxLengthReached);
- MaxLengthReachedSignal().Connect(textEditorMaxLengthReachedCallbackDelegate);
+ using var signal = MaxLengthReachedSignal();
+ signal.Connect(textEditorMaxLengthReachedCallbackDelegate);
}
textEditorMaxLengthReachedEventHandler += value;
}
remove
{
- if (textEditorMaxLengthReachedEventHandler == null && MaxLengthReachedSignal().Empty() == false)
+ using var signal = MaxLengthReachedSignal();
+ if (textEditorMaxLengthReachedEventHandler == null && signal.Empty() == false)
{
- this.MaxLengthReachedSignal().Disconnect(textEditorMaxLengthReachedCallbackDelegate);
+ signal.Disconnect(textEditorMaxLengthReachedCallbackDelegate);
}
textEditorMaxLengthReachedEventHandler -= value;
}
if (textEditorAnchorClickedEventHandler == null)
{
textEditorAnchorClickedCallbackDelegate = (OnAnchorClicked);
- AnchorClickedSignal().Connect(textEditorAnchorClickedCallbackDelegate);
+ using var signal = AnchorClickedSignal();
+ signal.Connect(textEditorAnchorClickedCallbackDelegate);
}
textEditorAnchorClickedEventHandler += value;
}
remove
{
textEditorAnchorClickedEventHandler -= value;
- if (textEditorAnchorClickedEventHandler == null && AnchorClickedSignal().Empty() == false)
+ using var signal = AnchorClickedSignal();
+ if (textEditorAnchorClickedEventHandler == null && signal.Empty() == false)
{
- AnchorClickedSignal().Disconnect(textEditorAnchorClickedCallbackDelegate);
+ signal.Disconnect(textEditorAnchorClickedCallbackDelegate);
}
}
}
if (textEditorSelectionStartedEventHandler == null)
{
textEditorSelectionStartedCallbackDelegate = (OnSelectionStarted);
- SelectionStartedSignal().Connect(textEditorSelectionStartedCallbackDelegate);
+ using var signal = SelectionStartedSignal();
+ signal.Connect(textEditorSelectionStartedCallbackDelegate);
}
textEditorSelectionStartedEventHandler += value;
}
remove
{
- if (textEditorSelectionStartedEventHandler == null && SelectionStartedSignal().Empty() == false)
+ using var signal = SelectionStartedSignal();
+ if (textEditorSelectionStartedEventHandler == null && signal.Empty() == false)
{
- this.SelectionStartedSignal().Disconnect(textEditorSelectionStartedCallbackDelegate);
+ signal.Disconnect(textEditorSelectionStartedCallbackDelegate);
}
textEditorSelectionStartedEventHandler -= value;
}
if (textEditorSelectionClearedEventHandler == null)
{
textEditorSelectionClearedCallbackDelegate = (OnSelectionCleared);
- SelectionClearedSignal().Connect(textEditorSelectionClearedCallbackDelegate);
+ using var signal = SelectionClearedSignal();
+ signal.Connect(textEditorSelectionClearedCallbackDelegate);
}
textEditorSelectionClearedEventHandler += value;
}
remove
{
- if (textEditorSelectionClearedEventHandler == null && SelectionClearedSignal().Empty() == false)
+ using var signal = SelectionClearedSignal();
+ if (textEditorSelectionClearedEventHandler == null && signal.Empty() == false)
{
- this.SelectionClearedSignal().Disconnect(textEditorSelectionClearedCallbackDelegate);
+ signal.Disconnect(textEditorSelectionClearedCallbackDelegate);
}
textEditorSelectionClearedEventHandler -= value;
}
if (textEditorSelectionChangedEventHandler == null)
{
textEditorSelectionChangedCallbackDelegate = (OnSelectionChanged);
- SelectionChangedSignal().Connect(textEditorSelectionChangedCallbackDelegate);
+ using var signal = SelectionChangedSignal();
+ signal.Connect(textEditorSelectionChangedCallbackDelegate);
}
textEditorSelectionChangedEventHandler += value;
}
remove
{
- if (textEditorSelectionChangedEventHandler == null && SelectionChangedSignal().Empty() == false)
+ using var signal = SelectionChangedSignal();
+ if (textEditorSelectionChangedEventHandler == null && signal.Empty() == false)
{
- this.SelectionChangedSignal().Disconnect(textEditorSelectionChangedCallbackDelegate);
+ signal.Disconnect(textEditorSelectionChangedCallbackDelegate);
}
textEditorSelectionChangedEventHandler -= value;
}
if (textEditorInputFilteredEventHandler == null)
{
textEditorInputFilteredCallbackDelegate = (OnInputFiltered);
- InputFilteredSignal().Connect(textEditorInputFilteredCallbackDelegate);
+ using var signal = InputFilteredSignal();
+ signal.Connect(textEditorInputFilteredCallbackDelegate);
}
textEditorInputFilteredEventHandler += value;
}
remove
{
textEditorInputFilteredEventHandler -= value;
- if (textEditorInputFilteredEventHandler == null && InputFilteredSignal().Empty() == false)
+ using var signal = InputFilteredSignal();
+ if (textEditorInputFilteredEventHandler == null && signal.Empty() == false)
{
- InputFilteredSignal().Disconnect(textEditorInputFilteredCallbackDelegate);
+ signal.Disconnect(textEditorInputFilteredCallbackDelegate);
}
}
}
private PropertyMap GetInternalFontStyle()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.FontStyle);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.FontStyle))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionPopupStyle()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionPopupStyle);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionPopupStyle))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleImageLeft()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageLeft);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageLeft))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleImageRight()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageRight);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleImageRight))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandlePressedImageLeft()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageLeft);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageLeft))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandlePressedImageRight()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageRight);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandlePressedImageRight))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleMarkerImageLeft()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageLeft);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageLeft))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalSelectionHandleMarkerImageRight()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageRight);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SelectionHandleMarkerImageRight))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private Rectangle GetInternalDecorationBoundingBox()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Rectangle temp = new Rectangle(0, 0, 0, 0);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.DecorationBoundingBox);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.DecorationBoundingBox))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalInputMethodSettings()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.InputMethodSettings);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.InputMethodSettings))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalInputFontStyle()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.InputFontStyle);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.InputFontStyle))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalUnderline()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.UNDERLINE);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.UNDERLINE))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalShadow()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SHADOW);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SHADOW))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalOutline()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.OUTLINE);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.OUTLINE))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalHiddenInputSettings()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.HiddenInputSettings);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.HiddenInputSettings))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalPlaceholder()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap map = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.PLACEHOLDER);
- prop.Get(map);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.PLACEHOLDER))
+ {
+ prop.Get(map);
+ }
string defalutText = "";
{
if (textFieldCursorPositionChangedCallbackDelegate != null)
{
- this.CursorPositionChangedSignal().Disconnect(textFieldCursorPositionChangedCallbackDelegate);
+ using var signal = CursorPositionChangedSignal();
+ signal.Disconnect(textFieldCursorPositionChangedCallbackDelegate);
}
if (textFieldMaxLengthReachedCallbackDelegate != null)
{
- this.MaxLengthReachedSignal().Disconnect(textFieldMaxLengthReachedCallbackDelegate);
+ using var signal = MaxLengthReachedSignal();
+ signal.Disconnect(textFieldMaxLengthReachedCallbackDelegate);
}
if (textFieldSelectionStartedCallbackDelegate != null)
{
- this.SelectionStartedSignal().Disconnect(textFieldSelectionStartedCallbackDelegate);
+ using var signal = SelectionStartedSignal();
+ signal.Disconnect(textFieldSelectionStartedCallbackDelegate);
}
if (textFieldSelectionClearedCallbackDelegate != null)
{
- this.SelectionClearedSignal().Disconnect(textFieldSelectionClearedCallbackDelegate);
+ using var signal = SelectionClearedSignal();
+ signal.Disconnect(textFieldSelectionClearedCallbackDelegate);
}
if (textFieldSelectionChangedCallbackDelegate != null)
{
- this.SelectionChangedSignal().Disconnect(textFieldSelectionChangedCallbackDelegate);
+ using var signal = SelectionChangedSignal();
+ signal.Disconnect(textFieldSelectionChangedCallbackDelegate);
}
if (textFieldTextChangedCallbackDelegate != null)
{
- TextChangedSignal().Disconnect(textFieldTextChangedCallbackDelegate);
+ using var signal = TextChangedSignal();
+ signal.Disconnect(textFieldTextChangedCallbackDelegate);
}
}
internal void SetTextWithoutTextChanged(string text)
{
invokeTextChanged = false;
- Tizen.NUI.Object.SetProperty((System.Runtime.InteropServices.HandleRef)SwigCPtr, TextField.Property.TEXT, new Tizen.NUI.PropertyValue(text));
+ using var pv = new Tizen.NUI.PropertyValue(text);
+ Tizen.NUI.Object.SetProperty((System.Runtime.InteropServices.HandleRef)SwigCPtr, TextField.Property.TEXT, pv);
invokeTextChanged = true;
}
if (textFieldTextChangedEventHandler == null)
{
textFieldTextChangedCallbackDelegate = (OnTextChanged);
- TextChangedSignal().Connect(textFieldTextChangedCallbackDelegate);
+ using var signal = TextChangedSignal();
+ signal.Connect(textFieldTextChangedCallbackDelegate);
}
textFieldTextChangedEventHandler += value;
}
remove
{
textFieldTextChangedEventHandler -= value;
- if (textFieldTextChangedEventHandler == null && TextChangedSignal().Empty() == false)
+ using var signal = TextChangedSignal();
+ if (textFieldTextChangedEventHandler == null && signal.Empty() == false)
{
- TextChangedSignal().Disconnect(textFieldTextChangedCallbackDelegate);
+ signal.Disconnect(textFieldTextChangedCallbackDelegate);
}
}
}
if (textFieldCursorPositionChangedEventHandler == null)
{
textFieldCursorPositionChangedCallbackDelegate = (OnCursorPositionChanged);
- CursorPositionChangedSignal().Connect(textFieldCursorPositionChangedCallbackDelegate);
+ using var signal = CursorPositionChangedSignal();
+ signal.Connect(textFieldCursorPositionChangedCallbackDelegate);
}
textFieldCursorPositionChangedEventHandler += value;
}
remove
{
- if (textFieldCursorPositionChangedEventHandler == null && CursorPositionChangedSignal().Empty() == false)
+ using var signal = CursorPositionChangedSignal();
+ if (textFieldCursorPositionChangedEventHandler == null && signal.Empty() == false)
{
- this.CursorPositionChangedSignal().Disconnect(textFieldCursorPositionChangedCallbackDelegate);
+ signal.Disconnect(textFieldCursorPositionChangedCallbackDelegate);
}
textFieldCursorPositionChangedEventHandler -= value;
}
if (textFieldMaxLengthReachedEventHandler == null)
{
textFieldMaxLengthReachedCallbackDelegate = (OnMaxLengthReached);
- MaxLengthReachedSignal().Connect(textFieldMaxLengthReachedCallbackDelegate);
+ using var signal = MaxLengthReachedSignal();
+ signal.Connect(textFieldMaxLengthReachedCallbackDelegate);
}
textFieldMaxLengthReachedEventHandler += value;
}
remove
{
- if (textFieldMaxLengthReachedEventHandler == null && MaxLengthReachedSignal().Empty() == false)
+ using var signal = MaxLengthReachedSignal();
+ if (textFieldMaxLengthReachedEventHandler == null && signal.Empty() == false)
{
- this.MaxLengthReachedSignal().Disconnect(textFieldMaxLengthReachedCallbackDelegate);
+ signal.Disconnect(textFieldMaxLengthReachedCallbackDelegate);
}
textFieldMaxLengthReachedEventHandler -= value;
}
if (textFieldSelectionStartedEventHandler == null)
{
textFieldSelectionStartedCallbackDelegate = (OnSelectionStarted);
- SelectionStartedSignal().Connect(textFieldSelectionStartedCallbackDelegate);
+ using var signal = SelectionStartedSignal();
+ signal.Connect(textFieldSelectionStartedCallbackDelegate);
}
textFieldSelectionStartedEventHandler += value;
}
remove
{
- if (textFieldSelectionStartedEventHandler == null && SelectionStartedSignal().Empty() == false)
+ using var signal = SelectionStartedSignal();
+ if (textFieldSelectionStartedEventHandler == null && signal.Empty() == false)
{
- this.SelectionStartedSignal().Disconnect(textFieldSelectionStartedCallbackDelegate);
+ signal.Disconnect(textFieldSelectionStartedCallbackDelegate);
}
textFieldSelectionStartedEventHandler -= value;
}
if (textFieldSelectionClearedEventHandler == null)
{
textFieldSelectionClearedCallbackDelegate = (OnSelectionCleared);
- SelectionClearedSignal().Connect(textFieldSelectionClearedCallbackDelegate);
+ using var signal = SelectionClearedSignal();
+ signal.Connect(textFieldSelectionClearedCallbackDelegate);
}
textFieldSelectionClearedEventHandler += value;
}
remove
{
- if (textFieldSelectionClearedEventHandler == null && SelectionClearedSignal().Empty() == false)
+ using var signal = SelectionClearedSignal();
+ if (textFieldSelectionClearedEventHandler == null && signal.Empty() == false)
{
- this.SelectionClearedSignal().Disconnect(textFieldSelectionClearedCallbackDelegate);
+ signal.Disconnect(textFieldSelectionClearedCallbackDelegate);
}
textFieldSelectionClearedEventHandler -= value;
}
if (textFieldAnchorClickedEventHandler == null)
{
textFieldAnchorClickedCallbackDelegate = (OnAnchorClicked);
- AnchorClickedSignal().Connect(textFieldAnchorClickedCallbackDelegate);
+ using var signal = AnchorClickedSignal();
+ signal.Connect(textFieldAnchorClickedCallbackDelegate);
}
textFieldAnchorClickedEventHandler += value;
}
remove
{
textFieldAnchorClickedEventHandler -= value;
- if (textFieldAnchorClickedEventHandler == null && AnchorClickedSignal().Empty() == false)
+ using var signal = AnchorClickedSignal();
+ if (textFieldAnchorClickedEventHandler == null && signal.Empty() == false)
{
- AnchorClickedSignal().Disconnect(textFieldAnchorClickedCallbackDelegate);
+ signal.Disconnect(textFieldAnchorClickedCallbackDelegate);
}
}
}
if (textFieldSelectionChangedEventHandler == null)
{
textFieldSelectionChangedCallbackDelegate = (OnSelectionChanged);
- SelectionChangedSignal().Connect(textFieldSelectionChangedCallbackDelegate);
+ using var signal = SelectionChangedSignal();
+ signal.Connect(textFieldSelectionChangedCallbackDelegate);
}
textFieldSelectionChangedEventHandler += value;
}
remove
{
- if (textFieldSelectionChangedEventHandler == null && SelectionChangedSignal().Empty() == false)
+ using var signal = SelectionChangedSignal();
+ if (textFieldSelectionChangedEventHandler == null && signal.Empty() == false)
{
- this.SelectionChangedSignal().Disconnect(textFieldSelectionChangedCallbackDelegate);
+ signal.Disconnect(textFieldSelectionChangedCallbackDelegate);
}
textFieldSelectionChangedEventHandler -= value;
}
if (textFieldInputFilteredEventHandler == null)
{
textFieldInputFilteredCallbackDelegate = (OnInputFiltered);
- InputFilteredSignal().Connect(textFieldInputFilteredCallbackDelegate);
+ using var signal = InputFilteredSignal();
+ signal.Connect(textFieldInputFilteredCallbackDelegate);
}
textFieldInputFilteredEventHandler += value;
}
remove
{
textFieldInputFilteredEventHandler -= value;
- if (textFieldInputFilteredEventHandler == null && InputFilteredSignal().Empty() == false)
+ using var signal = InputFilteredSignal();
+ if (textFieldInputFilteredEventHandler == null && signal.Empty() == false)
{
- InputFilteredSignal().Disconnect(textFieldInputFilteredCallbackDelegate);
+ signal.Disconnect(textFieldInputFilteredCallbackDelegate);
}
}
}
private PropertyMap GetInternalFontStyle()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.FontStyle);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.FontStyle))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalUnderline()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.UNDERLINE);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.UNDERLINE))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalShadow()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.SHADOW);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.SHADOW))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private TextShadow GetInternalTextShadow()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
- PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
+ using PropertyMap temp = new PropertyMap();
using var prop = Object.GetProperty(SwigCPtr, Property.SHADOW);
prop.Get(temp);
return temp.Empty() ? null : new TextShadow(temp);
private PropertyMap GetInternalOutline()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.OUTLINE);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.OUTLINE))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalTextFit()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.TextFit);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.TextFit))
+ {
+ prop.Get(temp);
+ }
return temp;
}
{
if (textLabelAnchorClickedCallbackDelegate != null)
{
- AnchorClickedSignal().Disconnect(textLabelAnchorClickedCallbackDelegate);
+ using var signal = AnchorClickedSignal();
+ signal.Disconnect(textLabelAnchorClickedCallbackDelegate);
}
if (textLabelTextFitChangedCallbackDelegate != null)
{
- TextFitChangedSignal().Disconnect(textLabelTextFitChangedCallbackDelegate);
+ using var signal = TextFitChangedSignal();
+ signal.Disconnect(textLabelTextFitChangedCallbackDelegate);
}
if (textLabelAsyncTextRenderedCallbackDelegate != null)
}
Color color = new Color();
- if (!GetProperty(TextLabel.Property.TextColor).Get(color))
+ using var prop = GetProperty(TextLabel.Property.TextColor);
+ if (!prop.Get(color))
{
return null;
}
{
if (value != null)
{
- Object.SetProperty((System.Runtime.InteropServices.HandleRef)SwigCPtr, Property.SHADOW, TextShadow.ToPropertyValue(value));
+ using var pv = TextShadow.ToPropertyValue(value);
+ Object.SetProperty((System.Runtime.InteropServices.HandleRef)SwigCPtr, Property.SHADOW, pv);
}
}
}
if (textLabelAnchorClickedEventHandler == null)
{
textLabelAnchorClickedCallbackDelegate = (OnAnchorClicked);
- AnchorClickedSignal().Connect(textLabelAnchorClickedCallbackDelegate);
+ using var signal = AnchorClickedSignal();
+ signal.Connect(textLabelAnchorClickedCallbackDelegate);
}
textLabelAnchorClickedEventHandler += value;
}
remove
{
textLabelAnchorClickedEventHandler -= value;
- if (textLabelAnchorClickedEventHandler == null && AnchorClickedSignal().Empty() == false)
+ using var signal = AnchorClickedSignal();
+ if (textLabelAnchorClickedEventHandler == null && signal.Empty() == false)
{
- AnchorClickedSignal().Disconnect(textLabelAnchorClickedCallbackDelegate);
+ signal.Disconnect(textLabelAnchorClickedCallbackDelegate);
}
}
}
if (textLabelTextFitChangedEventHandler == null)
{
textLabelTextFitChangedCallbackDelegate = (OnTextFitChanged);
- TextFitChangedSignal().Connect(textLabelTextFitChangedCallbackDelegate);
+ using var signal = TextFitChangedSignal();
+ signal.Connect(textLabelTextFitChangedCallbackDelegate);
}
textLabelTextFitChangedEventHandler += value;
}
remove
{
textLabelTextFitChangedEventHandler -= value;
- if (textLabelTextFitChangedEventHandler == null && TextFitChangedSignal().Empty() == false)
+ using var signal = TextFitChangedSignal();
+ if (textLabelTextFitChangedEventHandler == null && signal.Empty() == false)
{
- TextFitChangedSignal().Disconnect(textLabelTextFitChangedCallbackDelegate);
+ signal.Disconnect(textLabelTextFitChangedCallbackDelegate);
}
}
}
textFitArray.Enable = TextMapHelper.GetBoolFromMap(textFitArrayMap, "enable", false);
textFitArray.OptionList = new List<TextFitArrayOption>();
- var pointSizeArray = TextMapHelper.GetArrayFromMap(textFitArrayMap, "pointSizeArray");
- var minLineSizeArray = TextMapHelper.GetArrayFromMap(textFitArrayMap, "minLineSizeArray");
+ using var pointSizeArray = TextMapHelper.GetArrayFromMap(textFitArrayMap, "pointSizeArray");
+ using var minLineSizeArray = TextMapHelper.GetArrayFromMap(textFitArrayMap, "minLineSizeArray");
if (pointSizeArray != null && minLineSizeArray != null && pointSizeArray.Count() == minLineSizeArray.Count())
{
HandleRef CPtr = new HandleRef(this, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new HandleRef(null, global::System.IntPtr.Zero);
+ return ret;
}
else
{
ret = new Gradient(cPtr, true);
+ return ret;
}
- return ret;
}
set
{
HandleRef CPtr = new HandleRef(this, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new HandleRef(null, global::System.IntPtr.Zero);
+ return ret;
}
else
{
ret = new Gradient(cPtr, true);
+ return ret;
}
- return ret;
}
set
{
if (videoViewFinishedEventHandler == null)
{
videoViewFinishedCallbackDelegate = (OnFinished);
- FinishedSignal().Connect(videoViewFinishedCallbackDelegate);
+ using var signal = FinishedSignal();
+ signal.Connect(videoViewFinishedCallbackDelegate);
}
videoViewFinishedEventHandler += value;
}
remove
{
videoViewFinishedEventHandler -= value;
- if (videoViewFinishedEventHandler == null && FinishedSignal().Empty() == false)
+ using var signal = FinishedSignal();
+ if (videoViewFinishedEventHandler == null && signal.Empty() == false)
{
- FinishedSignal().Disconnect(videoViewFinishedCallbackDelegate);
+ signal.Disconnect(videoViewFinishedCallbackDelegate);
}
}
}
private PropertyMap GetInternalVideo()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.VIDEO);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.VIDEO))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private PropertyMap GetInternalVolume()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.VOLUME);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.VOLUME))
+ {
+ prop.Get(temp);
+ }
return temp;
}
if (this != null && videoViewFinishedCallbackDelegate != null)
{
- FinishedSignal().Disconnect(videoViewFinishedCallbackDelegate);
+ using var signal = FinishedSignal();
+ signal.Disconnect(videoViewFinishedCallbackDelegate);
}
base.Dispose(type);
private PropertyMap GetInternalTooltip()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyMap temp = new PropertyMap();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var pv = Object.GetProperty(SwigCPtr, Property.TOOLTIP);
- pv.Get(temp);
+ using (var pv = Object.GetProperty(SwigCPtr, Property.TOOLTIP))
+ {
+ pv.Get(temp);
+ }
return temp;
}
private Rotation GetInternalOrientation()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Rotation temp = new Rotation();
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var pv = Object.GetProperty(SwigCPtr, Property.ORIENTATION);
- pv.Get(temp);
+ using (var pv = Object.GetProperty(SwigCPtr, Property.ORIENTATION))
+ {
+ pv.Get(temp);
+ }
return temp;
}
HandleRef CPtr = new HandleRef(dummyObect, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new Clipboard(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
[EditorBrowsable(EditorBrowsableState.Never)]
{
if (clipboardDataReceivedCallback != null)
{
- this.ClipboardDataReceivedSignal().Disconnect(clipboardDataReceivedCallback);
+ using var signal = ClipboardDataReceivedSignal();
+ signal.Disconnect(clipboardDataReceivedCallback);
clipboardDataReceivedCallback = null;
}
if (clipboardDataSelectedCallback != null)
{
- this.ClipboardDataSelectedSignal().Disconnect(clipboardDataSelectedCallback);
+ using var signal = ClipboardDataSelectedSignal();
+ signal.Disconnect(clipboardDataSelectedCallback);
clipboardDataSelectedCallback = null;
}
}
if (clipboardDataSelectedEventHandler == null)
{
clipboardDataSelectedCallback = (OnClipboardDataSelected);
- ClipboardDataSelectedSignal().Connect(clipboardDataSelectedCallback);
+ using var signal = ClipboardDataSelectedSignal();
+ signal.Connect(clipboardDataSelectedCallback);
}
clipboardDataSelectedEventHandler += value;
}
clipboardDataSelectedEventHandler -= value;
if (clipboardDataSelectedEventHandler == null && clipboardDataSelectedCallback != null)
{
- ClipboardDataSelectedSignal().Disconnect(clipboardDataSelectedCallback);
+ using var signal = ClipboardDataSelectedSignal();
+ signal.Disconnect(clipboardDataSelectedCallback);
clipboardDataSelectedCallback = null;
}
}
if (clipboardDataReceivedEventHandler == null)
{
clipboardDataReceivedCallback = (OnClipboardDataReceived);
- ClipboardDataReceivedSignal().Connect(clipboardDataReceivedCallback);
+ using var signal = ClipboardDataReceivedSignal();
+ signal.Connect(clipboardDataReceivedCallback);
}
clipboardDataReceivedEventHandler += value;
}
clipboardDataReceivedEventHandler -= value;
if (clipboardDataReceivedEventHandler == null && clipboardDataReceivedCallback != null)
{
- ClipboardDataReceivedSignal().Disconnect(clipboardDataReceivedCallback);
+ using var signal = ClipboardDataReceivedSignal();
+ signal.Disconnect(clipboardDataReceivedCallback);
clipboardDataReceivedCallback = null;
}
}
{
throw new ArgumentNullException(nameof(arg1));
}
- Color result = arg1.Add(arg2);
+ using Color result = arg1.Add(arg2);
return ValueCheck(result);
}
{
throw new ArgumentNullException(nameof(arg1));
}
- Color result = arg1.Subtract(arg2);
+ using Color result = arg1.Subtract(arg2);
return ValueCheck(result);
}
{
throw new ArgumentNullException(nameof(arg1));
}
- Color result = arg1.Subtract();
+ using Color result = arg1.Subtract();
return ValueCheck(result);
}
{
throw new ArgumentNullException(nameof(arg1));
}
- Color result = arg1.Multiply(arg2);
+ using Color result = arg1.Multiply(arg2);
return ValueCheck(result);
}
{
throw new ArgumentNullException(nameof(arg1));
}
- Color result = arg1.Multiply(arg2);
+ using Color result = arg1.Multiply(arg2);
return ValueCheck(result);
}
{
throw new ArgumentNullException(nameof(arg1));
}
- Color result = arg1.Divide(arg2);
+ using Color result = arg1.Divide(arg2);
return ValueCheck(result);
}
{
throw new ArgumentNullException(nameof(arg1));
}
- Color result = arg1.Divide(arg2);
+ using Color result = arg1.Divide(arg2);
return ValueCheck(result);
}
/// <since_tizen> 3 </since_tizen>
public PropertyValue GetValue(uint position)
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyValue ret = new PropertyValue(Interop.PropertyMap.GetValue(SwigCPtr, position), false);
-#pragma warning restore CA2000 // Dispose objects before losing scope
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <since_tizen> 3 </since_tizen>
public PropertyKey GetKeyAt(uint position)
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyKey ret = new PropertyKey(Interop.PropertyMap.GetKeyAt(SwigCPtr, position), true);
-#pragma warning restore CA2000 // Dispose objects before losing scope
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public PropertyValue Find(string stringKey)
{
global::System.IntPtr cPtr = Interop.PropertyMap.Find(SwigCPtr, stringKey);
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
-#pragma warning restore CA2000 // Dispose objects before losing scope
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public PropertyValue Find(int key)
{
global::System.IntPtr cPtr = Interop.PropertyMap.Find(SwigCPtr, key);
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
-#pragma warning restore CA2000 // Dispose objects before losing scope
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public PropertyValue Find(int indexKey, string stringKey)
{
global::System.IntPtr cPtr = Interop.PropertyMap.Find(SwigCPtr, indexKey, stringKey);
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new PropertyValue(cPtr, false);
-#pragma warning restore CA2000 // Dispose objects before losing scope
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <returns>The value for the element with the specified key.</returns>
internal PropertyValue ValueOfIndex(string key)
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyValue ret = new PropertyValue(Interop.PropertyMap.ValueOfIndex(SwigCPtr, key), false);
-#pragma warning restore CA2000 // Dispose objects before losing scope
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <returns>The value for the element with the specified key.</returns>
internal PropertyValue ValueOfIndex(int key)
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
PropertyValue ret = new PropertyValue(Interop.PropertyMap.ValueOfIndex(SwigCPtr, key), false);
-#pragma warning restore CA2000 // Dispose objects before losing scope
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
global::System.Runtime.InteropServices.HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new PropertyCondition(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
/// <summary>
}
System.Type type = obj.GetType();
- PropertyValue value;
if (type.IsEnum)
{
- value = new PropertyValue((int)obj);//Enum.Parse(type, str);
+ PropertyValue value = new PropertyValue((int)obj);//Enum.Parse(type, str);
+ return value;
}
else if (type.Equals(typeof(int)))
{
- value = new PropertyValue((int)obj);
+ PropertyValue value = new PropertyValue((int)obj);
+ return value;
}
else if (type.Equals(typeof(System.Int32)))
{
- value = new PropertyValue((int)obj);
+ PropertyValue value = new PropertyValue((int)obj);
+ return value;
}
else if (type.Equals(typeof(bool)))
{
- value = new PropertyValue((bool)obj);
+ PropertyValue value = new PropertyValue((bool)obj);
+ return value;
}
else if (type.Equals(typeof(float)))
{
- value = new PropertyValue((float)obj);
+ PropertyValue value = new PropertyValue((float)obj);
+ return value;
}
else if (type.Equals(typeof(string)))
{
- value = new PropertyValue((string)obj);
+ PropertyValue value = new PropertyValue((string)obj);
+ return value;
}
else if (type.Equals(typeof(Vector2)))
{
- value = new PropertyValue((Vector2)obj);
+ PropertyValue value = new PropertyValue((Vector2)obj);
+ return value;
}
else if (type.Equals(typeof(Vector3)))
{
- value = new PropertyValue((Vector3)obj);
+ PropertyValue value = new PropertyValue((Vector3)obj);
+ return value;
}
else if (type.Equals(typeof(Vector4)))
{
- value = new PropertyValue((Vector4)obj);
+ PropertyValue value = new PropertyValue((Vector4)obj);
+ return value;
}
else if (type.Equals(typeof(Position)))
{
- value = new PropertyValue((Position)obj);
+ PropertyValue value = new PropertyValue((Position)obj);
+ return value;
}
else if (type.Equals(typeof(Position2D)))
{
- value = new PropertyValue((Position2D)obj);
+ PropertyValue value = new PropertyValue((Position2D)obj);
+ return value;
}
else if (type.Equals(typeof(Size)))
{
- value = new PropertyValue((Size)obj);
+ PropertyValue value = new PropertyValue((Size)obj);
+ return value;
}
else if (type.Equals(typeof(Size2D)))
{
- value = new PropertyValue((Size2D)obj);
+ PropertyValue value = new PropertyValue((Size2D)obj);
+ return value;
}
else if (type.Equals(typeof(Color)))
{
- value = new PropertyValue((Color)obj);
+ PropertyValue value = new PropertyValue((Color)obj);
+ return value;
}
else if (type.Equals(typeof(Rotation)))
{
- value = new PropertyValue((Rotation)obj);
+ PropertyValue value = new PropertyValue((Rotation)obj);
+ return value;
}
else if (type.Equals(typeof(RelativeVector2)))
{
- value = new PropertyValue((RelativeVector2)obj);
+ PropertyValue value = new PropertyValue((RelativeVector2)obj);
+ return value;
}
else if (type.Equals(typeof(RelativeVector3)))
{
- value = new PropertyValue((RelativeVector3)obj);
+ PropertyValue value = new PropertyValue((RelativeVector3)obj);
+ return value;
}
else if (type.Equals(typeof(RelativeVector4)))
{
- value = new PropertyValue((RelativeVector4)obj);
+ PropertyValue value = new PropertyValue((RelativeVector4)obj);
+ return value;
}
else if (type.Equals(typeof(Extents)))
{
- value = new PropertyValue((Extents)obj);
+ PropertyValue value = new PropertyValue((Extents)obj);
+ return value;
}
else if (type.Equals(typeof(Rectangle)))
{
- value = new PropertyValue((Rectangle)obj);
+ PropertyValue value = new PropertyValue((Rectangle)obj);
+ return value;
}
else if (type.Equals(typeof(PropertyArray)))
{
- value = new PropertyValue((PropertyArray)obj);
+ PropertyValue value = new PropertyValue((PropertyArray)obj);
+ return value;
}
else if (type.Equals(typeof(PropertyMap)))
{
- value = new PropertyValue((PropertyMap)obj);
+ PropertyValue value = new PropertyValue((PropertyMap)obj);
+ return value;
}
else if (type.Equals(typeof(UIColor)))
{
UIColor color = ((UIColor)obj);
- value = new PropertyValue(color.R, color.G, color.B, color.A);
+ PropertyValue value = new PropertyValue(color.R, color.G, color.B, color.A);
+ return value;
}
else if (type.Equals(typeof(UICorner)))
{
UICorner corner = ((UICorner)obj);
- value = new PropertyValue(corner.TopLeft, corner.TopRight, corner.BottomRight, corner.BottomLeft);
+ PropertyValue value = new PropertyValue(corner.TopLeft, corner.TopRight, corner.BottomRight, corner.BottomLeft);
+ return value;
}
else if (type.Equals(typeof(UIExtents)))
{
// TODO Do not create Extents instance
using Extents extents = ((UIExtents)obj).ToReferenceType();
- value = new PropertyValue(extents);
+ PropertyValue value = new PropertyValue(extents);
+ return value;
}
else if (type.Equals(typeof(UIVector2)))
{
UIVector2 vector2 = ((UIVector2)obj);
- value = new PropertyValue(vector2.X, vector2.Y);
+ PropertyValue value = new PropertyValue(vector2.X, vector2.Y);
+ return value;
}
else if (type.Equals(typeof(UIVector3)))
{
UIVector3 vector3 = ((UIVector3)obj);
- value = new PropertyValue(vector3.X, vector3.Y, vector3.Z);
+ PropertyValue value = new PropertyValue(vector3.X, vector3.Y, vector3.Z);
+ return value;
}
else
{
throw new global::System.InvalidOperationException("Unimplemented type for Property Value :" + type.Name);
}
- return value;
}
if (styleManagerStyleChangedEventHandler == null)
{
styleManagerStyleChangedCallbackDelegate = (OnStyleChanged);
- StyleChangedSignal().Connect(styleManagerStyleChangedCallbackDelegate);
+ using var signal = StyleChangedSignal();
+ signal.Connect(styleManagerStyleChangedCallbackDelegate);
}
styleManagerStyleChangedEventHandler += value;
}
remove
{
styleManagerStyleChangedEventHandler -= value;
- if (styleManagerStyleChangedEventHandler == null && StyleChangedSignal().Empty() == false)
+ using var signal = StyleChangedSignal();
+ if (styleManagerStyleChangedEventHandler == null && signal.Empty() == false)
{
- StyleChangedSignal().Disconnect(styleManagerStyleChangedCallbackDelegate);
+ signal.Disconnect(styleManagerStyleChangedCallbackDelegate);
}
}
}
HandleRef CPtr = new HandleRef(dummyObect, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new StyleManager(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
[EditorBrowsable(EditorBrowsableState.Never)]
if (detectedEventHandler == null)
{
detectedCallback = OnLongPressGestureDetected;
- DetectedSignal().Connect(detectedCallback);
+ using var signal = DetectedSignal();
+ signal.Connect(detectedCallback);
}
detectedEventHandler += value;
remove
{
detectedEventHandler -= value;
-
- if (detectedEventHandler == null && DetectedSignal().Empty() == false)
+ using var signal = DetectedSignal();
+ if (detectedEventHandler == null && signal.Empty() == false)
{
- DetectedSignal().Disconnect(detectedCallback);
+ signal.Disconnect(detectedCallback);
}
}
}
if (detectedEventHandler == null)
{
detectedCallback = OnPinchGestureDetected;
- DetectedSignal().Connect(detectedCallback);
+ using var signal = DetectedSignal();
+ signal.Connect(detectedCallback);
}
detectedEventHandler += value;
remove
{
detectedEventHandler -= value;
-
- if (detectedEventHandler == null && DetectedSignal().Empty() == false)
+ using var signal = DetectedSignal();
+ if (detectedEventHandler == null && signal.Empty() == false)
{
- DetectedSignal().Disconnect(detectedCallback);
+ signal.Disconnect(detectedCallback);
}
}
}
if (detectedEventHandler == null)
{
detectedCallback = OnRotationGestureDetected;
- DetectedSignal().Connect(detectedCallback);
+ using var signal = DetectedSignal();
+ signal.Connect(detectedCallback);
}
detectedEventHandler += value;
remove
{
detectedEventHandler -= value;
-
- if (detectedEventHandler == null && DetectedSignal().Empty() == false)
+ using var signal = DetectedSignal();
+ if (detectedEventHandler == null && signal.Empty() == false)
{
- DetectedSignal().Disconnect(detectedCallback);
+ signal.Disconnect(detectedCallback);
}
}
}
if (_detectedEventHandler == null)
{
_detectedCallback = OnTapGestureDetected;
- DetectedSignal().Connect(_detectedCallback);
+ using var signal = DetectedSignal();
+ signal.Connect(_detectedCallback);
}
_detectedEventHandler += value;
remove
{
_detectedEventHandler -= value;
-
- if (_detectedEventHandler == null && DetectedSignal().Empty() == false)
+ using var signal = DetectedSignal();
+ if (_detectedEventHandler == null && signal.Empty() == false)
{
- DetectedSignal().Disconnect(_detectedCallback);
+ signal.Disconnect(_detectedCallback);
}
}
}
global::System.Runtime.InteropServices.HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(dummyObect, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+#if !PROFILE_TV
+ //tv profile never use default focus indicator, so this is not needed!
+ ret.FocusIndicator = ret.GetDefaultFocusIndicator();
+#endif
+ return ret;
}
else
{
ret = new FocusManager(cPtr, true);
- }
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
#if !PROFILE_TV
- //tv profile never use default focus indicator, so this is not needed!
- ret.FocusIndicator = ret.GetDefaultFocusIndicator();
+ //tv profile never use default focus indicator, so this is not needed!
+ ret.FocusIndicator = ret.GetDefaultFocusIndicator();
#endif
- return ret;
+ return ret;
+ }
}
[EditorBrowsable(EditorBrowsableState.Never)]
if (activatedEventHandler == null)
{
CreateSafeCallback(OnActivated, out activatedEventCallback);
- ActivatedSignal().Connect(activatedEventCallback);
+ using var signal = ActivatedSignal();
+ signal.Connect(activatedEventCallback);
}
activatedEventHandler += value;
if (activatedEventHandler == null && activatedEventCallback != null)
{
- ActivatedSignal().Disconnect(activatedEventCallback);
+ using var signal = ActivatedSignal();
+ signal.Disconnect(activatedEventCallback);
ReleaseSafeCallback(ref activatedEventCallback);
}
}
if (eventReceivedEventHandler == null)
{
CreateSafeCallback(OnEventReceived, out eventReceivedEventCallback);
- EventReceivedSignal().Connect(eventReceivedEventCallback);
+ using var signal = EventReceivedSignal();
+ signal.Connect(eventReceivedEventCallback);
}
eventReceivedEventHandler += value;
if (eventReceivedEventHandler == null && eventReceivedEventCallback != null)
{
- EventReceivedSignal().Disconnect(eventReceivedEventCallback);
+ using var signal = EventReceivedSignal();
+ signal.Disconnect(eventReceivedEventCallback);
ReleaseSafeCallback(ref eventReceivedEventCallback);
}
}
if (statusChangedEventHandler == null)
{
CreateSafeCallback(OnStatusChanged, out statusChangedEventCallback);
- StatusChangedSignal().Connect(statusChangedEventCallback);
+ using var signal = StatusChangedSignal();
+ signal.Connect(statusChangedEventCallback);
}
statusChangedEventHandler += value;
if (statusChangedEventHandler == null && statusChangedEventCallback != null)
{
- StatusChangedSignal().Disconnect(statusChangedEventCallback);
+ using var signal = StatusChangedSignal();
+ signal.Disconnect(statusChangedEventCallback);
ReleaseSafeCallback(ref statusChangedEventCallback);
}
}
if (resizedEventHandler == null)
{
CreateSafeCallback(OnResized, out resizedEventCallback);
- ResizedSignal().Connect(resizedEventCallback);
+ using var signal = ResizedSignal();
+ signal.Connect(resizedEventCallback);
}
resizedEventHandler += value;
if (resizedEventHandler == null && resizedEventCallback != null)
{
- ResizedSignal().Disconnect(resizedEventCallback);
+ using var signal = ResizedSignal();
+ signal.Disconnect(resizedEventCallback);
ReleaseSafeCallback(ref resizedEventCallback);
}
}
if (languageChangedEventHandler == null)
{
CreateSafeCallback(OnLanguageChanged, out languageChangedEventCallback);
- LanguageChangedSignal().Connect(languageChangedEventCallback);
+ using var signal = LanguageChangedSignal();
+ signal.Connect(languageChangedEventCallback);
}
languageChangedEventHandler += value;
if (languageChangedEventHandler == null && languageChangedEventCallback != null)
{
- LanguageChangedSignal().Disconnect(languageChangedEventCallback);
+ using var signal = LanguageChangedSignal();
+ signal.Disconnect(languageChangedEventCallback);
ReleaseSafeCallback(ref languageChangedEventCallback);
}
}
if (keyboardTypeChangedEventHandler == null)
{
CreateSafeCallback(OnKeyboardTypeChanged, out keyboardTypeChangedEventCallback);
- KeyboardTypeChangedSignal().Connect(keyboardTypeChangedEventCallback);
+ using var signal = KeyboardTypeChangedSignal();
+ signal.Connect(keyboardTypeChangedEventCallback);
}
keyboardTypeChangedEventHandler += value;
if (keyboardTypeChangedEventHandler == null && keyboardTypeChangedEventCallback != null)
{
- KeyboardTypeChangedSignal().Disconnect(keyboardTypeChangedEventCallback);
+ using var signal = KeyboardTypeChangedSignal();
+ signal.Disconnect(keyboardTypeChangedEventCallback);
ReleaseSafeCallback(ref keyboardTypeChangedEventCallback);
}
}
if (contentReceivedEventHandler == null)
{
CreateSafeCallback(OnContentReceived, out contentReceivedEventCallback);
- ContentReceivedSignal().Connect(contentReceivedEventCallback);
+ using var signal = ContentReceivedSignal();
+ signal.Connect(contentReceivedEventCallback);
}
contentReceivedEventHandler += value;
if (contentReceivedEventHandler == null && contentReceivedEventCallback != null)
{
- ContentReceivedSignal().Disconnect(contentReceivedEventCallback);
+ using var signal = ContentReceivedSignal();
+ signal.Disconnect(contentReceivedEventCallback);
ReleaseSafeCallback(ref contentReceivedEventCallback);
}
}
if (activatedEventCallback != null)
{
- ActivatedSignal().Disconnect(activatedEventCallback);
+ using var signal = ActivatedSignal();
+ signal.Disconnect(activatedEventCallback);
activatedEventCallback = null;
}
if (eventReceivedEventCallback != null)
{
- EventReceivedSignal().Disconnect(eventReceivedEventCallback);
+ using var signal = EventReceivedSignal();
+ signal.Disconnect(eventReceivedEventCallback);
eventReceivedEventCallback = null;
}
if (statusChangedEventCallback != null)
{
- StatusChangedSignal().Disconnect(statusChangedEventCallback);
+ using var signal = StatusChangedSignal();
+ signal.Disconnect(statusChangedEventCallback);
statusChangedEventCallback = null;
}
if (resizedEventCallback != null)
{
- ResizedSignal().Disconnect(resizedEventCallback);
+ using var signal = ResizedSignal();
+ signal.Disconnect(resizedEventCallback);
resizedEventCallback = null;
}
if (languageChangedEventCallback != null)
{
- LanguageChangedSignal().Disconnect(languageChangedEventCallback);
+ using var signal = LanguageChangedSignal();
+ signal.Disconnect(languageChangedEventCallback);
languageChangedEventCallback = null;
}
if (keyboardTypeChangedEventCallback != null)
{
- KeyboardTypeChangedSignal().Disconnect(keyboardTypeChangedEventCallback);
+ using var signal = KeyboardTypeChangedSignal();
+ signal.Disconnect(keyboardTypeChangedEventCallback);
keyboardTypeChangedEventCallback = null;
}
if (contentReceivedEventCallback != null)
{
- ContentReceivedSignal().Disconnect(contentReceivedEventCallback);
+ using var signal = ContentReceivedSignal();
+ signal.Disconnect(contentReceivedEventCallback);
contentReceivedEventCallback = null;
}
}
if (ret != null)
{
Interop.BaseHandle.DeleteBaseHandle(new global::System.Runtime.InteropServices.HandleRef(this, cPtr));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ return ret;
}
else
{
ret = new TextureSet(cPtr, true);
+ return ret;
}
- NDalicPINVOKE.ThrowExceptionIfExists();
- return ret;
}
internal Renderable(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
if (ret != null)
{
Interop.BaseHandle.DeleteBaseHandle(new global::System.Runtime.InteropServices.HandleRef(this, cPtr));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ return ret;
}
else
{
ret = new Texture(cPtr, true);
+ return ret;
}
- NDalicPINVOKE.ThrowExceptionIfExists();
- return ret;
}
/// <summary>
if (ret != null)
{
Interop.BaseHandle.DeleteBaseHandle(new global::System.Runtime.InteropServices.HandleRef(this, cPtr));
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ return ret;
}
else
{
ret = new Sampler(cPtr, true);
+ return ret;
}
- NDalicPINVOKE.ThrowExceptionIfExists();
- return ret;
}
/// <summary>
global::System.Runtime.InteropServices.HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(dummyObect, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new FontClient(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
[EditorBrowsable(EditorBrowsableState.Never)]
if (stateChangedEventHandler == null)
{
stateChangedEventCallback = OnStateChanged;
- StateChangedSignal().Connect(stateChangedEventCallback);
+ using var signal = StateChangedSignal();
+ signal.Connect(stateChangedEventCallback);
}
stateChangedEventHandler += value;
remove
{
stateChangedEventHandler -= value;
-
- if (stateChangedEventHandler == null && StateChangedSignal().Empty() == false && stateChangedEventCallback != null)
+ using var signal = StateChangedSignal();
+ if (stateChangedEventHandler == null && signal.Empty() == false && stateChangedEventCallback != null)
{
- StateChangedSignal().Disconnect(stateChangedEventCallback);
+ signal.Disconnect(stateChangedEventCallback);
}
}
}
HandleRef CPtr = new HandleRef(dummyObect, cPtr);
Interop.BaseHandle.DeleteBaseHandle(CPtr);
CPtr = new HandleRef(null, global::System.IntPtr.Zero);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
else
{
ret = new TTSPlayer(cPtr, true);
+ return ret;
}
-
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
[EditorBrowsable(EditorBrowsableState.Never)]
{
if (timerTickEventHandler == null && disposed == false)
{
- TickSignal().Connect(timerTickCallbackOfNative);
+ using var signal = TickSignal();
+ signal.Connect(timerTickCallbackOfNative);
}
timerTickEventHandler += value;
}
remove
{
timerTickEventHandler -= value;
- if (timerTickEventHandler == null && TickSignal().Empty() == false)
+ using var signal = TickSignal();
+ if (timerTickEventHandler == null && signal.Empty() == false)
{
- TickSignal().Disconnect(timerTickCallbackOfNative);
+ signal.Disconnect(timerTickCallbackOfNative);
}
}
}
if (this != null && timerTickCallbackDelegate != null)
{
- TickSignal().Disconnect(timerTickCallbackOfNative);
+ using var signal = TickSignal();
+ signal.Disconnect(timerTickCallbackOfNative);
}
if (disposed)
Offset = new Vector2(noOffset);
Extents = new Vector2(noExtents);
- var transformProperty = propertyMap.Find(Visual.Property.Transform);
+ var transformProperty = propertyMap?.Find(Visual.Property.Transform);
if (transformProperty == null)
{
get
{
Vector4 ret = new Vector4();
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerRadius);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerRadius))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Vector4 ret = new Vector4();
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerSquareness);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerSquareness))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Color ret = new Color(0.0f, 0.0f, 0.0f, 1.0f);
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.BorderlineColor);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.BorderlineColor))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Vector4 ret = new Vector4(0.0f, 0.0f, 1.0f, 1.0f);
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.ImageVisualProperty.PixelArea);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.ImageVisualProperty.PixelArea))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Vector4 ret = new Vector4();
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerRadius);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerRadius))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Vector4 ret = new Vector4();
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerSquareness);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.CornerSquareness))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Color ret = new Color(0.0f, 0.0f, 0.0f, 1.0f);
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.BorderlineColor);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.BorderlineColor))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Rectangle ret = new Rectangle();
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.NpatchImageVisualProperty.Border);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.NpatchImageVisualProperty.Border))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
get
{
Tizen.NUI.Color ret = new Color(0.0f, 0.0f, 0.0f, 1.0f);
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.TextVisualProperty.TextColor);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.TextVisualProperty.TextColor))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
internal void ConvertFromPropertyMap(PropertyMap inputMap)
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
- PropertyValue value = null;
-
- if ((value = inputMap?.Find((int)VisualTransformPropertyType.Size)) != null)
- {
- using var size = new Size();
- if (value.Get(size))
+ using (PropertyValue value = inputMap?.Find((int)VisualTransformPropertyType.Size))
+ if (value != null)
{
- width = size.Width;
- height = size.Height;
+ using var size = new Size();
+ if (value.Get(size))
+ {
+ width = size.Width;
+ height = size.Height;
+ }
}
- }
- if ((value = inputMap?.Find((int)VisualTransformPropertyType.Offset)) != null)
- {
- using var offset = new Position();
- if (value.Get(offset))
+ using (PropertyValue value = inputMap?.Find((int)VisualTransformPropertyType.Offset))
+ if (value != null)
{
- offsetX = offset.X;
- offsetY = offset.Y;
+ using var offset = new Position();
+ if (value.Get(offset))
+ {
+ offsetX = offset.X;
+ offsetY = offset.Y;
+ }
}
- }
- if ((value = inputMap?.Find((int)VisualTransformPropertyType.SizePolicy)) != null)
- {
- using var policyValue = new Vector2();
- if (value.Get(policyValue))
+ using (PropertyValue value = inputMap?.Find((int)VisualTransformPropertyType.SizePolicy))
+ if (value != null)
{
- widthPolicy = (VisualTransformPolicyType)policyValue.X;
- heightPolicy = (VisualTransformPolicyType)policyValue.Y;
+ using var policyValue = new Vector2();
+ if (value.Get(policyValue))
+ {
+ widthPolicy = (VisualTransformPolicyType)policyValue.X;
+ heightPolicy = (VisualTransformPolicyType)policyValue.Y;
+ }
}
- }
- if ((value = inputMap?.Find((int)VisualTransformPropertyType.OffsetPolicy)) != null)
- {
- using var policyValue = new Vector2();
- if (value.Get(policyValue))
+ using (PropertyValue value = inputMap?.Find((int)VisualTransformPropertyType.OffsetPolicy))
+ if (value != null)
{
- offsetXPolicy = (VisualTransformPolicyType)policyValue.X;
- offsetYPolicy = (VisualTransformPolicyType)policyValue.Y;
+ using var policyValue = new Vector2();
+ if (value.Get(policyValue))
+ {
+ offsetXPolicy = (VisualTransformPolicyType)policyValue.X;
+ offsetYPolicy = (VisualTransformPolicyType)policyValue.Y;
+ }
}
- }
- if ((value = inputMap?.Find((int)VisualTransformPropertyType.Origin)) != null)
- {
- int ret = 0;
- if (value.Get(out ret))
+ using (PropertyValue value = inputMap?.Find((int)VisualTransformPropertyType.Origin))
+ if (value != null)
{
- origin = (Visual.AlignType)ret;
+ int ret = 0;
+ if (value.Get(out ret))
+ {
+ origin = (Visual.AlignType)ret;
+ }
}
- }
- if ((value = inputMap?.Find((int)VisualTransformPropertyType.AnchorPoint)) != null)
- {
- int ret = 0;
- if (value.Get(out ret))
+ using (PropertyValue value = inputMap?.Find((int)VisualTransformPropertyType.AnchorPoint))
+ if (value != null)
{
- pivotPoint = (Visual.AlignType)ret;
+ int ret = 0;
+ if (value.Get(out ret))
+ {
+ pivotPoint = (Visual.AlignType)ret;
+ }
}
- }
- if ((value = inputMap?.Find((int)VisualTransformPropertyType.ExtraSize)) != null)
- {
- using var extraValue = new Vector2();
- if (value.Get(extraValue))
+ using (PropertyValue value = inputMap?.Find((int)VisualTransformPropertyType.ExtraSize))
+ if (value != null)
{
- extraWidth = extraValue.Width;
- extraHeight = extraValue.Height;
+ using var extraValue = new Vector2();
+ if (value.Get(extraValue))
+ {
+ extraWidth = extraValue.Width;
+ extraHeight = extraValue.Height;
+ }
}
- }
- value?.Dispose();
-#pragma warning restore CA2000 // Dispose objects before losing scope
}
};
internal VisualTransformInfo transformInfo;
}
get
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Tizen.NUI.Color ret = new Tizen.NUI.Color(1.0f, 1.0f, 1.0f, 1.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.MixColor);
- propertyValue?.Get(ret);
+ using (var propertyValue = GetCachedVisualProperty((int)Tizen.NUI.Visual.Property.MixColor))
+ {
+ propertyValue?.Get(ret);
+ }
return ret;
}
}
private Vector2 GetInternalScrollSize()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector2 temp = new Vector2(0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.ScrollSize);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.ScrollSize))
+ {
+ prop.Get(temp);
+ }
return temp;
}
private Vector2 GetInternalContentSize()
{
-#pragma warning disable CA2000 // Dispose objects before losing scope
Vector2 temp = new Vector2(0.0f, 0.0f);
-#pragma warning restore CA2000 // Dispose objects before losing scope
- using var prop = Object.GetProperty(SwigCPtr, Property.ContentSize);
- prop.Get(temp);
+ using (var prop = Object.GetProperty(SwigCPtr, Property.ContentSize))
+ {
+ prop.Get(temp);
+ }
return temp;
}
if (focusChangedEventCallback == null)
{
focusChangedEventCallback = OnWindowFocusedChanged;
- FocusChangedSignal().Connect(focusChangedEventCallback);
+ using var signal = FocusChangedSignal();
+ signal.Connect(focusChangedEventCallback);
}
focusChangedEventHandler += value;
remove
{
focusChangedEventHandler -= value;
-
- if (focusChangedEventHandler == null && FocusChangedSignal().Empty() == false && focusChangedEventCallback != null)
+ using var signal = FocusChangedSignal();
+ if (focusChangedEventHandler == null && signal.Empty() == false && focusChangedEventCallback != null)
{
- FocusChangedSignal().Disconnect(focusChangedEventCallback);
+ signal.Disconnect(focusChangedEventCallback);
}
}
}
if (stageKeyHandler == null)
{
windowKeyCallbackDelegate = OnStageKey;
- KeyEventSignal().Connect(windowKeyCallbackDelegate);
+ using var signal = KeyEventSignal();
+ signal.Connect(windowKeyCallbackDelegate);
}
stageKeyHandler += value;
}
remove
{
stageKeyHandler -= value;
- if (stageKeyHandler == null && KeyEventSignal().Empty() == false)
+ using var signal = KeyEventSignal();
+ if (stageKeyHandler == null && signal.Empty() == false)
{
- KeyEventSignal().Disconnect(windowKeyCallbackDelegate);
+ signal.Disconnect(windowKeyCallbackDelegate);
}
}
}
if (windowResizedEventHandler == null)
{
windowResizedEventCallback = OnResized;
- GLWindowResizedSignal().Connect(windowResizedEventCallback);
+ using var signal = GLWindowResizedSignal();
+ signal.Connect(windowResizedEventCallback);
}
windowResizedEventHandler += value;
remove
{
windowResizedEventHandler -= value;
-
- if (windowResizedEventHandler == null && GLWindowResizedSignal().Empty() == false && windowResizedEventCallback != null)
+ using var signal = GLWindowResizedSignal();
+ if (windowResizedEventHandler == null && signal.Empty() == false && windowResizedEventCallback != null)
{
- GLWindowResizedSignal().Disconnect(windowResizedEventCallback);
+ signal.Disconnect(windowResizedEventCallback);
}
}
}
{
if (focusChangedEventCallback != null)
{
- FocusChangedSignal().Disconnect(focusChangedEventCallback);
+ using var signal = FocusChangedSignal();
+ signal.Disconnect(focusChangedEventCallback);
}
if (windowTouchDataCallback != null)
if (windowKeyCallbackDelegate != null)
{
- KeyEventSignal().Disconnect(windowKeyCallbackDelegate);
+ using var signal = KeyEventSignal();
+ signal.Disconnect(windowKeyCallbackDelegate);
}
if (windowResizedEventCallback != null)
{
- GLWindowResizedSignal().Disconnect(windowResizedEventCallback);
+ using var signal = GLWindowResizedSignal();
+ signal.Disconnect(windowResizedEventCallback);
}
}
projects / platform / core / csapi / tizenfx.git / commitdiff