// Unity C# reference source

// Copyright (c) Unity Technologies. For terms of use, see

// https://unity3d.com/legal/licenses/Unity_Reference_Only_License

//#define ENABLE_CAPTURE_DEBUG

using System;

using System.Collections.Generic;

using System.Text;

using UnityEngine.Yoga;

using UnityEngine.Experimental.UIElements.StyleEnums;

using UnityEngine.Experimental.UIElements.StyleSheets;

namespace UnityEngine.Experimental.UIElements

{

internal delegate void OnStylesResolved(ICustomStyle styles);

// pseudo states are used for common states of a widget

// they are addressable from CSS via the pseudo state syntax ":selected" for example

// while css class list can solve the same problem, pseudo states are a fast commonly agreed upon path for common cases.

[Flags]

internal enum PseudoStates

{

Active = 1 << 0, // control is currently pressed in the case of a button

Hover = 1 << 1, // mouse is over control, set and removed from dispatcher automatically

Checked = 1 << 3, // usually associated with toggles of some kind to change visible style

Selected = 1 << 4, // selected, used to denote the current selected state and associate a visual style from CSS

Disabled = 1 << 5, // control will not respond to user input

Focus = 1 << 6, // control has the keyboard focus. This is activated deactivated by the dispatcher automatically

}

public enum PickingMode

{

Position, // todo better name

Ignore

}

internal class VisualElementListPool

{

static ObjectPool<List<VisualElement>> pool = new ObjectPool<List<VisualElement>>(20);

public static List<VisualElement> Copy(List<VisualElement> elements)

{

var result = pool.Get();

result.AddRange(elements);

return result;

}

public static List<VisualElement> Get(int initialCapacity = 0)

{

List<VisualElement> result = pool.Get();

if (initialCapacity > 0 && result.Capacity < initialCapacity)

{

result.Capacity = initialCapacity;

}

return result;

}

public static void Release(List<VisualElement> elements)

{

elements.Clear();

pool.Release(elements);

}

}

public partial class VisualElement : Focusable, ITransform

{

public class VisualElementFactory : UxmlFactory<VisualElement, VisualElementUxmlTraits> {}

public class VisualElementUxmlTraits : UxmlTraits

{

UxmlStringAttributeDescription m_Name;

UxmlEnumAttributeDescription<PickingMode> m_PickingMode;

protected UxmlIntAttributeDescription m_FocusIndex;

public VisualElementUxmlTraits()

{

m_Name = new UxmlStringAttributeDescription { name = "name" };

m_PickingMode = new UxmlEnumAttributeDescription<PickingMode> { name = "pickingMode" };

m_FocusIndex = new UxmlIntAttributeDescription { name = "focusIndex", defaultValue = VisualElement.defaultFocusIndex };

}

public override IEnumerable<UxmlAttributeDescription> uxmlAttributesDescription

{

get

{

foreach (var attr in base.uxmlAttributesDescription)

{

yield return attr;

}

yield return m_Name;

yield return m_PickingMode;

yield return m_FocusIndex;

}

}

public override IEnumerable<UxmlChildElementDescription> uxmlChildElementsDescription

{

get { yield return new UxmlChildElementDescription(typeof(VisualElement)); }

}

public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)

{

base.Init(ve, bag, cc);

ve.name = m_Name.GetValueFromBag(bag);

ve.pickingMode = m_PickingMode.GetValueFromBag(bag);

ve.focusIndex = m_FocusIndex.GetValueFromBag(bag);

}

}

public static readonly int defaultFocusIndex = -1;

private static uint s_NextId;

string m_Name;

HashSet<string> m_ClassList;

string m_TypeName;

string m_FullTypeName;

// Used for view data persistence, like expanded states.

private string m_PersistenceKey;

public string persistenceKey

{

get { return m_PersistenceKey; }

set

{

if (m_PersistenceKey != value)

{

m_PersistenceKey = value;

if (!string.IsNullOrEmpty(value))

Dirty(ChangeType.PersistentData);

}

}

}

// It seems worse to have unwanted/unpredictable persistence

// than to expect it and not have it. This internal check, set

// by Panel.ValidatePersistentDataOnSubTree() controls whether

// persistency is enabled or not. Persistence will be disabled

// on any VisualElement that does not have a persistenceKey, but

// it will also be disabled if any of its parents does not have

// a persistenceKey.

internal bool enablePersistence { get; private set; }

public object userData { get; set; }

public override bool canGrabFocus { get { return visible && enabledInHierarchy && base.canGrabFocus; } }

public override FocusController focusController

{

get { return panel == null ? null : panel.focusController; }

}

private RenderData m_RenderData;

internal RenderData renderData

{

get { return m_RenderData ?? (m_RenderData = new RenderData()); }

}

Vector3 m_Position = Vector3.zero;

Quaternion m_Rotation = Quaternion.identity;

Vector3 m_Scale = Vector3.one;

public ITransform transform

{

get { return this; }

}

Vector3 ITransform.position

{

get

{

return m_Position;

}

set

{

if (m_Position == value)

return;

m_Position = value;

Dirty(ChangeType.Transform);

}

}

Quaternion ITransform.rotation

{

get

{

return m_Rotation;

}

set

{

if (m_Rotation == value)

return;

m_Rotation = value;

Dirty(ChangeType.Transform);

}

}

Vector3 ITransform.scale

{

get

{

return m_Scale;

}

set

{

if (m_Scale == value)

return;

m_Scale = value;

Dirty(ChangeType.Transform);

}

}

Matrix4x4 ITransform.matrix

{

get { return Matrix4x4.TRS(m_Position, m_Rotation, m_Scale); }

}

Rect m_Layout;

// This will replace the Rect position

// origin and size relative to parent

public Rect layout

{

get

{

var result = m_Layout;

if (yogaNode != null && style.positionType.value != PositionType.Manual)

{

result.x = yogaNode.LayoutX;

result.y = yogaNode.LayoutY;

result.width = yogaNode.LayoutWidth;

result.height = yogaNode.LayoutHeight;

}

return result;

}

set

{

if (yogaNode == null)

{

yogaNode = new YogaNode();

}

// Same position value while type is already manual should not trigger any layout change, return early

if (style.positionType.value == PositionType.Manual && m_Layout == value)

return;

// set results so we can read straight back in get without waiting for a pass

m_Layout = value;

// mark as inline so that they do not get overridden if needed.

IStyle styleAccess = this;

styleAccess.positionType = PositionType.Manual;

styleAccess.marginLeft = 0.0f;

styleAccess.marginRight = 0.0f;

styleAccess.marginBottom = 0.0f;

styleAccess.marginTop = 0.0f;

styleAccess.positionLeft = value.x;

styleAccess.positionTop = value.y;

styleAccess.positionRight = float.NaN;

styleAccess.positionBottom = float.NaN;

styleAccess.width = value.width;

styleAccess.height = value.height;

Dirty(ChangeType.Transform);

}

}

public Rect contentRect

{

get

{

var spacing = new Spacing(m_Style.paddingLeft,

m_Style.paddingTop,

m_Style.paddingRight,

m_Style.paddingBottom);

return paddingRect - spacing;

}

}

protected Rect paddingRect

{

get

{

var spacing = new Spacing(style.borderLeftWidth,

style.borderTopWidth,

style.borderRightWidth,

style.borderBottomWidth);

return rect - spacing;

}

}

/// <summary>

/// AABB after applying the world transform to <c>rect</c>.

/// </summary>

public Rect worldBound

{

get

{

var g = worldTransform;

var min = GUIUtility.Internal_MultiplyPoint(new Vector3(rect.min.x, rect.min.y, 1), g);

var max = GUIUtility.Internal_MultiplyPoint(new Vector3(rect.max.x, rect.max.y, 1), g);

// We assume that the transform performs translation/scaling without rotation.

return Rect.MinMaxRect(Math.Min(min.x, max.x), Math.Min(min.y, max.y), Math.Max(min.x, max.x), Math.Max(min.y, max.y));

}

}

/// <summary>

/// AABB after applying the transform to the rect, but before applying the layout translation.

/// </summary>

public Rect localBound

{

get

{

var g = transform.matrix;

var min = GUIUtility.Internal_MultiplyPoint(layout.min, g);

var max = GUIUtility.Internal_MultiplyPoint(layout.max, g);

// We assume that the transform performs translation/scaling without rotation.

return Rect.MinMaxRect(Math.Min(min.x, max.x), Math.Min(min.y, max.y), Math.Max(min.x, max.x), Math.Max(min.y, max.y));

}

}

internal Rect rect

{

get

{

return new Rect(0.0f, 0.0f, layout.width, layout.height);

}

}

internal bool isWorldTransformDirty { get; set; } = true;

/// <summary>

/// Returns a matrix that cumulates the following operations (in order):

/// -Local Scaling

/// -Local Rotation

/// -Local Translation

/// -Layout Translation

/// -Parent <c>worldTransform</c> (recursive definition - consider identity when there is no parent)

/// </summary>

/// <remarks>

/// Multiplying the <c>layout</c> rect by this matrix is incorrect because it already contains the translation.

/// </remarks>

public Matrix4x4 worldTransform

{

get

{

if (IsDirty(ChangeType.Transform))

{

var offset = Matrix4x4.Translate(new Vector3(layout.x, layout.y, 0));

if (shadow.parent != null)

{

renderData.worldTransForm = shadow.parent.worldTransform * offset * transform.matrix;

}

else

{

renderData.worldTransForm = offset * transform.matrix;

}

ClearDirty(ChangeType.Transform);

}

return renderData.worldTransForm;

}

}

// which pseudo states would change the current VE styles if added

internal PseudoStates triggerPseudoMask;

// which pseudo states would change the current VE styles if removed

internal PseudoStates dependencyPseudoMask;

private PseudoStates m_PseudoStates;

internal PseudoStates pseudoStates

{

get { return m_PseudoStates; }

set

{

if (m_PseudoStates != value)

{

m_PseudoStates = value;

if ((triggerPseudoMask & m_PseudoStates) != 0

|| (dependencyPseudoMask & ~m_PseudoStates) != 0)

{

Dirty(ChangeType.Styles);

}

}

}

}

public PickingMode pickingMode { get; set; }

// does not guarantee uniqueness

public string name

{

get { return m_Name; }

set

{

if (m_Name == value)

return;

m_Name = value;

Dirty(ChangeType.Styles);

}

}

internal string fullTypeName

{

get

{

if (string.IsNullOrEmpty(m_FullTypeName))

m_FullTypeName = GetType().FullName;

return m_FullTypeName;

}

}

internal string typeName

{

get

{

if (string.IsNullOrEmpty(m_TypeName))

{

var type = GetType();

bool isGeneric = false;

isGeneric = type.IsGenericType;

m_TypeName = isGeneric ? type.Name.Remove(type.Name.IndexOf('`')) : type.Name;

}

return m_TypeName;

}

}

// Set and pass in values to be used for layout

internal YogaNode yogaNode { get; private set; }

// shared style object, cannot be changed by the user

internal VisualElementStylesData m_SharedStyle = VisualElementStylesData.none;

// user-defined style object, if not set, is the same reference as m_SharedStyles

internal VisualElementStylesData m_Style = VisualElementStylesData.none;

protected virtual void OnStyleResolved(ICustomStyle style)

{

// push all non inlined layout things up

FinalizeLayout();

}

internal VisualElementStylesData sharedStyle

{

get

{

return m_SharedStyle;

}

}

internal VisualElementStylesData effectiveStyle

{

get

{

return m_Style;

}

}

internal bool hasInlineStyle

{

get

{

return m_Style != m_SharedStyle;

}

}

VisualElementStylesData inlineStyle

{

get

{

if (!hasInlineStyle)

{

var inline = new VisualElementStylesData(false);

inline.Apply(m_SharedStyle, StylePropertyApplyMode.Copy);

m_Style = inline;

}

return m_Style;

}

}

// Opacity is not fully supported so it's hidden from public API for now

internal float opacity

{

get

{

return style.opacity.value;

}

set

{

style.opacity = value;

}

}

internal readonly uint controlid;

public VisualElement()

{

controlid = ++s_NextId;

shadow = new Hierarchy(this);

m_ClassList = new HashSet<string>();

m_FullTypeName = string.Empty;

m_TypeName = string.Empty;

SetEnabled(true);

// Make element non focusable by default.

focusIndex = defaultFocusIndex;

name = string.Empty;

yogaNode = new YogaNode();

changesNeeded = ChangeType.All;

clippingOptions = ClippingOptions.ClipContents;

}

protected internal override void ExecuteDefaultAction(EventBase evt)

{

base.ExecuteDefaultAction(evt);

if (evt.GetEventTypeId() == MouseOverEvent.TypeId() || evt.GetEventTypeId() == MouseOutEvent.TypeId())

{

UpdateCursorStyle(evt.GetEventTypeId());

}

else if (evt.GetEventTypeId() == MouseEnterEvent.TypeId())

{

pseudoStates |= PseudoStates.Hover;

}

else if (evt.GetEventTypeId() == MouseLeaveEvent.TypeId())

{

pseudoStates &= ~PseudoStates.Hover;

}

else if (evt.GetEventTypeId() == BlurEvent.TypeId())

{

pseudoStates = pseudoStates & ~PseudoStates.Focus;

}

else if (evt.GetEventTypeId() == FocusEvent.TypeId())

{

pseudoStates = pseudoStates | PseudoStates.Focus;

}

}

public sealed override void Focus()

{

if (!canGrabFocus && shadow.parent != null)

{

shadow.parent.Focus();

}

else

{

base.Focus();

}

}

internal void SetPanel(BaseVisualElementPanel p)

{

if (panel == p)

return;

//We now gather all Elements in order to dispatch events in an efficient manner

List<VisualElement> elements = VisualElementListPool.Get();

try

{

elements.Add(this);

GatherAllChildren(elements);

foreach (var e in elements)

{

e.ChangePanel(p);

}

}

finally

{

VisualElementListPool.Release(elements);

}

}

// This should never be called directly

// This needs to be virtual for GraphView.cs

// We could avoid this by having a single PanelChangeEvent

// containing both the previous and the new panel values.

internal virtual void ChangePanel(BaseVisualElementPanel p)

{

if (panel != null)

{

using (var e = DetachFromPanelEvent.GetPooled())

{

e.target = this;

UIElementsUtility.eventDispatcher.DispatchEvent(e, panel);

}

}

elementPanel = p;

if (panel != null)

{

using (var e = AttachToPanelEvent.GetPooled())

{

e.target = this;

UIElementsUtility.eventDispatcher.DispatchEvent(e, panel);

}

}

Dirty(ChangeType.Styles);

}

// in the case of a Topology change the target is the parent of the removed or added element

// TODO write test suite for this method. in particular, any change type should implicitly

private ChangeType changesNeeded;

// helper when change impact are known and we need to propagate down into children

private void PropagateToChildren(ChangeType type)

{

// when touching we grass fire in the tree but stop when we are already touched.

// this is a key point of the on demand dirty that keeps it from exploding.

if ((type & changesNeeded) == type)

return;

changesNeeded |= type;

// only those propagate to children

type = type & (ChangeType.Styles | ChangeType.Transform);

if (type == 0)

return;

// propagate to children

if (m_Children != null)

{

foreach (var child in m_Children)

{

// recurse down

child.PropagateToChildren(type);

}

}

}

private void PropagateChangesToParents()

{

ChangeType parentChanges = 0;

if (changesNeeded != 0)

{

// if we have any change at all, propagate the repaint flag

// this is somehow an implementation detail but this is the only flag that is checked in the app tick

// this means that styles, layout, transform, etc. will be processed just before painting a panel

// a small downside is that we might repaint more often that necessary

// another solution would be to process all flags sequentially in the tick to check if a repaint is needed

parentChanges |= ChangeType.Repaint;

if ((changesNeeded & ChangeType.Styles) > 0)

{

// if this visual element needs its styles recomputed, propagate this specific flags for its parents

// it is less expensive than a full styles re-pass

parentChanges |= ChangeType.StylesPath;

}

if ((changesNeeded & (ChangeType.PersistentData | ChangeType.PersistentDataPath)) > 0)

{

// Parents do not need their OnPersistentDataReady() called but they need to call still

// propagate it to their children so it gets back to us.

parentChanges |= ChangeType.PersistentDataPath;

}

}

var current = shadow.parent;

while (current != null)

{

if ((current.changesNeeded & parentChanges) == parentChanges)

break;

current.changesNeeded |= parentChanges;

current = current.shadow.parent;

}

}

public void Dirty(ChangeType type)

{

// when touching we grass fire in the tree but stop when we are already touched.

// this is a key point of the on demand dirty that keeps it from exploding.

if ((type & changesNeeded) == type)

return;

if ((type & ChangeType.Layout) == ChangeType.Layout)

{

if (yogaNode != null && yogaNode.IsMeasureDefined)

{

yogaNode.MarkDirty();

}

type |= ChangeType.Repaint;

}

if (((type & ChangeType.Transform) == ChangeType.Transform) && (elementPanel != null))

{

elementPanel.hasDirtyTransform = true;

}

PropagateToChildren(type);

PropagateChangesToParents();

}

internal bool AnyDirty()

{

return changesNeeded != 0;

}

public bool IsDirty(ChangeType type)

{

return (changesNeeded & type) == type;

}

public bool AnyDirty(ChangeType type)

{

return (changesNeeded & type) > 0;

}

public void ClearDirty(ChangeType type)

{

changesNeeded &= ~type;

}

[Obsolete("enabled is deprecated. Use SetEnabled as setter, and enabledSelf/enabledInHierarchy as getters.", true)]

public virtual bool enabled

{

get { return enabledInHierarchy; }

set { SetEnabled(value); }

}

private bool m_Enabled;

//TODO: Make private once VisualContainer is merged with VisualElement

protected internal bool SetEnabledFromHierarchy(bool state)

{

//returns false if state hasn't changed

if (state == ((pseudoStates & PseudoStates.Disabled) != PseudoStates.Disabled))

return false;

if (state && m_Enabled && (parent == null || parent.enabledInHierarchy))

pseudoStates &= ~PseudoStates.Disabled;

else

pseudoStates |= PseudoStates.Disabled;

return true;

}

//Returns true if 'this' can be enabled relative to the enabled state of its panel

public bool enabledInHierarchy

{

get { return (pseudoStates & PseudoStates.Disabled) != PseudoStates.Disabled; }

}

//Returns the local enabled state

public bool enabledSelf

{

get { return m_Enabled; }

}

public void SetEnabled(bool value)

{

if (m_Enabled != value)

{

m_Enabled = value;

PropagateEnabledToChildren(value);

}

}

void PropagateEnabledToChildren(bool value)

{

if (SetEnabledFromHierarchy(value))

{

for (int i = 0; i < shadow.childCount; ++i)

{

shadow[i].PropagateEnabledToChildren(value);

}

}

}

public bool visible

{

get

{

return style.visibility.GetSpecifiedValueOrDefault(Visibility.Visible) == Visibility.Visible;

}

set

{

// Note: this could causes an allocation because styles are copy-on-write

// we might want to remove this setter altogether

// so everything goes through style.visibility (and then it's documented in a single place)

style.visibility = value ? Visibility.Visible : Visibility.Hidden;

}

}

public virtual void DoRepaint()

{

var painter = elementPanel.stylePainter;

painter.DrawBackground(this);

painter.DrawBorder(this);

}

internal virtual void DoRepaint(IStylePainter painter)

{

if (visible == false)

{

return;

}

DoRepaint();

}

private void GetFullHierarchicalPersistenceKey(StringBuilder key)

{

const string keySeparator = "__";

if (parent != null)

parent.GetFullHierarchicalPersistenceKey(key);

if (!string.IsNullOrEmpty(persistenceKey))

{

key.Append(keySeparator);

key.Append(persistenceKey);

}

}

public string GetFullHierarchicalPersistenceKey()

{

StringBuilder key = new StringBuilder();

GetFullHierarchicalPersistenceKey(key);

return key.ToString();

}

public T GetOrCreatePersistentData<T>(object existing, string key) where T : class, new()

{

Debug.Assert(elementPanel != null, "VisualElement.elementPanel is null! Cannot load persistent data.");

var persistentData = elementPanel == null || elementPanel.getViewDataDictionary == null ? null : elementPanel.getViewDataDictionary();

// If persistency is disable (no data, no key, no key one of the parents), just return the

// existing data or create a local one if none exists.

if (persistentData == null || string.IsNullOrEmpty(persistenceKey) || enablePersistence == false)

{

if (existing != null)

return existing as T;

return new T();

}

string keyWithType = key + "__" + typeof(T).ToString();

if (!persistentData.ContainsKey(keyWithType))

persistentData.Set(keyWithType, new T());

return persistentData.Get<T>(keyWithType);

}

public T GetOrCreatePersistentData<T>(ScriptableObject existing, string key) where T : ScriptableObject

{

Debug.Assert(elementPanel != null, "VisualElement.elementPanel is null! Cannot load persistent data.");

var persistentData = elementPanel == null || elementPanel.getViewDataDictionary == null ? null : elementPanel.getViewDataDictionary();

// If persistency is disable (no data, no key, no key one of the parents), just return the

// existing data or create a local one if none exists.

if (persistentData == null || string.IsNullOrEmpty(persistenceKey) || enablePersistence == false)

{

if (existing != null)

return existing as T;

return ScriptableObject.CreateInstance<T>();

}

string keyWithType = key + "__" + typeof(T).ToString();

if (!persistentData.ContainsKey(keyWithType))

persistentData.Set(keyWithType, ScriptableObject.CreateInstance<T>());

return persistentData.GetScriptable<T>(keyWithType);

}

public void OverwriteFromPersistedData(object obj, string key)

{

Debug.Assert(elementPanel != null, "VisualElement.elementPanel is null! Cannot load persistent data.");

var persistentData = elementPanel == null || elementPanel.getViewDataDictionary == null ? null : elementPanel.getViewDataDictionary();

// If persistency is disable (no data, no key, no key one of the parents), just return the

// existing data or create a local one if none exists.

if (persistentData == null || string.IsNullOrEmpty(persistenceKey) || enablePersistence == false)

{

return;

}

string keyWithType = key + "__" + obj.GetType();

if (!persistentData.ContainsKey(keyWithType))

{

persistentData.Set(keyWithType, obj);

return;

}

persistentData.Overwrite(obj, keyWithType);

}

public void SavePersistentData()

{

if (elementPanel != null && elementPanel.savePersistentViewData != null && !string.IsNullOrEmpty(persistenceKey))

elementPanel.savePersistentViewData();

}

internal bool IsPersitenceSupportedOnChildren()

{

// We relax here the requirement that ALL parents of a VisualElement

// need to have a persistenceKey for persistence to work. Plain

// VisualElements are likely to be used just for layouting and

// grouping and requiring a key on each element is a bit tedious.

if (this.GetType() == typeof(VisualElement))

return true;

if (string.IsNullOrEmpty(persistenceKey))

return false;

return true;

}

internal void OnPersistentDataReady(bool enablePersistence)

{

this.enablePersistence = enablePersistence;

OnPersistentDataReady();

}

public virtual void OnPersistentDataReady() {}

// position should be in local space

// override to customize intersection between point and shape

public virtual bool ContainsPoint(Vector2 localPoint)

{

return rect.Contains(localPoint);

}

public virtual bool Overlaps(Rect rectangle)

{

return rect.Overlaps(rectangle, true);

}

public enum MeasureMode

{

Undefined = YogaMeasureMode.Undefined,

Exactly = YogaMeasureMode.Exactly,

AtMost = YogaMeasureMode.AtMost

}

private bool m_RequireMeasureFunction = false;

internal bool requireMeasureFunction

{

get { return m_RequireMeasureFunction; }

set

{

m_RequireMeasureFunction = value;

if (m_RequireMeasureFunction && !yogaNode.IsMeasureDefined)

{

yogaNode.SetMeasureFunction(Measure);

}

else if (!m_RequireMeasureFunction && yogaNode.IsMeasureDefined)

{

yogaNode.SetMeasureFunction(null);

}

}

}

protected internal virtual Vector2 DoMeasure(float width, MeasureMode widthMode, float height, MeasureMode heightMode)

{

return new Vector2(float.NaN, float.NaN);

}

internal YogaSize Measure(YogaNode node, float width, YogaMeasureMode widthMode, float height, YogaMeasureMode heightMode)

{

Debug.Assert(node == yogaNode, "YogaNode instance mismatch");

Vector2 size = DoMeasure(width, (MeasureMode)widthMode, height, (MeasureMode)heightMode);

return MeasureOutput.Make(Mathf.RoundToInt(size.x), Mathf.RoundToInt(size.y));

}

public void SetSize(Vector2 size)

{

var pos = layout;

pos.width = size.x;

pos.height = size.y;

layout = pos;

}

internal const Align DefaultAlignContent = Align.FlexStart;

internal const Align DefaultAlignItems = Align.Stretch;