public static List <Type> GetAllUnityComponents()
{
if (null == _availableUnityComponents)
{
var types = GuiReflector.GetAllLoadedTypesAsignableFrom(typeof(Component)); // UnityEngine.Component
#if DEBUG
if (DebugMode)
{
StringBuilder sb = new StringBuilder();
if (types.Count == 0)
{
sb.AppendLine("No styleable classes available.");
}
else
{
foreach (Type type in types)
{
sb.AppendLine(string.Format(" -> {0}", type));
}
}
Debug.Log(string.Format(@"====== Unity components ======
{0}", sb));
}
#endif
_availableUnityComponents = types;
//Debug.Log("_availableUnityComponents: " + _availableUnityComponents.Count);
}
return(_availableUnityComponents);
}
/// <summary>
/// Initializes the Singleton instance
/// </summary>
private void Initialize()
{
_adapters = new Dictionary <Type, StyleClientAdapterBase>();
var adapters = GuiReflector.GetAllLoadedTypesDecoratedWith(typeof(StyleClientAdapterAttribute));
#if DEBUG
if (DebugMode)
{
Debug.Log(string.Format(@"Found {0} adapters", adapters.Count));
}
#endif
foreach (var adapter in adapters)
{
if (!(typeof(StyleClientAdapterBase).IsAssignableFrom(adapter)))
{
throw new Exception(string.Format("{0} is not StyleClientAdapterBase", adapter));
}
var attributes = CoreReflector.GetClassAttributes <StyleClientAdapterAttribute>(adapter);
var client = (StyleClientAdapterBase)Activator.CreateInstance(adapter);
_adapters[attributes[0].Type] = client;
}
#if DEBUG
if (DebugMode)
{
Debug.Log(string.Format(@"Retrieved {0} style client adapters:
{1}", _adapters.Count, DictionaryUtil <Type, StyleClientAdapterBase> .Format(_adapters)));
}
#endif
}
/*private static int ClassNameSort(Type x, Type y)
* {
* return String.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);
* }*/
#endregion
#region Skin parts
/// <summary>
/// Describes skin parts
/// </summary>
/// <param name="componentType"></param>
/// <returns></returns>
public static string GetSkinParts(Type componentType)
{
if (!typeof(SkinnableComponent).IsAssignableFrom(componentType))
{
return(string.Format(@"Skin parts: Not a skinnable component." + NewLine + NewLine));
}
var dict = GuiReflector.GetSkinParts(componentType); // string->bool
var list = new List <string>();
foreach (string key in dict.Keys)
{
list.Add(key);
}
list.Sort();
StringBuilder sb = new StringBuilder();
foreach (var name in list)
{
MemberWrapper mw = new MemberWrapper(componentType, name);
sb.AppendLine(string.Format("{0} [Type: {1}, Required: {2}]", name, mw.MemberType, dict[name]));
}
return(string.Format(@"Skin parts ({0}):
{1}
{2}", list.Count, Line, sb) + NewLine /* + NewLine*/);
}
/// <summary>
/// Used by designer
/// </summary>
/// <param name="componentType"></param>
public static List <Type> GetSkinClasses(Type componentType)
{
List <Type> list = new List <Type>();
//Debug.Log("componentType: " + componentType);
if (!componentType.IsSubclassOf(typeof(SkinnableComponent)))
{
//Debug.LogError("Component is not a subclass of SkinnableComponent: " + componentType);
return(list);
}
List <Type> types = GuiReflector.GetAllLoadedTypes();
foreach (Type type in types)
{
if (!type.IsClass)
{
continue;
}
if (!type.IsSubclassOf(typeof(Skin)))
{
continue;
}
var componentTypeSpecifiedInAttribute = SkinUtil.GetHostComponent(type);
if (componentTypeSpecifiedInAttribute == componentType)
{
list.Add(type);
}
}
return(list);
}
public static Type GetTypeByClassName(string className)
{
var types = GuiReflector.GetAllLoadedTypes();
return(types.Find(delegate(Type t)
{
return /*t.Namespace == nameSpace && */ t.Name == className;
}));
}
//private static List<Type> _allTypes;
//public static List<Type> GetAllLoadedTypes()
//{
// /**
// * 1. Get all types for all loaded assemblies
// * This is done only when componet tab expanded, so is no performance issue
// * */
// if (null == _allTypes)
// {
// _allTypes = new List<Type>();
// Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
// foreach (Assembly assembly in loadedAssemblies)
// {
// _allTypes.AddRange(assembly.GetTypes());
// }
// }
// return _allTypes;
//}
public static bool IsUniqueScriptName(string className)
{
var types = GuiReflector.GetAllLoadedTypes();
//Debug.Log(string.Format(@"nameToTest: {0}", className));
//Debug.Log(string.Format(@"types: {0}", types.Count));
bool found = types.Exists(delegate(Type t)
{
return /*t.Namespace == nameSpace && */ (t.Name == className);
});
return(!found);
}
internal void RefreshComponentList()
{
_showComponents = EditorSettings.ReferenceShowComponents;
_showSkinnableComponents = EditorSettings.ReferenceShowSkinnableComponents;
_showSkins = EditorSettings.ReferenceShowSkins;
_selectedIndex = -1;
_selectionChanged = false;
_classes.Clear();
var allClasses = GuiReflector.GetAllLoadedTypes();
foreach (var type in allClasses)
{
if (typeof(Component).IsAssignableFrom(type))
{
if (!string.IsNullOrEmpty(_searchText) && !PassesSearchFilter(type.FullName, _searchText))
{
/*!type.FullName.ToUpper().Contains(_searchText.ToUpper())*/
continue;
}
_classes.Add(type);
}
}
_classes.Sort(TypeSort);
//Debug.Log("_classes: " + _classes.Count);
List <GUIContent> contentList = new List <GUIContent>();
foreach (var @class in _classes)
{
var isSkinnableComponent = typeof(SkinnableComponent).IsAssignableFrom(@class);
var isSkin = typeof(Skin).IsAssignableFrom(@class);
var isSimpleComponent = !isSkinnableComponent && !isSkin;
var texture = GuiComponentEvaluator.EvaluateComponentRowIcon(@class);
if (_showComponents && isSimpleComponent ||
_showSkinnableComponents && isSkinnableComponent ||
_showSkins && isSkin)
{
contentList.Add(new GUIContent(" " + @class.FullName, texture));
}
}
_contents = contentList.ToArray();
//Debug.Log("_contents: " + _contents.Length);
}
/// <summary>
/// Initializes the Singleton instance
/// </summary>
private void Initialize()
{
_allModules.Clear();
//var providerTypes = ReflectionUtil.GetAllLoadedTypesDecoratedWith(typeof (StyleModuleAttribute));
var moduleTypes = GuiReflector.GetAllLoadedTypesAsignableFrom(typeof(StyleModuleBase));
foreach (var moduleType in moduleTypes)
{
if (moduleType == typeof(StyleModuleBase))
{
continue; // skip the abstract class
}
var module = (StyleModuleBase)Activator.CreateInstance(moduleType);
module.ReflectAttribute();
_allModules.Add(module);
}
}
/// <summary>
/// Describes skin states
/// </summary>
/// <param name="componentType"></param>
/// <returns></returns>
public static string GetSkinStates(Type componentType)
{
if (!typeof(SkinnableComponent).IsAssignableFrom(componentType))
{
return(string.Format(@"Skin states: Not a skinnable component." + NewLine + NewLine));
}
var list = GuiReflector.GetSkinStates(componentType); // string->bool
StringBuilder sb = new StringBuilder();
foreach (var name in list)
{
sb.AppendLine(name);
}
return(string.Format(@"Skin states ({0}):
{1}
{2}", list.Count, Line, sb) + NewLine /* + NewLine*/);
}
public static Type GetTypeByFullName(string name)
{
if (null == _allTypesDict)
{
_allTypesDict = new Dictionary <string, Type>();
//Type myType = Type.GetType(name);
var allTypes = GuiReflector.GetAllLoadedTypes();
foreach (Type type in allTypes)
{
_allTypesDict[type.FullName] = type;
}
}
if (_allTypesDict.ContainsKey(name))
{
return(_allTypesDict[name]);
}
return(null);
}
/// <summary>
/// Looks for all descriptor classes in running assemblies via reflection
/// </summary>
public static void Initialize()
{
//Debug.Log("Initialize");
var toolbox = Toolbox.Instance;
toolbox.Clear();
/**
* 1. Get all types for all loaded assemblies
* This is done only when componet tab expanded, so is no performance issue
* */
List <Type> types = GuiReflector.GetAllLoadedTypes();
foreach (Type type in types)
{
if (type.IsClass)
{
if (type.IsSubclassOf(typeof(ComponentAdapter)))
{
string icon = string.Empty;
string label = string.Empty;
string groupName = string.Empty;
string tooltip = string.Empty;
//ToolboxAttribute[] toolboxAttributes = (ToolboxAttribute[])type.GetCustomAttributes(typeof(ToolboxAttribute), true);
var toolboxAttributes = Core.Reflection.CoreReflector.GetClassAttributes <ToolboxAttribute>(type);
if (toolboxAttributes.Count > 0)
{
var attr = toolboxAttributes[0];
label = attr.Label;
icon = attr.Icon;
tooltip = attr.Tooltip;
groupName = attr.Group;
}
Texture iconTexture = null;
if (!string.IsNullOrEmpty(icon))
{
iconTexture = (Texture)Resources.Load(icon);
}
if (string.IsNullOrEmpty(label))
{
label = type.Name.Replace("Adapter", string.Empty);
}
var desc = new ComponentTypeDesc(label, type, iconTexture, tooltip);
if (type.IsAbstract)
{
continue; // skip abstract classes (SkinnableComponentAdapter etc.)
}
/**
* 1. Stage
* */
if (type == typeof(StageAdapter))
{
Toolbox.Instance.StageContent = desc.GetContent();
continue;
}
/**
* 2. Named group
* */
if (!string.IsNullOrEmpty(groupName))
{
desc.Group = groupName;
toolbox.Add(desc);
continue;
}
/**
* 3. Group
* */
//if (type == typeof (GroupAdapter) || type.IsSubclassOf(typeof (GroupAdapter)))
if (typeof(GroupAdapter).IsAssignableFrom(type))
{
desc.Group = "Containers";
toolbox.Add(desc);
continue;
}
/**
* 4. Component
* */
desc.Group = "Components";
toolbox.Add(desc);
}
}
}
toolbox.Process();
}
/// <summary>
/// Re-scanns all the media queries on demand
/// </summary>
/// <exception cref="Exception"></exception>
public void Rescan()
{
_methodInfos = new Dictionary <string, MethodInfo>();
_queries = new Dictionary <string, MediaQuery>();
/*foreach (Type type in GlobalTypeDictionary.Instance.Values)
* {
* if (typeof(MediaQueryBase).IsAssignableFrom(type) && typeof(MediaQueryBase) != type)
* {
* MediaQueryBase query = (MediaQueryBase)Activator.CreateInstance(type);
* _queries[query.Id] = query;
* }
* }*/
var queries = GuiReflector.GetMethodsInAllLoadedTypesDecoratedWith(typeof(MediaQueryAttribute));
#if DEBUG
if (DebugMode)
{
Debug.Log(string.Format(@"Found {0} media queries", queries.Count));
}
#endif
foreach (var methodInfo in queries)
{
if (null == methodInfo.ReturnParameter || methodInfo.ReturnType != typeof(bool))
{
throw new Exception(@"Method decorated with MediaQuery attribute should return a boolean value:
" + methodInfo);
}
var p = methodInfo.GetParameters();
var parameters = new List <Type>();
foreach (var parameterInfo in p)
{
parameters.Add(parameterInfo.ParameterType);
}
// get attribute
var attributes = CoreReflector.GetMethodAttributes <MediaQueryAttribute>(methodInfo);
if (attributes.Count == 0)
{
throw new Exception(@"Cannot find MediaQuery attribute:
" + methodInfo);
}
var attribute = attributes[0];
/**
* If there is already an existing query with a same ID, allow overriding
* only if this is an editor override. This way we'll get all the editor overrides
* override the Play mode media queries.
* */
if (_methodInfos.ContainsKey(attribute.Id) && !attribute.EditorOverride)
{
continue;
}
_methodInfos[attribute.Id] = methodInfo;
MediaQuery query;
if (parameters.Count > 0)
{
var type = parameters[0];
query = (MediaQuery)NameValueBase.CreateProperty <MediaQuery>(attribute.Id, type);
//query.Value = type.
}
else
{
query = new MediaQuery
{
Name = attribute.Id,
Parameters = parameters.ToArray()
};
}
_queries[attribute.Id] = query;
}
#if DEBUG
if (DebugMode)
{
Debug.Log(string.Format(@"Number of queries after overrides: {0}", _queries.Keys.Count));
}
#endif
#if DEBUG
if (DebugMode)
{
Debug.Log(string.Format(@"Retrieved {0} media queries:
{1}", _queries.Count, DictionaryUtil <string, MediaQuery> .Format(_queries)));
}
#endif
}
