-/*
- * Copyright(c) 2019 Samsung Electronics Co., Ltd.
+/*
+ * Copyright(c) 2022 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
using System;
using System.ComponentModel;
-using System.Collections.Generic;
-using System.IO;
-using System.Runtime.InteropServices;
-using Tizen.NUI.Binding;
-using Tizen.NUI.Xaml;
+using global::System.Diagnostics;
+using Tizen.NUI;
namespace Tizen.NUI.BaseComponents
{
/// <since_tizen> 3 </since_tizen>
public partial class View
{
- private MergedStyle mergedStyle = null;
- private ViewSelectorData selectorData;
internal string styleName;
- internal MergedStyle _mergedStyle
+ [Flags]
+ internal enum BackgroundExtraDataUpdatedFlag : byte
{
- get
+ BackgroundCornerRadius = 1 << 0,
+ BackgroundBorderline = 1 << 1,
+ ShadowCornerRadius = 1 << 2,
+ ContentsCornerRadius = 1 << 3, /// Subclass cases.
+ ContentsBorderline = 1 << 4, /// Subclass cases.
+
+ Background = BackgroundCornerRadius | BackgroundBorderline,
+ Shadow = ShadowCornerRadius,
+
+ CornerRadius = BackgroundCornerRadius | ShadowCornerRadius | ContentsCornerRadius,
+ Borderline = BackgroundBorderline | ContentsBorderline,
+
+ None = 0,
+ All = Background | Shadow,
+ }
+
+ internal BackgroundExtraDataUpdatedFlag backgroundExtraDataUpdatedFlag = BackgroundExtraDataUpdatedFlag.None;
+
+ private bool backgroundExtraDataUpdateProcessAttachedFlag = false;
+
+ internal virtual LayoutItem CreateDefaultLayout()
+ {
+ return new AbsoluteLayout();
+ }
+
+ internal class ThemeData
+ {
+ [Flags]
+ private enum States : byte
{
- if (null == mergedStyle)
- {
- mergedStyle = new MergedStyle(GetType(), this);
- }
+ None = 0,
+ ControlStatePropagation = 1 << 0,
+ ThemeChangeSensitive = 1 << 1,
+ ThemeApplied = 1 << 2, // It is true when the view has valid style name or the platform theme has a component style for this view type.
+ // That indicates the view can have different styles by theme.
+ // Hence if the current state has ThemeApplied and ThemeChangeSensitive, the view will change its style by theme changing.
+ ListeningThemeChangeEvent = 1 << 3,
+ };
- return mergedStyle;
+ private States states = ThemeManager.ApplicationThemeChangeSensitive ? States.ThemeChangeSensitive : States.None;
+ public ViewStyle viewStyle;
+ public ControlState controlStates = ControlState.Normal;
+ public ViewSelectorData selectorData;
+
+ public bool ControlStatePropagation
+ {
+ get => ((states & States.ControlStatePropagation) != 0);
+ set => SetOption(States.ControlStatePropagation, value);
+ }
+
+ public bool ThemeChangeSensitive
+ {
+ get => ((states & States.ThemeChangeSensitive) != 0);
+ set => SetOption(States.ThemeChangeSensitive, value);
+ }
+
+ public bool ThemeApplied
+ {
+ get => ((states & States.ThemeApplied) != 0);
+ set => SetOption(States.ThemeApplied, value);
+ }
+
+ public bool ListeningThemeChangeEvent
+ {
+ get => ((states & States.ListeningThemeChangeEvent) != 0);
+ set => SetOption(States.ListeningThemeChangeEvent, value);
+ }
+
+ private void SetOption(States option, bool value)
+ {
+ if (value) states |= option;
+ else states &= ~option;
}
}
}
}
+ internal LayoutLength SuggestedMinimumWidth
+ {
+ get
+ {
+ float result = Interop.Actor.GetSuggestedMinimumWidth(SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return new LayoutLength(result);
+ }
+ }
+
+ internal LayoutLength SuggestedMinimumHeight
+ {
+ get
+ {
+ float result = Interop.Actor.GetSuggestedMinimumHeight(SwigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return new LayoutLength(result);
+ }
+ }
+
internal float WorldPositionX
{
get
{
- float returnValue = 0.0f;
- PropertyValue wordPositionX = GetProperty(View.Property.WORLD_POSITION_X);
- wordPositionX?.Get(out returnValue);
- wordPositionX?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.WorldPositionX);
}
}
{
get
{
- float returnValue = 0.0f;
- PropertyValue wordPositionY = GetProperty(View.Property.WORLD_POSITION_Y);
- wordPositionY?.Get(out returnValue);
- wordPositionY?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.WorldPositionY);
}
}
{
get
{
- float returnValue = 0.0f;
- PropertyValue wordPositionZ = GetProperty(View.Property.WORLD_POSITION_Z);
- wordPositionZ?.Get(out returnValue);
- wordPositionZ?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.WorldPositionZ);
}
}
internal void SetLayout(LayoutItem layout)
{
- _layout = layout;
- _layout?.AttachToOwner(this);
- _layout?.RequestLayout();
- }
+ LayoutCount++;
- /// <summary>
- /// Stores the calculated width value and its ModeType. Width component.
- /// </summary>
- internal MeasureSpecification MeasureSpecificationWidth
- {
- set
- {
- _measureSpecificationWidth = value;
- _layout?.RequestLayout();
- }
- get
- {
- return _measureSpecificationWidth;
- }
- }
-
- /// <summary>
- /// Stores the calculated width value and its ModeType. Height component.
- /// </summary>
- internal MeasureSpecification MeasureSpecificationHeight
- {
- set
- {
- _measureSpecificationHeight = value;
- _layout?.RequestLayout();
- }
- get
- {
- return _measureSpecificationHeight;
- }
+ this.layout = layout;
+ this.layout?.AttachToOwner(this);
+ this.layout?.RequestLayout();
}
internal void AttachTransitionsToChildren(LayoutTransition transition)
{
get
{
- float returnValue = 0.0f;
- PropertyValue parentOriginX = GetProperty(View.Property.PARENT_ORIGIN_X);
- parentOriginX?.Get(out returnValue);
- parentOriginX?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.ParentOriginX);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.PARENT_ORIGIN_X, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyFloat(SwigCPtr, View.Property.WorldPositionX, value);
NotifyPropertyChanged();
}
}
{
get
{
- float returnValue = 0.0f;
- PropertyValue parentOriginY = GetProperty(View.Property.PARENT_ORIGIN_Y);
- parentOriginY?.Get(out returnValue);
- parentOriginY?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.ParentOriginY);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.PARENT_ORIGIN_Y, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyFloat(SwigCPtr, View.Property.ParentOriginY, value);
NotifyPropertyChanged();
}
}
{
get
{
- float returnValue = 0.0f;
- PropertyValue parentOriginZ = GetProperty(View.Property.PARENT_ORIGIN_Z);
- parentOriginZ?.Get(out returnValue);
- parentOriginZ?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.ParentOriginZ);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.PARENT_ORIGIN_Z, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyFloat(SwigCPtr, View.Property.ParentOriginZ, value);
NotifyPropertyChanged();
}
}
{
get
{
- float returnValue = 0.0f;
- PropertyValue anchorPointX = GetProperty(View.Property.ANCHOR_POINT_X);
- anchorPointX?.Get(out returnValue);
- anchorPointX?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.AnchorPointX);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.ANCHOR_POINT_X, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyFloat(SwigCPtr, View.Property.AnchorPointX, value);
}
}
{
get
{
- float returnValue = 0.0f;
- PropertyValue anchorPointY = GetProperty(View.Property.ANCHOR_POINT_Y);
- anchorPointY?.Get(out returnValue);
- anchorPointY?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.AnchorPointY);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.ANCHOR_POINT_Y, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyFloat(SwigCPtr, View.Property.AnchorPointY, value);
}
}
{
get
{
- float returnValue = 0.0f;
- PropertyValue anchorPointZ = GetProperty(View.Property.ANCHOR_POINT_Z);
- anchorPointZ?.Get(out returnValue);
- anchorPointZ?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.AnchorPointZ);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.ANCHOR_POINT_Z, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyFloat(SwigCPtr, View.Property.AnchorPointZ, value);
}
}
get
{
Matrix returnValue = new Matrix();
- PropertyValue wordMatrix = GetProperty(View.Property.WORLD_MATRIX);
+ PropertyValue wordMatrix = GetProperty(View.Property.WorldMatrix);
wordMatrix?.Get(returnValue);
wordMatrix?.Dispose();
return returnValue;
}
/// <summary>
+ /// The number of layouts including view's layout and children's layouts.
+ /// This can be used to set/unset Process callback to calculate Layout.
+ /// </summary>
+ internal int LayoutCount
+ {
+ get
+ {
+ return layoutCount;
+ }
+
+ set
+ {
+ if (layoutCount == value) return;
+
+ if (value < 0) throw new global::System.ArgumentOutOfRangeException(nameof(LayoutCount), "LayoutCount(" + LayoutCount + ") should not be less than zero");
+
+ int diff = value - layoutCount;
+ layoutCount = value;
+
+ if (InternalParent != null)
+ {
+ var parentView = InternalParent as View;
+ if (parentView != null)
+ {
+ parentView.LayoutCount += diff;
+ }
+ else
+ {
+ var parentLayer = InternalParent as Layer;
+ if (parentLayer != null)
+ {
+ parentLayer.LayoutCount += diff;
+ }
+ }
+ }
+ }
+ }
+
+ /// <summary>
/// Indicates that this View should listen Touch event to handle its ControlState.
/// </summary>
private bool enableControlState = false;
{
get
{
- int returnValue = 0;
- PropertyValue leftFocusableViewId = GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID);
- leftFocusableViewId?.Get(out returnValue);
- leftFocusableViewId?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyInt(SwigCPtr, View.Property.LeftFocusableViewId);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyInt(SwigCPtr, View.Property.LeftFocusableViewId, value);
}
}
{
get
{
- int returnValue = 0;
- PropertyValue rightFocusableViewId = GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID);
- rightFocusableViewId?.Get(out returnValue);
- rightFocusableViewId?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyInt(SwigCPtr, View.Property.RightFocusableViewId);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyInt(SwigCPtr, View.Property.RightFocusableViewId, value);
}
}
{
get
{
- int returnValue = 0;
- PropertyValue upFocusableViewId = GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID);
- upFocusableViewId?.Get(out returnValue);
- upFocusableViewId?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyInt(SwigCPtr, View.Property.UpFocusableViewId);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, setValue);
- setValue.Dispose();
+
+ Object.InternalSetPropertyInt(SwigCPtr, View.Property.UpFocusableViewId, value);
}
}
{
get
{
- int returnValue = 0;
- PropertyValue downFocusableViewId = GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID);
- downFocusableViewId?.Get(out returnValue);
- downFocusableViewId?.Dispose();
- return returnValue;
+
+ return Object.InternalGetPropertyInt(SwigCPtr, View.Property.DownFocusableViewId);
}
set
{
- PropertyValue setValue = new Tizen.NUI.PropertyValue(value);
- SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, setValue);
- setValue.Dispose();
- }
- }
- private ViewSelectorData SelectorData
- {
- get
- {
- if (selectorData == null)
- {
- selectorData = new ViewSelectorData();
- }
- return selectorData;
+ Object.InternalSetPropertyInt(SwigCPtr, View.Property.DownFocusableViewId, value);
}
}
- internal void Raise()
+ private int ClockwiseFocusableViewId
{
- var parentChildren = GetParent()?.Children;
-
- if (parentChildren != null)
+ get
{
- int currentIndex = parentChildren.IndexOf(this);
-
- // If the view is not already the last item in the list.
- if (currentIndex >= 0 && currentIndex < parentChildren.Count - 1)
- {
- View temp = parentChildren[currentIndex + 1];
- parentChildren[currentIndex + 1] = this;
- parentChildren[currentIndex] = temp;
- Interop.NDalic.Raise(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ return Object.InternalGetPropertyInt(SwigCPtr, View.Property.ClockwiseFocusableViewId);
}
- }
-
- internal void Lower()
- {
- var parentChildren = GetParent()?.Children;
-
- if (parentChildren != null)
+ set
{
- int currentIndex = parentChildren.IndexOf(this);
-
- // If the view is not already the first item in the list.
- if (currentIndex > 0 && currentIndex < parentChildren.Count)
- {
- View temp = parentChildren[currentIndex - 1];
- parentChildren[currentIndex - 1] = this;
- parentChildren[currentIndex] = temp;
- Interop.NDalic.Lower(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ Object.InternalSetPropertyInt(SwigCPtr, View.Property.ClockwiseFocusableViewId, value);
}
}
- /// <summary>
- /// Raises the view to above the target view.
- /// </summary>
- /// <remarks>The sibling order of views within the parent will be updated automatically.
- /// Views on the level above the target view will still be shown above this view.
- /// Raising this view above views with the same sibling order as each other will raise this view above them.
- /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- /// <param name="target">Will be raised above this view.</param>
- internal void RaiseAbove(View target)
+ private int CounterClockwiseFocusableViewId
{
- var parentChildren = GetParent()?.Children;
-
- if (parentChildren != null)
+ get
{
- int currentIndex = parentChildren.IndexOf(this);
- int targetIndex = parentChildren.IndexOf(target);
-
- if (currentIndex < 0 || targetIndex < 0 ||
- currentIndex >= parentChildren.Count || targetIndex >= parentChildren.Count)
- {
- NUILog.Error("index should be bigger than 0 and less than children of layer count");
- return;
- }
- // If the currentIndex is less than the target index and the target has the same parent.
- if (currentIndex < targetIndex)
- {
- parentChildren.Remove(this);
- parentChildren.Insert(targetIndex, this);
- Interop.NDalic.RaiseAbove(swigCPtr, View.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ return Object.InternalGetPropertyInt(SwigCPtr, View.Property.CounterClockwiseFocusableViewId);
}
-
- }
-
- /// <summary>
- /// Lowers the view to below the target view.
- /// </summary>
- /// <remarks>The sibling order of views within the parent will be updated automatically.
- /// Lowering this view below views with the same sibling order as each other will lower this view above them.
- /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- /// <param name="target">Will be lowered below this view.</param>
- internal void LowerBelow(View target)
- {
- var parentChildren = GetParent()?.Children;
-
- if (parentChildren != null)
+ set
{
- int currentIndex = parentChildren.IndexOf(this);
- int targetIndex = parentChildren.IndexOf(target);
- if (currentIndex < 0 || targetIndex < 0 ||
- currentIndex >= parentChildren.Count || targetIndex >= parentChildren.Count)
- {
- NUILog.Error("index should be bigger than 0 and less than children of layer count");
- return;
- }
-
- // If the currentIndex is not already the 0th index and the target has the same parent.
- if ((currentIndex != 0) && (targetIndex != -1) &&
- (currentIndex > targetIndex))
- {
- parentChildren.Remove(this);
- parentChildren.Insert(targetIndex, this);
- Interop.NDalic.LowerBelow(swigCPtr, View.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ Object.InternalSetPropertyInt(SwigCPtr, View.Property.CounterClockwiseFocusableViewId, value);
}
-
}
internal string GetName()
{
- string ret = Interop.Actor.Actor_GetName(swigCPtr);
+ string ret = Interop.Actor.GetName(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetName(string name)
{
- Interop.Actor.Actor_SetName(swigCPtr, name);
+ Interop.Actor.SetName(SwigCPtr, name);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal uint GetId()
{
- uint ret = Interop.Actor.Actor_GetId(swigCPtr);
+ uint ret = Interop.Actor.GetId(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal bool IsRoot()
{
- bool ret = Interop.ActorInternal.Actor_IsRoot(swigCPtr);
+ bool ret = Interop.ActorInternal.IsRoot(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
internal bool OnWindow()
{
- bool ret = Interop.Actor.Actor_OnStage(swigCPtr);
+ bool ret = Interop.Actor.OnStage(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal View FindChildById(uint id)
{
//to fix memory leak issue, match the handle count with native side.
- IntPtr cPtr = Interop.Actor.Actor_FindChildById(swigCPtr, id);
+ IntPtr cPtr = Interop.Actor.FindChildById(SwigCPtr, id);
View ret = this.GetInstanceSafely<View>(cPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
return FindChildById(id);
}
- internal void SetParentOrigin(Vector3 origin)
+ internal void SetParentOrigin(Position origin)
{
- Interop.ActorInternal.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
+ Interop.ActorInternal.SetParentOrigin(SwigCPtr, Position.getCPtr(origin));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Vector3 GetCurrentParentOrigin()
+ internal Position GetCurrentParentOrigin()
{
- Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentParentOrigin(swigCPtr), true);
+
+ if(internalCurrentParentOrigin == null)
+ {
+ internalCurrentParentOrigin = new Position(0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.ParentOrigin, internalCurrentParentOrigin.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalCurrentParentOrigin;
}
- internal void SetAnchorPoint(Vector3 anchorPoint)
+ internal void SetAnchorPoint(Position anchorPoint)
{
- Interop.Actor.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
+ Interop.Actor.SetAnchorPoint(SwigCPtr, Position.getCPtr(anchorPoint));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Vector3 GetCurrentAnchorPoint()
+ internal Position GetCurrentAnchorPoint()
{
- Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentAnchorPoint(swigCPtr), true);
+
+ if(internalCurrentAnchorPoint == null)
+ {
+ internalCurrentAnchorPoint = new Position(0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.AnchorPoint, internalCurrentAnchorPoint.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalCurrentAnchorPoint;
}
internal void SetSize(float width, float height)
{
- Interop.ActorInternal.Actor_SetSize__SWIG_0(swigCPtr, width, height);
+ Interop.ActorInternal.SetSize(SwigCPtr, width, height);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void SetSize(float width, float height, float depth)
{
- Interop.ActorInternal.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
+ Interop.ActorInternal.SetSize(SwigCPtr, width, height, depth);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void SetSize(Vector2 size)
{
- Interop.ActorInternal.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
+ Interop.ActorInternal.SetSizeVector2(SwigCPtr, Vector2.getCPtr(size));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void SetSize(Vector3 size)
{
- Interop.ActorInternal.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
+ Interop.ActorInternal.SetSizeVector3(SwigCPtr, Vector3.getCPtr(size));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal Vector3 GetTargetSize()
{
- Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetTargetSize(swigCPtr), true);
+
+ if(internalTargetSize == null)
+ {
+ internalTargetSize = new Vector3(0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveTargetSize(SwigCPtr, internalTargetSize.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalTargetSize;
}
internal Size2D GetCurrentSize()
{
- Size ret = new Size(Interop.Actor.Actor_GetCurrentSize(swigCPtr), true);
+
+ if(internalCurrentSize == null)
+ {
+ internalCurrentSize = new Size2D(0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector2ActualVector3(SwigCPtr, Property.SIZE, internalCurrentSize.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- Size2D size = new Size2D((int)ret.Width, (int)ret.Height);
- ret.Dispose();
- return size;
+ }
+ return internalCurrentSize;
}
internal Size2D GetCurrentSizeFloat()
{
- Size ret = new Size(Interop.Actor.Actor_GetCurrentSize(swigCPtr), true);
+ Size ret = new Size(Interop.Actor.GetCurrentSize(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal Vector3 GetNaturalSize()
+ /// <summary>
+ /// GetNaturalSize() function behaviour can be changed for each subclass of View.
+ /// So we make GetNaturalSize() function virtual, and make subclass can define it's owned logic
+ /// </summary>
+ internal virtual Vector3 GetNaturalSize()
{
- Vector3 ret = new Vector3(Interop.Actor.Actor_GetNaturalSize(swigCPtr), true);
+ Vector3 ret = new Vector3(Interop.Actor.GetNaturalSize(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal void SetPosition(float x, float y)
+ internal void SetX(float x)
{
- Interop.ActorInternal.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
+ Interop.ActorInternal.SetX(SwigCPtr, x);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetPosition(float x, float y, float z)
+ internal void SetY(float y)
{
- Interop.ActorInternal.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
+ Interop.ActorInternal.SetY(SwigCPtr, y);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetPosition(Vector3 position)
+ internal void SetZ(float z)
{
- Interop.ActorInternal.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
+ Interop.ActorInternal.SetZ(SwigCPtr, z);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetX(float x)
+ internal void TranslateBy(Vector3 distance)
{
- Interop.ActorInternal.Actor_SetX(swigCPtr, x);
+ Interop.ActorInternal.TranslateBy(SwigCPtr, Vector3.getCPtr(distance));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetY(float y)
+ internal Position GetCurrentPosition()
{
- Interop.ActorInternal.Actor_SetY(swigCPtr, y);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
- internal void SetZ(float z)
- {
- Interop.ActorInternal.Actor_SetZ(swigCPtr, z);
+ if(internalCurrentPosition == null)
+ {
+ internalCurrentPosition = new Position(0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, Property.POSITION, internalCurrentPosition.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ return internalCurrentPosition;
}
-
- internal void TranslateBy(Vector3 distance)
+ internal Vector3 GetCurrentWorldPosition()
{
- Interop.ActorInternal.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
+
+ if(internalCurrentWorldPosition == null)
+ {
+ internalCurrentWorldPosition = new Vector3(0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.WorldPosition, internalCurrentWorldPosition.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ return internalCurrentWorldPosition;
}
- internal Position GetCurrentPosition()
+ internal Vector2 GetCurrentScreenPosition()
{
- Position ret = new Position(Interop.Actor.Actor_GetCurrentPosition(swigCPtr), true);
+
+ if(internalCurrentScreenPosition == null)
+ {
+ internalCurrentScreenPosition = new Vector2(0, 0);
+ }
+
+ Object.InternalRetrievingPropertyVector2(SwigCPtr, View.Property.ScreenPosition, internalCurrentScreenPosition.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalCurrentScreenPosition;
}
- internal Vector3 GetCurrentWorldPosition()
+ internal Vector4 GetCurrentScreenPositionSize()
{
- Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentWorldPosition(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ Vector4 ret = new Vector4(Interop.Actor.CurrentScreenExtents(SwigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
return ret;
}
internal void SetInheritPosition(bool inherit)
{
- Interop.ActorInternal.Actor_SetInheritPosition(swigCPtr, inherit);
+ Interop.ActorInternal.SetInheritPosition(SwigCPtr, inherit);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal bool IsPositionInherited()
{
- bool ret = Interop.ActorInternal.Actor_IsPositionInherited(swigCPtr);
+ bool ret = Interop.ActorInternal.IsPositionInherited(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetOrientation(Degree angle, Vector3 axis)
{
- Interop.ActorInternal.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
+ Interop.ActorInternal.SetOrientationDegree(SwigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void SetOrientation(Radian angle, Vector3 axis)
{
- Interop.ActorInternal.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
+ Interop.ActorInternal.SetOrientationRadian(SwigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void SetOrientation(Rotation orientation)
{
- Interop.ActorInternal.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
+ Interop.ActorInternal.SetOrientationQuaternion(SwigCPtr, Rotation.getCPtr(orientation));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal Rotation GetCurrentOrientation()
{
- Rotation ret = new Rotation(Interop.ActorInternal.Actor_GetCurrentOrientation(swigCPtr), true);
+ Rotation ret = new Rotation(Interop.ActorInternal.GetCurrentOrientation(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetInheritOrientation(bool inherit)
{
- Interop.ActorInternal.Actor_SetInheritOrientation(swigCPtr, inherit);
+ Interop.ActorInternal.SetInheritOrientation(SwigCPtr, inherit);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal bool IsOrientationInherited()
{
- bool ret = Interop.ActorInternal.Actor_IsOrientationInherited(swigCPtr);
+ bool ret = Interop.ActorInternal.IsOrientationInherited(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal Rotation GetCurrentWorldOrientation()
{
- Rotation ret = new Rotation(Interop.ActorInternal.Actor_GetCurrentWorldOrientation(swigCPtr), true);
+ Rotation ret = new Rotation(Interop.ActorInternal.GetCurrentWorldOrientation(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetScale(float scale)
{
- Interop.ActorInternal.Actor_SetScale__SWIG_0(swigCPtr, scale);
+ Interop.ActorInternal.SetScale(SwigCPtr, scale);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void SetScale(float scaleX, float scaleY, float scaleZ)
{
- Interop.ActorInternal.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
+ Interop.ActorInternal.SetScale(SwigCPtr, scaleX, scaleY, scaleZ);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void SetScale(Vector3 scale)
{
- Interop.ActorInternal.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
+ Interop.ActorInternal.SetScale(SwigCPtr, Vector3.getCPtr(scale));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal Vector3 GetCurrentScale()
{
- Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentScale(swigCPtr), true);
+
+ if(internalCurrentScale == null)
+ {
+ internalCurrentScale = new Vector3(0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.SCALE, internalCurrentScale.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalCurrentScale;
}
internal Vector3 GetCurrentWorldScale()
{
- Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentWorldScale(swigCPtr), true);
+
+ if(internalCurrentWorldScale == null)
+ {
+ internalCurrentWorldScale = new Vector3(0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.WorldScale, internalCurrentWorldScale.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalCurrentWorldScale;
}
internal void SetInheritScale(bool inherit)
{
- Interop.ActorInternal.Actor_SetInheritScale(swigCPtr, inherit);
+ Interop.ActorInternal.SetInheritScale(SwigCPtr, inherit);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal bool IsScaleInherited()
{
- bool ret = Interop.ActorInternal.Actor_IsScaleInherited(swigCPtr);
+ bool ret = Interop.ActorInternal.IsScaleInherited(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal Matrix GetCurrentWorldMatrix()
{
- Matrix ret = new Matrix(Interop.ActorInternal.Actor_GetCurrentWorldMatrix(swigCPtr), true);
+ Matrix ret = new Matrix(Interop.ActorInternal.GetCurrentWorldMatrix(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetVisible(bool visible)
{
- Interop.Actor.Actor_SetVisible(swigCPtr, visible);
+ Interop.Actor.SetVisible(SwigCPtr, visible);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieve the View's current Visibility.
+ /// </summary>
+ /// <remarks>
+ /// The <see cref="Visibility"/> property is set in the main thread, so it is not updated in real time when the value is changed in the render thread.
+ /// However, this method can get the current actual value updated in real time.
+ /// </remarks>
internal bool IsVisible()
{
- bool ret = Interop.ActorInternal.Actor_IsVisible(swigCPtr);
+ bool ret = Interop.ActorInternal.IsVisible(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetOpacity(float opacity)
{
- Interop.ActorInternal.Actor_SetOpacity(swigCPtr, opacity);
+ Interop.ActorInternal.SetOpacity(SwigCPtr, opacity);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal float GetCurrentOpacity()
{
- float ret = Interop.ActorInternal.Actor_GetCurrentOpacity(swigCPtr);
+ float ret = Interop.ActorInternal.GetCurrentOpacity(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal void SetColor(Vector4 color)
- {
- Interop.ActorInternal.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
- if (NDalicPINVOKE.SWIGPendingException.Pending)
- throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
internal Vector4 GetCurrentColor()
{
- Vector4 ret = new Vector4(Interop.ActorInternal.Actor_GetCurrentColor(swigCPtr), true);
+
+ if(internalCurrentColor == null)
+ {
+ internalCurrentColor = new Vector4(0, 0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector4(SwigCPtr, Interop.ActorProperty.ColorGet(), internalCurrentColor.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalCurrentColor;
}
internal ColorMode GetColorMode()
{
- ColorMode ret = (ColorMode)Interop.ActorInternal.Actor_GetColorMode(swigCPtr);
+ ColorMode ret = (ColorMode)Interop.ActorInternal.GetColorMode(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal Vector4 GetCurrentWorldColor()
{
- Vector4 ret = new Vector4(Interop.ActorInternal.Actor_GetCurrentWorldColor(swigCPtr), true);
+
+ if(internalCurrentWorldColor == null)
+ {
+ internalCurrentWorldColor = new Vector4(0, 0, 0, 0);
+ }
+
+ Interop.ActorInternal.RetrieveCurrentPropertyVector4(SwigCPtr, Property.WorldColor, internalCurrentWorldColor.SwigCPtr);
+
if (NDalicPINVOKE.SWIGPendingException.Pending)
+ {
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+ return internalCurrentWorldColor;
}
internal void SetDrawMode(DrawModeType drawMode)
{
- Interop.ActorInternal.Actor_SetDrawMode(swigCPtr, (int)drawMode);
+ Interop.ActorInternal.SetDrawMode(SwigCPtr, (int)drawMode);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal DrawModeType GetDrawMode()
{
- DrawModeType ret = (DrawModeType)Interop.ActorInternal.Actor_GetDrawMode(swigCPtr);
+ DrawModeType ret = (DrawModeType)Interop.ActorInternal.GetDrawMode(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal void SetKeyboardFocusable(bool focusable)
{
- Interop.ActorInternal.Actor_SetKeyboardFocusable(swigCPtr, focusable);
+ Interop.ActorInternal.SetKeyboardFocusable(SwigCPtr, focusable);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal bool IsKeyboardFocusable()
{
- bool ret = Interop.ActorInternal.Actor_IsKeyboardFocusable(swigCPtr);
+ bool ret = Interop.ActorInternal.IsKeyboardFocusable(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
+ internal void SetKeyboardFocusableChildren(bool focusable)
{
- Interop.Actor.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
+ Interop.ActorInternal.SetKeyboardFocusableChildren(SwigCPtr, focusable);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal ResizePolicyType GetResizePolicy(DimensionType dimension)
+ internal bool AreChildrenKeyBoardFocusable()
{
- ResizePolicyType ret = (ResizePolicyType)Interop.Actor.Actor_GetResizePolicy(swigCPtr, (int)dimension);
+ bool ret = Interop.ActorInternal.AreChildrenKeyBoardFocusable(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal Vector3 GetSizeModeFactor()
+ internal void SetFocusableInTouch(bool enabled)
+ {
+ Interop.ActorInternal.SetFocusableInTouch(SwigCPtr, enabled);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal bool IsFocusableInTouch()
{
- Vector3 ret = new Vector3(Interop.Actor.Actor_GetSizeModeFactor(swigCPtr), true);
+ bool ret = Interop.ActorInternal.IsFocusableInTouch(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal void SetMinimumSize(Vector2 size)
+ internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
{
- Interop.ActorInternal.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
+ Interop.Actor.SetResizePolicy(SwigCPtr, (int)policy, (int)dimension);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Vector2 GetMinimumSize()
+ internal ResizePolicyType GetResizePolicy(DimensionType dimension)
{
- Vector2 ret = new Vector2(Interop.ActorInternal.Actor_GetMinimumSize(swigCPtr), true);
+ ResizePolicyType ret = (ResizePolicyType)Interop.Actor.GetResizePolicy(SwigCPtr, (int)dimension);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal void SetMaximumSize(Vector2 size)
+ internal Vector3 GetSizeModeFactor()
{
- Interop.ActorInternal.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
+
+ if (internalSizeModeFactor == null)
+ {
+ internalSizeModeFactor = new Vector3(OnSizeModeFactorChanged, 0, 0, 0);
+ }
+ Object.InternalRetrievingPropertyVector3(SwigCPtr, View.Property.SizeModeFactor, internalSizeModeFactor.SwigCPtr);
+ return internalSizeModeFactor;
+ }
+
+ internal void SetMinimumSize(Vector2 size)
+ {
+ Interop.ActorInternal.SetMinimumSize(SwigCPtr, Vector2.getCPtr(size));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Vector2 GetMaximumSize()
+ internal Vector2 GetMinimumSize()
{
- Vector2 ret = new Vector2(Interop.ActorInternal.Actor_GetMaximumSize(swigCPtr), true);
+
+ if (internalMinimumSize == null)
+ {
+ internalMinimumSize = new Size2D(OnMinimumSizeChanged, 0, 0);
+ }
+ Object.InternalRetrievingPropertyVector2(SwigCPtr, View.Property.MinimumSize, internalMinimumSize.SwigCPtr);
+ return internalMinimumSize;
+ }
+
+ internal void SetMaximumSize(Vector2 size)
+ {
+ Interop.ActorInternal.SetMaximumSize(SwigCPtr, Vector2.getCPtr(size));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
+ }
+
+ internal Vector2 GetMaximumSize()
+ {
+
+ if (internalMaximumSize == null)
+ {
+ internalMaximumSize = new Size2D(OnMaximumSizeChanged, 0, 0);
+ }
+ Object.InternalRetrievingPropertyVector2(SwigCPtr, View.Property.MaximumSize, internalMaximumSize.SwigCPtr);
+ return internalMaximumSize;
}
internal int GetHierarchyDepth()
{
- int ret = Interop.Actor.Actor_GetHierarchyDepth(swigCPtr);
+ int ret = Interop.Actor.GetHierarchyDepth(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal uint GetRendererCount()
{
- uint ret = Interop.Actor.Actor_GetRendererCount(swigCPtr);
+ uint ret = Interop.Actor.GetRendererCount(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
{
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
}
internal bool IsTopLevelView()
return false;
}
+ /// <summary>
+ /// Check whether Current view don't has BackgroundVisual or not.
+ /// Some API (like Animation, Borderline) required non-empty backgrounds.
+ /// </summary>
+ internal bool IsBackgroundEmpty()
+ {
+ int visualType = (int)Visual.Type.Invalid;
+ Interop.View.InternalRetrievingVisualPropertyInt(this.SwigCPtr, Property.BACKGROUND, Visual.Property.Type, out visualType);
+ return visualType == (int)Visual.Type.Invalid;
+ }
+
+ /// <summary>
+ /// Check whether Current view don't has ShadowVisual or not.
+ /// </summary>
+ internal bool IsShadowEmpty()
+ {
+ int visualType = (int)Visual.Type.Invalid;
+ Interop.View.InternalRetrievingVisualPropertyInt(this.SwigCPtr, Property.SHADOW, Visual.Property.Type, out visualType);
+ return visualType == (int)Visual.Type.Invalid;
+ }
+
internal void SetKeyInputFocus()
{
- Interop.ViewInternal.View_SetKeyInputFocus(swigCPtr);
+ Interop.ViewInternal.SetKeyInputFocus(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal void ClearKeyInputFocus()
{
- Interop.ViewInternal.View_ClearKeyInputFocus(swigCPtr);
+ Interop.ViewInternal.ClearKeyInputFocus(SwigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal PinchGestureDetector GetPinchGestureDetector()
{
- PinchGestureDetector ret = new PinchGestureDetector(Interop.ViewInternal.View_GetPinchGestureDetector(swigCPtr), true);
+ PinchGestureDetector ret = new PinchGestureDetector(Interop.ViewInternal.GetPinchGestureDetector(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
internal PanGestureDetector GetPanGestureDetector()
{
- PanGestureDetector ret = new PanGestureDetector(Interop.ViewInternal.View_GetPanGestureDetector(swigCPtr), true);
+ PanGestureDetector ret = new PanGestureDetector(Interop.ViewInternal.GetPanGestureDetector(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
internal TapGestureDetector GetTapGestureDetector()
{
- TapGestureDetector ret = new TapGestureDetector(Interop.ViewInternal.View_GetTapGestureDetector(swigCPtr), true);
+ TapGestureDetector ret = new TapGestureDetector(Interop.ViewInternal.GetTapGestureDetector(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
internal LongPressGestureDetector GetLongPressGestureDetector()
{
- LongPressGestureDetector ret = new LongPressGestureDetector(Interop.ViewInternal.View_GetLongPressGestureDetector(swigCPtr), true);
+ LongPressGestureDetector ret = new LongPressGestureDetector(Interop.ViewInternal.GetLongPressGestureDetector(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
internal IntPtr GetPtrfromView()
{
- return (IntPtr)swigCPtr;
+ return (IntPtr)SwigCPtr;
}
internal void RemoveChild(View child)
{
+ // If the view had focus, it clears focus.
+ if (child == FocusManager.Instance.GetCurrentFocusView())
+ {
+ Tizen.Log.Debug("NUI", $"ClearFocus due to View id:({child.ID}) removed from scene\n");
+ FocusManager.Instance.ClearFocus();
+ }
// Do actual child removal
- Interop.Actor.Actor_Remove(swigCPtr, View.getCPtr(child));
+ Interop.Actor.Remove(SwigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending)
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
Children.Remove(child);
child.InternalParent = null;
+ LayoutCount -= child.LayoutCount;
+ OnChildRemoved(child);
if (ChildRemoved != null)
{
ChildRemovedEventArgs e = new ChildRemovedEventArgs
/// </summary>
internal void ResetLayout()
{
- _layout = null;
+ LayoutCount--;
+
+ layout = null;
}
internal ResourceLoadingStatusType GetBackgroundResourceStatus()
{
- return (ResourceLoadingStatusType)Interop.View.View_GetVisualResourceStatus(this.swigCPtr, Property.BACKGROUND);
+ return (ResourceLoadingStatusType)Interop.View.GetVisualResourceStatus(this.SwigCPtr, Property.BACKGROUND);
+ }
+
+ /// <summary>
+ /// Lazy call to UpdateBackgroundExtraData.
+ /// Collect Properties need to be update, and set properties that starts the Processing.
+ /// </summary>
+ internal virtual void UpdateBackgroundExtraData(BackgroundExtraDataUpdatedFlag flag)
+ {
+ if (backgroundExtraData == null)
+ {
+ return;
+ }
+
+ if (!backgroundExtraDataUpdatedFlag.HasFlag(flag))
+ {
+ backgroundExtraDataUpdatedFlag |= flag;
+ // TODO : Re-open this API when we resolve Animation issue.
+ // Instead, let we call UpdateBackgroundExtraData() synchronously.
+ UpdateBackgroundExtraData();
+ // if (!backgroundExtraDataUpdateProcessAttachedFlag)
+ // {
+ // backgroundExtraDataUpdateProcessAttachedFlag = true;
+ // ProcessorController.Instance.ProcessorOnceEvent += UpdateBackgroundExtraData;
+ // // Call process hardly.
+ // ProcessorController.Instance.Awake();
+ // }
+ }
+ }
+
+ /// <summary>
+ /// Callback function to Lazy UpdateBackgroundExtraData.
+ /// </summary>
+ private void UpdateBackgroundExtraData(object source, EventArgs e)
+ {
+ // Note : To allow event attachment during UpdateBackgroundExtraData, let we make flag as false before call UpdateBackgroundExtraData().
+ backgroundExtraDataUpdateProcessAttachedFlag = false;
+ UpdateBackgroundExtraData();
+ }
+
+ /// <summary>
+ /// Update background extra data properties synchronously.
+ /// After call this API, All background extra data properties updated.
+ /// </summary>
+ internal virtual void UpdateBackgroundExtraData()
+ {
+ if (backgroundExtraData == null)
+ {
+ return;
+ }
+
+ if (IsShadowEmpty())
+ {
+ backgroundExtraDataUpdatedFlag &= ~BackgroundExtraDataUpdatedFlag.Shadow;
+ }
+ if (!Rectangle.IsNullOrZero(backgroundExtraData.BackgroundImageBorder))
+ {
+ backgroundExtraDataUpdatedFlag &= ~BackgroundExtraDataUpdatedFlag.Background;
+ }
+
+ if (backgroundExtraDataUpdatedFlag == BackgroundExtraDataUpdatedFlag.None)
+ {
+ return;
+ }
+
+ if ((backgroundExtraDataUpdatedFlag & BackgroundExtraDataUpdatedFlag.Borderline) != BackgroundExtraDataUpdatedFlag.None)
+ {
+ ApplyBorderline();
+ }
+ if ((backgroundExtraDataUpdatedFlag & BackgroundExtraDataUpdatedFlag.CornerRadius) != BackgroundExtraDataUpdatedFlag.None)
+ {
+ ApplyCornerRadius();
+ }
+ backgroundExtraDataUpdatedFlag = BackgroundExtraDataUpdatedFlag.None;
+ }
+
+ /// TODO open as a protected level
+ internal virtual void ApplyCornerRadius()
+ {
+ if (backgroundExtraData == null) return;
+
+ // Update corner radius properties to background and shadow by ActionUpdateProperty
+ if (backgroundExtraDataUpdatedFlag.HasFlag(BackgroundExtraDataUpdatedFlag.BackgroundCornerRadius))
+ {
+ if (backgroundExtraData.CornerRadius != null)
+ {
+ Interop.View.InternalUpdateVisualPropertyVector4(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.CornerRadius, Vector4.getCPtr(backgroundExtraData.CornerRadius));
+ }
+ Interop.View.InternalUpdateVisualPropertyInt(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.CornerRadiusPolicy, (int)backgroundExtraData.CornerRadiusPolicy);
+ }
+ if (backgroundExtraDataUpdatedFlag.HasFlag(BackgroundExtraDataUpdatedFlag.ShadowCornerRadius))
+ {
+ if (backgroundExtraData.CornerRadius != null)
+ {
+ Interop.View.InternalUpdateVisualPropertyVector4(this.SwigCPtr, View.Property.SHADOW, Visual.Property.CornerRadius, Vector4.getCPtr(backgroundExtraData.CornerRadius));
+ }
+ Interop.View.InternalUpdateVisualPropertyInt(this.SwigCPtr, View.Property.SHADOW, Visual.Property.CornerRadiusPolicy, (int)backgroundExtraData.CornerRadiusPolicy);
+ }
}
- internal virtual void UpdateCornerRadius(float value)
+ /// TODO open as a protected level
+ internal virtual void ApplyBorderline()
{
- if (value != 0)
+ if (backgroundExtraData == null) return;
+
+ // ActionUpdateProperty works well only if BACKGROUND visual setup before.
+ // If view don't have BACKGROUND visual, we set transparent background color in default.
+ if (IsBackgroundEmpty())
{
- (backgroundExtraData ?? (backgroundExtraData = new BackgroundExtraData())).CornerRadius = value;
+ // BACKGROUND visual doesn't exist.
+ SetBackgroundColor(Color.Transparent);
+ // SetBackgroundColor function apply borderline internally.
+ // So we can just return now.
+ return;
}
- Tizen.NUI.PropertyMap backgroundMap = new Tizen.NUI.PropertyMap();
- PropertyValue background = Tizen.NUI.Object.GetProperty(swigCPtr, View.Property.BACKGROUND);
- background?.Get(backgroundMap);
+ // Update borderline properties to background by ActionUpdateProperty
+ if (backgroundExtraDataUpdatedFlag.HasFlag(BackgroundExtraDataUpdatedFlag.BackgroundBorderline))
+ {
+ Interop.View.InternalUpdateVisualPropertyFloat(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.BorderlineWidth, backgroundExtraData.BorderlineWidth);
+ Interop.View.InternalUpdateVisualPropertyVector4(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.BorderlineColor, Vector4.getCPtr(backgroundExtraData.BorderlineColor ?? Color.Black));
+ Interop.View.InternalUpdateVisualPropertyFloat(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.BorderlineOffset, backgroundExtraData.BorderlineOffset);
+ }
+ }
- if (!backgroundMap.Empty())
+ /// <summary>
+ /// Get selector value from the triggerable selector or related property.
+ /// </summary>
+ internal Selector<T> GetSelector<T>(TriggerableSelector<T> triggerableSelector, NUI.Binding.BindableProperty relatedProperty)
+ {
+ var selector = triggerableSelector?.Get();
+ if (selector != null)
{
- backgroundMap[Visual.Property.CornerRadius] = new PropertyValue(value);
- PropertyValue setValue = new Tizen.NUI.PropertyValue(backgroundMap);
- Tizen.NUI.Object.SetProperty(swigCPtr, View.Property.BACKGROUND, setValue);
- setValue?.Dispose();
+ return selector;
}
- UpdateShadowCornerRadius(value);
- backgroundMap?.Dispose();
- background?.Dispose();
+
+ var value = (T)GetValue(relatedProperty);
+ return value == null ? null : new Selector<T>(value);
}
- internal void UpdateStyle()
+ internal void SetThemeApplied()
{
- ViewStyle newStyle;
- if (styleName == null) newStyle = ThemeManager.GetStyle(GetType());
- else newStyle = ThemeManager.GetStyle(styleName);
+ if (themeData == null) themeData = new ThemeData();
+ themeData.ThemeApplied = true;
- if (newStyle != null && (viewStyle == null || viewStyle.GetType() == newStyle.GetType())) ApplyStyle(newStyle);
+ if (ThemeChangeSensitive && !themeData.ListeningThemeChangeEvent)
+ {
+ themeData.ListeningThemeChangeEvent = true;
+ ThemeManager.ThemeChangedInternal.Add(OnThemeChanged);
+ }
}
/// <summary>
return;
}
+ disposeDebugging(type);
+
+ if (SwigCMemOwn && !IsNativeHandleInvalid())
+ {
+ Interop.ControlDevel.DaliAccessibilityDetachAccessibleObject(SwigCPtr);
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ }
+
//_mergedStyle = null;
+ internalMaximumSize?.Dispose();
+ internalMaximumSize = null;
+ internalMinimumSize?.Dispose();
+ internalMinimumSize = null;
+ internalMargin?.Dispose();
+ internalMargin = null;
+ internalPadding?.Dispose();
+ internalPadding = null;
+ internalSizeModeFactor?.Dispose();
+ internalSizeModeFactor = null;
+ internalCellIndex?.Dispose();
+ internalCellIndex = null;
+ internalBackgroundColor?.Dispose();
+ internalBackgroundColor = null;
+ internalColor?.Dispose();
+ internalColor = null;
+ internalPivotPoint?.Dispose();
+ internalPivotPoint = null;
+ internalPosition?.Dispose();
+ internalPosition = null;
+ internalPosition2D?.Dispose();
+ internalPosition2D = null;
+ internalScale?.Dispose();
+ internalScale = null;
+ internalSize?.Dispose();
+ internalSize = null;
+ internalSize2D?.Dispose();
+ internalSize2D = null;
+
+ panGestureDetector?.Dispose();
+ panGestureDetector = null;
+ longGestureDetector?.Dispose();
+ longGestureDetector = null;
+ pinchGestureDetector?.Dispose();
+ pinchGestureDetector = null;
+ tapGestureDetector?.Dispose();
+ tapGestureDetector = null;
+ rotationGestureDetector?.Dispose();
+ rotationGestureDetector = null;
+
+ internalCurrentParentOrigin?.Dispose();
+ internalCurrentParentOrigin = null;
+ internalCurrentAnchorPoint?.Dispose();
+ internalCurrentAnchorPoint = null;
+ internalTargetSize?.Dispose();
+ internalTargetSize = null;
+ internalCurrentSize?.Dispose();
+ internalCurrentSize = null;
+ internalCurrentPosition?.Dispose();
+ internalCurrentPosition = null;
+ internalCurrentWorldPosition?.Dispose();
+ internalCurrentWorldPosition = null;
+ internalCurrentScale?.Dispose();
+ internalCurrentScale = null;
+ internalCurrentWorldScale?.Dispose();
+ internalCurrentWorldScale = null;
+ internalCurrentColor?.Dispose();
+ internalCurrentColor = null;
+ internalCurrentWorldColor?.Dispose();
+ internalCurrentWorldColor = null;
+ internalSizeModeFactor?.Dispose();
+ internalSizeModeFactor = null;
+ internalCurrentScreenPosition?.Dispose();
+ internalCurrentScreenPosition = null;
+
if (type == DisposeTypes.Explicit)
{
//Called by User
//Release your own managed resources here.
//You should release all of your own disposable objects here.
- selectorData?.Reset(this);
- if (themeChangeSensitive)
+ if (themeData != null)
+ {
+ themeData.selectorData?.Reset(this);
+ if (themeData.ListeningThemeChangeEvent)
+ {
+ ThemeManager.ThemeChangedInternal.Remove(OnThemeChanged);
+ }
+ }
+ if (widthConstraint != null)
{
- ThemeManager.ThemeChanged -= OnThemeChanged;
+ widthConstraint.Remove();
+ widthConstraint.Dispose();
+ }
+ if (heightConstraint != null)
+ {
+ heightConstraint.Remove();
+ heightConstraint.Dispose();
}
}
//Release your own unmanaged resources here.
//You should not access any managed member here except static instance.
//because the execution order of Finalizes is non-deterministic.
- if (this != null)
- {
- DisConnectFromSignals();
- }
+
+ DisConnectFromSignals();
foreach (View view in Children)
{
view.InternalParent = null;
}
+ backgroundExtraDataUpdatedFlag = BackgroundExtraDataUpdatedFlag.None;
+ if (backgroundExtraDataUpdateProcessAttachedFlag)
+ {
+ ProcessorController.Instance.ProcessorOnceEvent -= UpdateBackgroundExtraData;
+ backgroundExtraDataUpdateProcessAttachedFlag = false;
+ }
+
+ LayoutCount = 0;
+
+ NUILog.Debug($"[Dispose] View.Dispose({type}) END");
+ NUILog.Debug($"=============================");
+
base.Dispose(type);
+
+ aliveCount--;
}
/// This will not be public opened.
[EditorBrowsable(EditorBrowsableState.Never)]
protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
{
- Interop.View.delete_View(swigCPtr);
+ Interop.View.DeleteView(swigCPtr);
}
/// <summary>
/// The touch event handler for ControlState.
/// Please change ControlState value by touch state if needed.
/// </summary>
+ /// <exception cref="ArgumentNullException"> Thrown when touch is null. </exception>
[EditorBrowsable(EditorBrowsableState.Never)]
protected virtual bool HandleControlStateOnTouch(Touch touch)
{
- switch(touch.GetState(0))
+ if (touch == null)
+ {
+ throw new global::System.ArgumentNullException(nameof(touch));
+ }
+
+ switch (touch.GetState(0))
{
case PointStateType.Down:
ControlState += ControlState.Pressed;
default:
break;
}
-
return false;
}
+ /// <summary>
+ /// Internal callback of enabled property changes.
+ /// Inherited view can override this method to implements enabled property changes.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ protected virtual void OnEnabled(bool enabled)
+ {
+ if (enabled)
+ {
+ if (State == View.States.Disabled)
+ {
+ State = View.States.Normal;
+ }
+ if (enableControlState)
+ {
+ ControlState -= ControlState.Disabled;
+ }
+ }
+ else
+ {
+ State = View.States.Disabled;
+ if (enableControlState)
+ {
+ ControlState += ControlState.Disabled;
+ }
+ }
+ }
+
+
private void DisConnectFromSignals()
{
- // Save current CPtr.
- global::System.Runtime.InteropServices.HandleRef currentCPtr = swigCPtr;
+ if (HasBody() == false)
+ {
+ NUILog.Debug($"[Dispose] DisConnectFromSignals() No native body! No need to Disconnect Signals!");
+ return;
+ }
+ NUILog.Debug($"[Dispose] DisConnectFromSignals START");
+ NUILog.Debug($"[Dispose] View.DisConnectFromSignals() type:{GetType()} copyNativeHandle:{GetBaseHandleCPtrHandleRef.Handle.ToString("X8")}");
+ NUILog.Debug($"[Dispose] ID:{Interop.Actor.GetId(GetBaseHandleCPtrHandleRef)} Name:{Interop.Actor.GetName(GetBaseHandleCPtrHandleRef)}");
+
+ if (onRelayoutEventCallback != null)
+ {
+ NUILog.Debug($"[Dispose] onRelayoutEventCallback");
+
+ Interop.ActorSignal.OnRelayoutDisconnect(GetBaseHandleCPtrHandleRef, onRelayoutEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ onRelayoutEventCallback = null;
+ }
+
+ if (offWindowEventCallback != null)
+ {
+ NUILog.Debug($"[Dispose] offWindowEventCallback");
- // Use BaseHandle CPtr as current might have been deleted already in derived classes.
- swigCPtr = GetBaseHandleCPtrHandleRef;
+ Interop.ActorSignal.OffSceneDisconnect(GetBaseHandleCPtrHandleRef, offWindowEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ offWindowEventCallback = null;
+ }
- if (_onRelayoutEventCallback != null)
+ if (onWindowEventCallback != null)
{
- ViewSignal signal = this.OnRelayoutSignal();
- signal?.Disconnect(_onRelayoutEventCallback);
- signal?.Dispose();
- _onRelayoutEventCallback = null;
+ NUILog.Debug($"[Dispose] onWindowEventCallback");
+
+ Interop.ActorSignal.OnSceneDisconnect(GetBaseHandleCPtrHandleRef, onWindowEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ onWindowEventCallback = null;
}
- if (_offWindowEventCallback != null)
+ if (interceptWheelCallback != null)
{
- ViewSignal signal = this.OffWindowSignal();
- signal?.Disconnect(_offWindowEventCallback);
- signal?.Dispose();
- _offWindowEventCallback = null;
+ NUILog.Debug($"[Dispose] interceptWheelCallback");
+
+ Interop.ActorSignal.InterceptWheelDisconnect(GetBaseHandleCPtrHandleRef, interceptWheelCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ interceptWheelCallback = null;
}
- if (_onWindowEventCallback != null)
+ if (wheelEventCallback != null)
{
- ViewSignal signal = this.OnWindowSignal();
- signal?.Disconnect(_onWindowEventCallback);
- signal?.Dispose();
- _onWindowEventCallback = null;
+ NUILog.Debug($"[Dispose] wheelEventCallback");
+
+ Interop.ActorSignal.WheelEventDisconnect(GetBaseHandleCPtrHandleRef, wheelEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ wheelEventCallback = null;
}
- if (_wheelEventCallback != null)
+ if (hoverEventCallback != null)
{
- WheelSignal signal = this.WheelEventSignal();
- signal?.Disconnect(_wheelEventCallback);
- signal?.Dispose();
+ NUILog.Debug($"[Dispose] hoverEventCallback");
+
+ Interop.ActorSignal.HoveredDisconnect(GetBaseHandleCPtrHandleRef, hoverEventCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ hoverEventCallback = null;
}
- if (WindowWheelEventHandler != null)
+ if (hitTestResultDataCallback != null)
{
- NUIApplication.GetDefaultWindow().WheelEvent -= OnWindowWheelEvent;
+ NUILog.Debug($"[Dispose] hitTestResultDataCallback");
+
+ Interop.ActorSignal.HitTestResultDisconnect(GetBaseHandleCPtrHandleRef, hitTestResultDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ hitTestResultDataCallback = null;
}
- if (_hoverEventCallback != null)
+
+ if (interceptTouchDataCallback != null)
{
- HoverSignal signal = this.HoveredSignal();
- signal?.Disconnect(_hoverEventCallback);
- signal?.Dispose();
+ NUILog.Debug($"[Dispose] interceptTouchDataCallback");
+
+ Interop.ActorSignal.InterceptTouchDisconnect(GetBaseHandleCPtrHandleRef, interceptTouchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ interceptTouchDataCallback = null;
}
- if (_interceptTouchDataCallback != null)
+ if (touchDataCallback != null)
{
- TouchDataSignal signal = this.InterceptTouchSignal();
- signal?.Disconnect(_interceptTouchDataCallback);
- signal?.Dispose();
+ NUILog.Debug($"[Dispose] touchDataCallback");
+
+ Interop.ActorSignal.TouchDisconnect(GetBaseHandleCPtrHandleRef, touchDataCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ touchDataCallback = null;
}
- if (_touchDataCallback != null)
+ if (resourcesLoadedCallback != null)
{
- TouchDataSignal signal = this.TouchSignal();
- signal?.Disconnect(_touchDataCallback);
- signal?.Dispose();
+ NUILog.Debug($"[Dispose] ResourcesLoadedCallback");
+
+ Interop.ViewSignal.ResourceReadyDisconnect(GetBaseHandleCPtrHandleRef, resourcesLoadedCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ resourcesLoadedCallback = null;
}
- if (_ResourcesLoadedCallback != null)
+ if (keyCallback != null)
{
- ViewSignal signal = this.ResourcesLoadedSignal();
- signal?.Disconnect(_ResourcesLoadedCallback);
- signal?.Dispose();
- _ResourcesLoadedCallback = null;
+ NUILog.Debug($"[Dispose] keyCallback");
+
+ Interop.ViewSignal.KeyEventDisconnect(GetBaseHandleCPtrHandleRef, keyCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ keyCallback = null;
}
- if (_keyCallback != null)
+ if (keyInputFocusLostCallback != null)
{
- ControlKeySignal signal = this.KeyEventSignal();
- signal?.Disconnect(_keyCallback);
- signal?.Dispose();
+ NUILog.Debug($"[Dispose] keyInputFocusLostCallback");
+
+ Interop.ViewSignal.KeyInputFocusLostDisconnect(GetBaseHandleCPtrHandleRef, keyInputFocusLostCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ keyInputFocusLostCallback = null;
+ keyInputFocusLostEventHandler = null;
}
- if (_keyInputFocusLostCallback != null)
+ if (keyInputFocusGainedCallback != null)
{
- KeyInputFocusSignal signal = this.KeyInputFocusLostSignal();
- signal?.Disconnect(_keyInputFocusLostCallback);
- signal?.Dispose();
+ NUILog.Debug($"[Dispose] keyInputFocusGainedCallback");
+
+ Interop.ViewSignal.KeyInputFocusGainedDisconnect(GetBaseHandleCPtrHandleRef, keyInputFocusGainedCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ keyInputFocusGainedCallback = null;
+ keyInputFocusGainedEventHandler = null;
}
- if (_keyInputFocusGainedCallback != null)
+ if (backgroundResourceLoadedCallback != null)
{
- KeyInputFocusSignal signal = this.KeyInputFocusGainedSignal();
- signal?.Disconnect(_keyInputFocusGainedCallback);
- signal?.Dispose();
+ NUILog.Debug($"[Dispose] backgroundResourceLoadedCallback");
+
+ Interop.ViewSignal.ResourceReadyDisconnect(GetBaseHandleCPtrHandleRef, backgroundResourceLoadedCallback.ToHandleRef(this));
+ NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+ backgroundResourceLoadedCallback = null;
}
- if (_backgroundResourceLoadedCallback != null)
+ NDalicPINVOKE.ThrowExceptionIfExists();
+ NUILog.Debug($"[Dispose] DisConnectFromSignals END");
+ }
+
+ /// <summary>
+ /// Apply initial style to the view.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ protected virtual void InitializeStyle(ViewStyle style = null)
+ {
+ if (style == null && ThemeManager.InitialThemeDisabled)
{
- ViewSignal signal = this.ResourcesLoadedSignal();
- signal?.Disconnect(_backgroundResourceLoadedCallback);
- signal?.Dispose();
- _backgroundResourceLoadedCallback = null;
+ // Fast return in most TV cases.
+ return;
}
- if (_onWindowSendEventCallback != null)
+ var initialStyle = ThemeManager.GetInitialStyleWithoutClone(GetType());
+ if (style == null)
{
- ViewSignal signal = this.OnWindowSignal();
- signal?.Disconnect(_onWindowSendEventCallback);
- signal?.Dispose();
+ ApplyStyle(initialStyle);
+ }
+ else
+ {
+ var refinedStyle = style;
+ if (style.IncludeDefaultStyle)
+ {
+ refinedStyle = initialStyle?.Merge(style);
+ }
+ ApplyStyle(refinedStyle);
}
- // BaseHandle CPtr is used in Registry and there is danger of deletion if we keep using it here.
- // Restore current CPtr.
- swigCPtr = currentCPtr;
+ // Listen theme change event if needs.
+ if (initialStyle != null)
+ {
+ SetThemeApplied();
+ }
}
private View ConvertIdToView(uint id)
return view;
}
- private void LoadTransitions()
- {
- foreach (string str in transitionNames)
- {
- string resourceName = str + ".xaml";
- Transition trans = null;
-
- string resource = Tizen.Applications.Application.Current.DirectoryInfo.Resource;
-
- string likelyResourcePath = resource + "animation/" + resourceName;
-
- if (File.Exists(likelyResourcePath))
- {
- trans = Xaml.Extensions.LoadObject<Transition>(likelyResourcePath);
- }
- if (trans != null)
- {
- transDictionary.Add(trans.Name, trans);
- }
- }
- }
-
private void OnScaleChanged(float x, float y, float z)
{
Scale = new Vector3(x, y, z);
Margin = new Extents(start, end, top, bottom);
}
- private void OnColorChanged(float r, float g, float b, float a)
- {
- Color = new Color(r, g, b, a);
- }
-
private void OnAnchorPointChanged(float x, float y, float z)
{
AnchorPoint = new Position(x, y, z);
SizeModeFactor = new Vector3(x, y, z);
}
- private void UpdateShadowCornerRadius(float value)
+ private bool EmptyOnTouch(object target, TouchEventArgs args)
{
- // TODO Update corner radius property only whe DALi supports visual property update.
- PropertyMap map = new PropertyMap();
+ return false;
+ }
- PropertyValue shadowVal = Tizen.NUI.Object.GetProperty(swigCPtr, View.Property.SHADOW);
- if (shadowVal.Get(map) && !map.Empty())
- {
- map[Visual.Property.CornerRadius] = new PropertyValue(value);
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ protected virtual bool CheckResourceReady()
+ {
+ return true;
+ }
- PropertyValue setValue = new PropertyValue(map);
- Tizen.NUI.Object.SetProperty(swigCPtr, View.Property.SHADOW, setValue);
- setValue?.Dispose();
- }
- map?.Dispose();
- shadowVal?.Dispose();
+ private ViewSelectorData EnsureSelectorData()
+ {
+ if (themeData == null) themeData = new ThemeData();
+
+ return themeData.selectorData ?? (themeData.selectorData = new ViewSelectorData());
}
- private bool EmptyOnTouch(object target, TouchEventArgs args)
+ [Conditional("NUI_DISPOSE_DEBUG_ON")]
+ private void disposeDebugging(DisposeTypes type)
{
- return false;
+ DebugFileLogging.Instance.WriteLog($"View.Dispose({type}) START");
+ DebugFileLogging.Instance.WriteLog($"type:{GetType()} copyNativeHandle:{GetBaseHandleCPtrHandleRef.Handle.ToString("X8")}");
+ if (HasBody())
+ {
+ DebugFileLogging.Instance.WriteLog($"ID:{Interop.Actor.GetId(GetBaseHandleCPtrHandleRef)} Name:{Interop.Actor.GetName(GetBaseHandleCPtrHandleRef)}");
+ }
+ else
+ {
+ DebugFileLogging.Instance.WriteLog($"has no native body!");
+ }
}
+
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff