protected HierarchyDataRoot(RuntimeHierarchy hierarchy)
{
Hierarchy = hierarchy;
// Root data are expanded by default
PopChildrenList();
}
public override void Initialize()
{
base.Initialize();
isActiveGetter = () => ((GameObject)Value).activeSelf;
isActiveSetter = (value) => ((GameObject)Value).SetActive((bool)value);
nameGetter = () => ((GameObject)Value).name;
nameSetter = (value) =>
{
((GameObject)Value).name = (string)value;
NameRaw = Value.GetNameWithType();
RuntimeHierarchy hierarchy = Inspector.ConnectedHierarchy;
if (hierarchy)
{
hierarchy.RefreshNameOf(((GameObject)Value).transform);
}
};
tagGetter = () =>
{
GameObject go = (GameObject)Value;
if (!go.CompareTag(currentTag))
{
currentTag = go.tag;
}
return(currentTag);
};
tagSetter = (value) => ((GameObject)Value).tag = (string)value;
layerProp = typeof(GameObject).GetProperty("layer");
}
private void Awake()
{
hierarchyItem = GetComponent <HierarchyItem>();
if (hierarchyItem == null)
{
m_hierarchy = GetComponent <RuntimeHierarchy>();
}
}
protected override void GenerateElements()
{
if (components.Count == 0)
{
return;
}
CreateDrawer(typeof(bool), "Is Active", () => ((GameObject)Value).activeSelf, (value) => ((GameObject)Value).SetActive((bool)value));
nameField = CreateDrawer(typeof(string), "Name", () => ((GameObject)Value).name, (value) =>
{
((GameObject)Value).name = (string)value;
NameRaw = Value.GetNameWithType();
RuntimeHierarchy hierarchy = Inspector.ConnectedHierarchy;
if (hierarchy != null)
{
hierarchy.RefreshNameOf(((GameObject)Value).transform);
}
}) as StringField;
tagField = CreateDrawer(typeof(string), "Tag", () =>
{
GameObject go = (GameObject)Value;
if (!go.CompareTag(currentTag))
{
currentTag = go.tag;
}
return(currentTag);
}, (value) => ((GameObject)Value).tag = (string)value) as StringField;
CreateDrawerForVariable(typeof(GameObject).GetProperty("layer"), "Layer");
for (int i = 0, j = elements.Count; i < components.Count; i++)
{
InspectorField componentDrawer = CreateDrawerForComponent(components[i]);
if (componentDrawer != null)
{
if (j < componentsExpandedStates.Count && componentsExpandedStates[j] && componentDrawer is ExpandableInspectorField)
{
((ExpandableInspectorField)componentDrawer).IsExpanded = true;
}
j++;
}
}
if (nameField != null)
{
nameField.SetterMode = StringField.Mode.OnSubmit;
}
if (tagField != null)
{
tagField.SetterMode = StringField.Mode.OnSubmit;
}
componentsExpandedStates.Clear();
}
public void Initialize(RuntimeHierarchy hierarchy)
{
Hierarchy = hierarchy;
rectTransform = (RectTransform)transform;
background = clickListener.GetComponent <Image>();
expandToggle.PointerClick += (eventData) => ToggleExpandedState();
clickListener.PointerClick += (eventData) => OnClick();
clickListener.PointerDown += OnPointerDown;
clickListener.PointerUp += OnPointerUp;
}
public void Initialize(RuntimeHierarchy hierarchy)
{
Hierarchy = hierarchy;
rectTransform = (RectTransform)transform;
background = clickListener.GetComponent <Image>();
if (hierarchy.ShowTooltips)
{
clickListener.gameObject.AddComponent <TooltipArea>().Initialize(hierarchy.TooltipListener, this);
}
expandToggle.PointerClick += (eventData) => ToggleExpandedState();
clickListener.PointerClick += (eventData) => OnClick();
clickListener.PointerDown += OnPointerDown;
clickListener.PointerUp += OnPointerUp;
}
protected override void GenerateElements()
{
if (components.Count == 0)
{
return;
}
CreateDrawer(typeof(bool), "Is Active", () => ((GameObject)Value).activeSelf, (value) => ((GameObject)Value).SetActive((bool)value));
nameField = CreateDrawer(typeof(string), "Name", () => ((GameObject)Value).name, (value) =>
{
((GameObject)Value).name = (string)value;
RuntimeHierarchy hierarchy = Inspector.ConnectedHierarchy;
if (hierarchy != null)
{
hierarchy.RefreshNameOf(((GameObject)Value).transform);
}
}) as StringField;
tagField = CreateDrawer(typeof(string), "Tag", () =>
{
GameObject go = (GameObject)Value;
if (!go.CompareTag(currentTag))
{
currentTag = go.tag;
}
return(currentTag);
}, (value) => ((GameObject)Value).tag = (string)value) as StringField;
CreateDrawerForVariable(typeof(GameObject).GetProperty("layer"), "Layer");
for (int i = 0; i < components.Count; i++)
{
CreateDrawerForComponent(components[i]);
}
if (nameField != null)
{
nameField.SetterMode = StringField.Mode.OnSubmit;
}
if (tagField != null)
{
tagField.SetterMode = StringField.Mode.OnSubmit;
}
}
private void GenerateChildItem(Transform child, int index, RuntimeHierarchy hierarchy)
{
bool isChildVisible = !RuntimeInspectorUtils.IgnoredTransformsInHierarchy.Contains(child);
if (isChildVisible && hierarchy.GameObjectFilter != null)
{
isChildVisible = hierarchy.GameObjectFilter(child);
}
HierarchyDataTransform childData;
int poolIndex = transformDataPool.Count - 1;
if (poolIndex >= 0)
{
childData = transformDataPool[poolIndex];
transformDataPool.RemoveAt(poolIndex);
}
else
{
childData = new HierarchyDataTransform();
}
childData.Initialize(child, this is HierarchyDataRootSearch);
childData.parent = this;
if (isChildVisible)
{
childData.m_depth = m_depth + 1;
childData.m_height = 1;
}
else
{
childData.m_depth = -1;
childData.m_height = 0;
}
children.Insert(index, childData);
}
public void OnDrop(PointerEventData eventData)
{
RuntimeHierarchy hierarchy = Hierarchy;
if (hierarchy == null || !hierarchy.CanReorganizeItems)
{
return;
}
Transform droppedTransform = RuntimeInspectorUtils.GetAssignableObjectFromDraggedReferenceItem(eventData, typeof(Transform)) as Transform;
if (droppedTransform == null)
{
return;
}
if (hierarchyItem == null)
{
if (droppedTransform.parent == null)
{
return;
}
droppedTransform.SetParent(null, true);
}
else if (hierarchyItem is HierarchyItemTransform)
{
Transform newParent = ((HierarchyItemTransform)hierarchyItem).BoundTransform;
if (droppedTransform.parent == newParent || droppedTransform == newParent)
{
return;
}
// Avoid setting child object as parent of the parent object
Transform curr = newParent;
while (curr.parent != null && curr.parent != droppedTransform)
{
curr = curr.parent;
}
if (curr.parent == droppedTransform)
{
curr.SetParent(droppedTransform.parent, true);
}
droppedTransform.SetParent(newParent, true);
}
else
{
IHierarchyRootContent rootContent = ((HierarchyItemRoot)hierarchyItem).Content;
if (rootContent is HierarchyRootPseudoScene)
{
//( (HierarchyRootPseudoScene) rootContent ).AddChild( droppedTransform ); // Add object to pseudo-scene
return;
}
else if (rootContent is HierarchyRootScene)
{
bool parentChanged = false;
if (droppedTransform.parent != null)
{
droppedTransform.SetParent(null, true);
parentChanged = true;
}
Scene scene = ((HierarchyRootScene)rootContent).Scene;
if (droppedTransform.gameObject.scene != scene)
{
SceneManager.MoveGameObjectToScene(droppedTransform.gameObject, scene);
parentChanged = true;
}
if (!parentChanged)
{
return;
}
}
}
if (hierarchyItem != null && !hierarchyItem.IsExpanded)
{
hierarchyItem.IsExpanded = true;
}
hierarchy.Refresh();
}
public HierarchyDataRootPseudoScene(RuntimeHierarchy hierarchy, string name) : base(hierarchy)
{
this.name = name;
}
public HierarchyRootSearch(RuntimeHierarchy hierarch, IHierarchyRootContent reference)
{
this.hierarch = hierarch;
this.reference = reference;
}
public HierarchyDataRootSearch(RuntimeHierarchy hierarchy, HierarchyDataRoot reference) : base(hierarchy)
{
this.reference = reference;
}
public HierarchyDataRootScene(RuntimeHierarchy hierarchy, Scene target) : base(hierarchy)
{
Scene = target;
}
public virtual bool Refresh()
{
if (m_depth < 0) // This object is hidden from Hierarchy
{
return(false);
}
m_height = 1;
bool hasChanged = false;
int childCount = ChildCount;
if (IsExpanded)
{
if (childCount != children.Count)
{
hasChanged = true;
}
//if( childCount == 0 ) // Issue with IsExpanded's Refresh changing iteratedIndex
// PoolChildrenList();
//else
{
RuntimeHierarchy hierarchy = null; // Root's RuntimeHierarchy will be fetched only once when it is needed
for (int i = 0; i < childCount; i++)
{
Transform child = GetChild(i);
if (children.Count <= i)
{
if (hierarchy == null)
{
hierarchy = Root.Hierarchy;
}
GenerateChildItem(child, i, hierarchy);
}
else if (children[i].BoundTransform != child)
{
int childIndex;
for (childIndex = 0; childIndex < children.Count; childIndex++)
{
if (children[childIndex].BoundTransform == child)
{
break;
}
}
if (childIndex == children.Count)
{
if (hierarchy == null)
{
hierarchy = Root.Hierarchy;
}
GenerateChildItem(child, i, hierarchy);
}
else
{
HierarchyDataTransform childItem = children[childIndex];
children.RemoveAt(childIndex);
children.Insert(i, childItem);
}
hasChanged = true;
}
hasChanged |= children[i].Refresh();
children[i].m_index = m_height - 1;
m_height += children[i].m_height;
}
for (int i = children.Count - 1; i >= childCount; i--)
{
RemoveChildItem(i);
}
}
}
return(hasChanged);
}
