public static IEnumerable <T> SearchHierarchy <T>(this GameObject self, HierarchySearchType searchType, bool doSearchInactive)
{
return(SearchHierarchy(self, searchType, doSearchInactive, null, new List <Type>()
{
typeof(T)
}).Select(m => m.GetComponent <T>()));
}
public static T SearchHierarchyForFirst <T>(this GameObject self, HierarchySearchType searchType, bool doSearchInactive)
{
return(SearchHierarchy(self, searchType, doSearchInactive, null, new List <Type>()
{
typeof(T)
}).First().GetComponent <T>());
}
//Called when collapsing, go up hierarchy from selected to find objects that need to be nudged
public void RecursiveUp(HierarchyEntry inputEntry, int nudgeCount, HierarchySearchType searchType)
{
if (inputEntry.parent) //Check not top of hierarchy
{
bool isSelected = false; //Flipped when expanded item is found
for (int i = 0; i < inputEntry.parent.children.Count; i++) //Iterate siblings
{
if (inputEntry.parent.children[i] == inputEntry) //If currently expanded item
{
isSelected = true; //Found expanded item
continue;
}
else if (isSelected) //Following items
{
RectTransform rect = inputEntry.parent.children[i].GetComponent <RectTransform>(); //Get reference to rect transfrom
Vector2 oldPos = rect.anchoredPosition; //get current position
switch (searchType)
{
case HierarchySearchType.Collapse:
rect.anchoredPosition = new Vector2(0, oldPos.y + nudgeCount * entryHeight); //set nudged position
break;
case HierarchySearchType.Expand:
rect.anchoredPosition = new Vector2(0, oldPos.y - nudgeCount * entryHeight); //set nudged position
break;
}
}
}
RecursiveUp(inputEntry.parent, nudgeCount, searchType); //Continue up hierarchy
}
}
//Called when collapsing, go down hierarchy from selected to collapse items and calculate hierarchy nudge count
public int RecursiveDown(HierarchyEntry inputEntry, HierarchySearchType searchType)
{
int count = 0; //Integer for tracking children found
for (int i = 0; i < inputEntry.children.Count; i++) //Iterate children
{
switch (searchType)
{
case HierarchySearchType.Collapse:
inputEntry.children[i].GetComponent <RectTransform>().anchoredPosition = Vector2.zero; //Set position
inputEntry.children[i].isHidden = true; //Set hidden to check against
inputEntry.children[i].gameObject.SetActive(false); //Set game object disabled
break;
case HierarchySearchType.Expand:
inputEntry.children[i].GetComponent <RectTransform>().anchoredPosition = new Vector2(0, -((1 + count) * entryHeight)); //Set position
inputEntry.children[i].isHidden = false; //Set hidden to check against
inputEntry.children[i].gameObject.SetActive(true); //Set game object disabled
break;
}
count++; //Add to collapsed item count;
if (!inputEntry.children[i].isCollapsed) //If not collapsed keep going down hierarchy
{
count += RecursiveDown(inputEntry.children[i], searchType); //Expand down hierarchy
}
}
return(count); //Return
}
private void OnSearch(HierarchySearchType type, string term)
{
if (m_OnRepaintWindow != null)
{
m_OnRepaintWindow();
}
Save();
m_SearchResults.Clear();
EditorApplication.RepaintHierarchyWindow();
if (string.IsNullOrEmpty(term))
{
m_SearchPrompt.message = "Search term cannot be empty.";
m_SearchPrompt.type = MessageType.Error;
return;
}
m_SearchHandlers[type](term, m_SearchWidget.CaseSensitive, m_SearchWidget.IncludeInactive, m_SearchWidget.MatchWholeWord, m_SearchResults);
if (m_SearchResults.Count == 0)
{
//repaint hierarchy
if (type == HierarchySearchType.Layer)
{
m_SearchPrompt.message = string.Format("Could not find match for \"{0}\". The layer name must be exact and is case sensitive.", term);
}
else
{
m_SearchPrompt.message = string.Format("Could not find match for \"{0}\"", term);
}
m_SearchPrompt.type = MessageType.Info;
}
else
{
m_SearchPrompt.message = string.Empty;
}
}
public static IEnumerable <GameObject> SearchHierarchy(this GameObject self, HierarchySearchType searchType, bool doSearchInactive, params string[] names)
{
return(SearchHierarchy(self, searchType, doSearchInactive, names.ToList(), null));
}
public static IEnumerable <GameObject> SearchHierarchy(this GameObject self, HierarchySearchType searchType, bool doSearchInactive, List <string> names, List <Type> types)
{
bool doSearchParent = (searchType & HierarchySearchType.Parent) != 0;
bool doSearchAncestors = (searchType & HierarchySearchType.Ancestors) != 0;
bool doSearchChildren = (searchType & HierarchySearchType.Children) != 0;
bool doSearchDescendants = (searchType & HierarchySearchType.Descendants) != 0;
bool doSearchSiblings = (searchType & HierarchySearchType.Siblings) != 0;
bool doSearchNiblings = (searchType & HierarchySearchType.Niblings) != 0;
bool doSearchAll = (searchType & HierarchySearchType.All) != 0;
List <GameObject> foundGameObjects = new List <GameObject>();
if (doSearchAll)
{
if (!doSearchInactive && (names != null) && (names.Count == 1) && ((types == null) || !types.Any()))
{
foundGameObjects.Add(GameObject.Find(names.First()));
}
else
{
searchRoots(true, true, doSearchInactive, names, types, self, foundGameObjects);
}
}
else
{
GameObject parent = null;
if (doSearchParent || doSearchAncestors || doSearchSiblings || doSearchNiblings)
{
if (self.transform.parent != null)
{
parent = self.transform.parent.gameObject;
if (doSearchParent || doSearchAncestors)
{
addGameObjectIfValid(parent, doSearchInactive, names, types, self, foundGameObjects);
}
}
if (doSearchSiblings || doSearchNiblings)
{
if (parent == null)
{
searchRoots(doSearchNiblings, false, doSearchInactive, names, types, self, foundGameObjects);
}
else
{
searchChildren(parent, doSearchNiblings, false, doSearchInactive, names, types, self, foundGameObjects);
}
}
if (doSearchAncestors && (parent != null))
{
searchAncestors(parent, doSearchInactive, names, types, self, foundGameObjects);
}
}
if (doSearchChildren || doSearchDescendants)
{
searchChildren(self, doSearchDescendants, false, doSearchInactive, names, types, self, foundGameObjects);
}
}
return(foundGameObjects);
}
