/// <summary>
/// Gets child index
/// </summary>
/// <param name="child"></param>
/// <returns></returns>
override public int GetChildIndex(ComponentAdapter child)
{
return(ContentChildren.FindIndex(delegate(ComponentAdapter componentAdapter)
{
return componentAdapter == child;
}));
}
public static Component AddHandlerScript(ComponentAdapter adapter, AddEventHandlerPersistedData data)
{
//Debug.Log(string.Format(@"AddHandlerScript [adapter: {0}, data: {1}]", adapter, data));
var component = adapter.gameObject.GetComponent(data.ClassName);
Component addedComponent = null;
/**
* 1. Check if the component is already attached
* */
if (null != component)
{
string text = string.Format(@"Script ""{0}"" is already attached to the selected game object.", data.ClassName);
Debug.LogWarning(text);
EditorUtility.DisplayDialog("Duplicated script", text, "OK");
}
else
{
/**
* 2. Add component
* */
addedComponent = adapter.gameObject.AddComponent(data.ClassName);
}
return addedComponent;
}
public AdapterAnalysis(object target)
{
if (null != target)
{
ComponentAdapter = target as ComponentAdapter;
SkinnableComponentAdapter = target as SkinnableComponentAdapter;
SkinnableContainerAdapter = target as SkinnableContainerAdapter;
GroupAdapter = target as GroupAdapter;
if (null != GroupAdapter)
{
HasAbsoluteLayout = CheckForAbsoluteLayout(GroupAdapter);
}
if (null != ComponentAdapter && null != ComponentAdapter.transform && null != ComponentAdapter.transform.parent)
{
ParentGroupAdapter = ComponentAdapter.transform.parent.GetComponent<GroupAdapter>();
HasParent = null != ParentGroupAdapter;
if (null != ParentGroupAdapter)
{
ParentIsStage = ParentGroupAdapter is StageAdapter;
//ParentUsesLayoutDescriptor = ParentContainerAdapter.UseLayoutDescriptor;
//ParentLayoutDescriptor = ParentContainerAdapter.LayoutDescriptor;
ParentLayout = ParentGroupAdapter.Layout;
ParentHasAbsoluteLayout = CheckForAbsoluteLayout(ParentGroupAdapter);
}
}
}
}
/// <summary>
/// Adds the content child at position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
/// <param name="register"></param>
public virtual void AddChildAt(int index, ComponentAdapter child, bool register)
{
ContentChildren.Remove(child);
if (ContentChildren.Count >= index)
{
ContentChildren.Insert(index, child);
}
else
{
ContentChildren.Add(child);
}
if (child.FactoryMode)
{
return;
}
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
{
return;
}
DoInstantiateAt(child, index, register);
}
/// <summary>
/// Since all of the tree displays use the selection change, I decided to implement it in superclass
/// </summary>
internal void ProcessSelectionChange()
{
//Debug.Log("ProcessSelectionChange: " + Selection.activeObject);
if (null == Selection.activeGameObject)
return;
GameObject go = Selection.activeGameObject;
/*if (null == go)
throw new Exception("Couldn't get the selection");*/
Adapter = go.GetComponent(typeof(ComponentAdapter)) as ComponentAdapter;
if (null == Adapter)
{
/**
* Not a GUI component
* S hould do cleanup and handle selection (deselect basically)
* */
GroupAdapter = null;
//HandleSelectionChange();
return;
}
Target = Adapter;
GroupAdapter = Target as GroupAdapter;
HandleSelectionChange();
}
///<summary>
///</summary>
///<param name="containerAdapter"></param>
///<returns></returns>
public List<ComponentAdapter> GetChildAdaptersCollection(ComponentAdapter containerAdapter)
{
if (null == CollectionMemberInfo || null == containerAdapter)
return null;
List<ComponentAdapter> collection = Core.Reflection.CoreReflector.GetMemberValue(CollectionMemberInfo, containerAdapter) as List<ComponentAdapter>;
return collection;
}
public static bool IsCreatedFromPrefab(ComponentAdapter adapter)
{
// if this is a prefab, or a child of a prefab, do not reorder its children
var prefabRoot = PrefabUtility.FindPrefabRoot(adapter.gameObject);
var prefabParent = PrefabUtility.GetPrefabParent(adapter.gameObject);
var prefabObject = PrefabUtility.GetPrefabObject(adapter.gameObject);
return null != prefabParent || null != prefabObject || null != prefabRoot;
}
//public void Add(List<ComponentAdapter> adapters)
//{
// _groups.Add(new ChildGroup(adapters)); // Beware: the bug was here - internally the changes were immediatelly applied to collections
// //_groups.Add(new ChildGroup(ListUtil<ComponentAdapter>.Clone(adapters))); //TODO??
//}
public int GetGroupHostingAdapterIndex(ComponentAdapter adapter)
{
for (int i = 0; i < Groups.Count; i++)
{
bool contains = Groups[i].Adapters.Contains(adapter);
if (contains)
return i;
}
return -1;
}
private void DoInstantiateAt(ComponentAdapter childAdapter, int index, bool useAsInstance)
{
if (!childAdapter.Instantiated)
{
childAdapter.DoInstantiate(useAsInstance);
}
var container = (IContentChildList)Component;
if (null != container)
{
container.AddContentChildAt(childAdapter.Component, index);
}
}
/// <summary>
/// Note: this method actually changes the collections
/// </summary>
/// <param name="adapter"></param>
/// <returns></returns>
public ChildGroupPack Remove(ComponentAdapter adapter)
{
_pack = ChildGroupPack.Read(_groupAdapter);
//Debug.Log(string.Format("Reorder: grp:{0}, item:{1}", groupIndex, itemIndex));
// get old group index
var oldGroupIndex = _pack.GetGroupHostingAdapterIndex(adapter);
// remove adapter from old group
_pack.Groups[oldGroupIndex].Remove(adapter);
return _pack;
}
/// <summary>
/// Instantiates
/// </summary>
/// <param name="childAdapter"></param>
/// <param name="register"></param>
public virtual void DoInstantiate(ComponentAdapter childAdapter, bool register)
{
if (!childAdapter.Instantiated)
{
childAdapter.DoInstantiate(register);
}
var container = Component as IContentChildList;
if (null == container)
{
Debug.LogError(Component.GetType().Name + " cannot host children");
return;
}
container.AddContentChild(childAdapter.Component);
}
/// <summary>
/// Removes the childAdapter
/// </summary>
/// <param name="childAdapter"></param>
override public void RemoveChild(ComponentAdapter childAdapter)
{
ContentChildren.Remove(childAdapter);
childAdapter.transform.parent = null;
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
{
return;
}
var container = (Group)Component;
if (null != container)
{
container.RemoveContentChild(childAdapter.Component);
}
}
public static void Run(ComponentAdapter adapter, AddEventHandlerPersistedData persistedData)
{
//if (EditorApplication.isPlaying)
//{
// //Debug.Log("Stopping...");
// EditorApplication.isPlaying = false;
//}
_adapter = adapter;
//Debug.Log("*** persistedData.ScriptPath: " + persistedData.ScriptPath);
//Debug.Log("*** persistedData.Snippet: " + persistedData.Snippet);
/**
* 4. Save file
* */
SaveFile(persistedData.ScriptPath, persistedData.Snippet);
}
/// <summary>
/// Instantiates
/// </summary>
/// <param name="childAdapter"></param>
/// <param name="register"></param>
override public void DoInstantiate(ComponentAdapter childAdapter, bool register)
{
if (!childAdapter.Instantiated)
{
childAdapter.DoInstantiate(register);
}
var scroller = (Scroller)Component;
if (null != scroller)
{
var group = childAdapter.Component as GroupBase;
if (null == group)
{
throw new Exception(string.Format(@"Scroller can have only a single child, extending the GroupBase ({0} supplied)", childAdapter.Component));
}
scroller.Viewport = group;
}
}
/// <summary>
/// Adds the content child
/// </summary>
/// <param name="child"></param>
/// <param name="register"></param>
override public void AddChild(ComponentAdapter child, bool register)
{
if (ContentChildren.Contains(child))
{
ContentChildren.Remove(child);
}
ContentChildren.Add(child);
if (child.FactoryMode)
{
return;
}
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
{
return;
}
DoInstantiate(child, register);
}
/// <summary>
/// Adds the content child at position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
/// <param name="register"></param>
override public void AddChildAt(int index, ComponentAdapter child, bool register)
{
ContentChildren.Remove(child);
if (ContentChildren.Count > 0)
{
throw new Exception("Only a single child is supported for Scroller");
}
ContentChildren.Add(child);
if (child.FactoryMode)
{
return;
}
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
{
return;
}
DoInstantiate(child, register);
}
/// <summary>
/// Changes the child position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
public virtual void Reorder(int index, ComponentAdapter child)
{
//Debug.Log("Reordering " + child);
AddChildAt(index, child, true);
}
private static void SetupDefaults(bool alt, ComponentAdapter adapter)
{
if (alt || EditorSettings.ExpandWidthUponCreation)
{
adapter.UseWidth = true;
adapter.UsePercentWidth = true;
adapter.Width = 100;
}
if (alt || EditorSettings.ExpandHeightUponCreation)
{
adapter.UseHeight = true;
adapter.UsePercentHeight = true;
adapter.Height = 100;
}
if (EditorSettings.FactoryModeUponCreation)
{
adapter.FactoryMode = true;
}
var skinnableComponentAdapter = adapter as SkinnableComponentAdapter;
if (skinnableComponentAdapter != null)
{
skinnableComponentAdapter.ApplySkin(EditorSettings.ApplyLastUsedSkinUponCreation);
}
}
private void LoadAvailableSkins(ComponentAdapter adapter)
{
var skins = EditorReflector.GetSkins(adapter.ComponentType).ToList();
#if DEBUG
if (true)
{
StringBuilder sb = new StringBuilder();
if (skins.Count == 0)
{
sb.AppendLine("No available skins.");
}
else
{
/*foreach (KeyValuePair<string, Type> pair in skins)
{
sb.AppendLine(string.Format(" {0} -> {1}", pair.Key, pair.Value));
}*/
foreach (var skin in skins)
{
sb.AppendLine(string.Format(" -> {0}", skin));
}
}
/*Debug.Log(string.Format(@"====== Skins ======
{0}", sb));*/
}
#endif
_availableSkinClasses = new List<string>();
//if (_couldNotLocateMapper)
// list.Add("=== Not found ===");
//list.Add("= Default =");
foreach (Type skinClass in skins)
{
_availableSkinClasses.Add(skinClass.FullName);
}
}
public static string GetDefaultEventName(ComponentAdapter adapter)
{
var list = Core.Reflection.CoreReflector.GetClassAttributes<DefaultEvent>(adapter.ComponentType);
if (list.Count == 0)
return null;
return list[0].Name;
}
protected bool CheckSelection(bool mustBeContainer, bool renderMessage = true)
{
if (null == Selection.activeTransform)
{
if (renderMessage)
GUILayout.Label(GuiContentCache.Instance.NoSelectionContent, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
return false;
}
Adapter = GuiLookup.GetAdapter(Selection.activeTransform);
GroupAdapter = Adapter as GroupAdapter;
if (null == Adapter)
{
if (renderMessage)
GUILayout.Label(GuiContentCache.Instance.NotEDrivenComponentContent, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
return false;
}
if (mustBeContainer && null == GroupAdapter)
{
if (renderMessage)
GUILayout.Label(GuiContentCache.Instance.NotAContainerContent, StyleCache.Instance.CenteredLabel, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
return false;
}
return true;
}
/// <summary>
/// Changes the child position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
public virtual void Reorder(int index, ComponentAdapter child)
{
//Debug.Log("Reordering " + child);
AddChildAt(index, child, true);
}
//public void Add(ComponentAdapter adapter)
//{
// if (_adapters.Contains(adapter))
// throw new Exception("Child group already contains adapter");
// _adapters.Add(adapter);
//}
public void Add(ComponentAdapter adapter)
{
if (_adapters.Contains(adapter))
throw new Exception("Child group already contains adapter");
_adapters.Add(adapter);
}
/// <summary>
/// Adds the content child at position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
/// <param name="register"></param>
override public void AddChildAt(int index, ComponentAdapter child, bool register)
{
ContentChildren.Remove(child);
if (ContentChildren.Count > 0)
{
throw new Exception("Only a single child is supported for Scroller");
}
ContentChildren.Add(child);
if (child.FactoryMode)
return;
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
return;
DoInstantiate(child, register);
}
/// <summary>
/// Adds the content child at position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
/// <param name="register"></param>
public virtual void AddChildAt(int index, ComponentAdapter child, bool register)
{
ContentChildren.Remove(child);
if (ContentChildren.Count >= index)
ContentChildren.Insert(index, child);
else
ContentChildren.Add(child);
if (child.FactoryMode)
return;
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
return;
DoInstantiateAt(child, index, register);
}
private static void CreateMapping(AddEventHandlerPersistedData persistedData, ComponentAdapter adapter)
{
EventMapping mapping = new EventMapping
{
EventType = persistedData.EventName,
ScriptName = persistedData.ClassName,
MethodName = persistedData.MethodName,
Phase = (EventPhase) persistedData.EventPhases
};
adapter.EventMap.Add(mapping);
//EventDisplay.Instance.Refresh(); // TODO: Crashes the app
}
private void DoInstantiateAt(ComponentAdapter childAdapter, int index, bool useAsInstance)
{
if (!childAdapter.Instantiated)
{
childAdapter.DoInstantiate(useAsInstance);
}
var container = (IContentChildList)Component;
if (null != container)
{
container.AddContentChildAt(childAdapter.Component, index);
}
}
/// <summary>
/// Instantiates
/// </summary>
/// <param name="childAdapter"></param>
/// <param name="register"></param>
public virtual void DoInstantiate(ComponentAdapter childAdapter, bool register)
{
if (!childAdapter.Instantiated)
{
childAdapter.DoInstantiate(register);
}
var container = Component as IContentChildList;
if (null == container)
{
Debug.LogError(Component.GetType().Name + " cannot host children");
return;
}
container.AddContentChild(childAdapter.Component);
}
/// <summary>
/// Changes the child position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
override public void Reorder(int index, ComponentAdapter child)
{
AddChildAt(index, child, true);
}
public void Remove(ComponentAdapter adapter)
{
if (!_adapters.Contains(adapter))
throw new Exception("Child group doesn't contains adapter");
_adapters.Remove(adapter);
}
/// <summary>
/// Gets child index
/// </summary>
/// <param name="child"></param>
/// <returns></returns>
override public int GetChildIndex(ComponentAdapter child)
{
return ContentChildren.FindIndex(delegate(ComponentAdapter componentAdapter)
{
return componentAdapter == child;
});
}
/// <summary>
/// Removes the childAdapter
/// </summary>
/// <param name="childAdapter"></param>
public virtual void RemoveChild(ComponentAdapter childAdapter)
{
if (null == childAdapter)
return;
ContentChildren.Remove(childAdapter);
childAdapter.transform.parent = null;
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
return;
var container = (IContentChildList)Component;
if (null != container)
{
container.RemoveContentChild(childAdapter.Component);
}
}
/// <summary>
/// Changes the child position
/// </summary>
/// <param name="index"></param>
/// <param name="child"></param>
override public void Reorder(int index, ComponentAdapter child)
{
AddChildAt(index, child, true);
}
/// <summary>
/// Instantiates
/// </summary>
/// <param name="childAdapter"></param>
/// <param name="register"></param>
override public void DoInstantiate(ComponentAdapter childAdapter, bool register)
{
if (!childAdapter.Instantiated)
{
childAdapter.DoInstantiate(register);
}
var scroller = (Scroller)Component;
if (null != scroller)
{
var group = childAdapter.Component as GroupBase;
if (null == group)
{
throw new Exception(string.Format(@"Scroller can have only a single child, extending the GroupBase ({0} supplied)", childAdapter.Component));
}
scroller.Viewport = group;
}
}
public void Insert(ComponentAdapter adapter, int index)
{
if (_adapters.Contains(adapter))
throw new Exception("Child group already contains adapter");
_adapters.Insert(index, adapter);
}
/// <summary>
/// Adds the content child
/// </summary>
/// <param name="child"></param>
/// <param name="register"></param>
override public void AddChild(ComponentAdapter child, bool register)
{
if (ContentChildren.Contains(child))
ContentChildren.Remove(child);
ContentChildren.Add(child);
if (child.FactoryMode)
return;
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
return;
DoInstantiate(child, register);
}
/// <summary>
///
/// </summary>
/// <param name="nodes"></param>
/// <param name="adapter"></param>
/// <returns></returns>
// ReSharper disable SuggestBaseTypeForParameter
private static Node GetNode(System.Collections.Generic.List<Node> nodes, ComponentAdapter adapter)
// ReSharper restore SuggestBaseTypeForParameter
{
return nodes.Find(delegate(Node node)
{
return node.Adapter == adapter;
});
}
private void FindSelectedSkinClassIndex(ComponentAdapter adapter, string value)
{
//Dictionary<string, Type> skins = new Dictionary<string, Type>();
//Debug.Log("FindSelectedStyleMapperIndex: " + value);
//var skin = adapter.SkinClass;
//ReflectionUtil.GetSkinClasses(adapter.ComponentType, ref skins);
LoadAvailableSkins(adapter);
_skinTemp = 0;
foreach (string skin in _availableSkinClasses)
{
if (skin == value)
{
break;
}
_skinTemp++;
}
_skinIndex = _skinTemp;
//Debug.Log("_skinIndex: " + _skinIndex);
_cannotFind = !string.IsNullOrEmpty(value) && !_availableSkinClasses.Contains(value);
//Debug.Log("_cannotFind: " + _cannotFind);
}
/// <summary>
/// Removes the childAdapter
/// </summary>
/// <param name="childAdapter"></param>
override public void RemoveChild(ComponentAdapter childAdapter)
{
ContentChildren.Remove(childAdapter);
childAdapter.transform.parent = null;
if (!Instantiated || !DesignerState.IsPlaying) // not instantiated
return;
var container = (Group)Component;
if (null != container)
{
container.RemoveContentChild(childAdapter.Component);
}
}
public static Dictionary<string, EventAttribute> GetEventsBubblingFromChildren(ComponentAdapter adapter)
{
var excludeList = new List<ComponentAdapter> { adapter };
Dictionary<string, EventAttribute> dict = new Dictionary<string, EventAttribute>();
GetEventsRecursive(adapter, adapter, ref dict, true, excludeList);
return dict;
}
