public AssemblyRow(Assembly assembly)
{
FullName = assembly.FullName;
DisplayName = $"Assembly: {assembly.GetName().Name}";
foreach (var type in assembly.GetTypes())
{
if (type.IsAbstract || type.IsInterface)
{
continue;
}
if (type.IsGenericType)
{
continue;
}
if (!typeof(Component).IsAssignableFrom(type))
{
#if INCLUDE_ALL_SERIALIZABLE_CONTAINERS
if (!CodeGenUtils.IsSerializableContainer(type))
#endif
continue;
}
var typeName = type.FullName;
if (string.IsNullOrEmpty(typeName))
{
continue;
}
var typeNamespace = type.Namespace;
var group = m_RootNamespaceGroup;
if (!string.IsNullOrEmpty(typeNamespace))
{
var namespaceParts = typeNamespace.Split('.');
foreach (var part in namespaceParts)
{
var lastGroup = group;
if (!group.Children.TryGetValue(part, out group))
{
group = new NamespaceGroup();
lastGroup.Children.Add(part, group);
}
}
}
var typeRow = new TypeRow(type);
var types = group.Types;
types.Add(typeRow);
}
m_RootNamespaceGroup.PostProcessRecursively();
m_GetAllNamespaces = GetAllNamespaces;
m_GetAllTypes = GetAllTypes;
m_RemoveAllNamespaces = RemoveAllNamespaces;
m_RemoveAllTypes = RemoveAllTypes;
}
public async Task WriteAsync(Document document)
{
Console.WriteLine($"Write Web resource .json file... [{_fileName}]");
IDictionary <Language, LanguageGroup> languages = new Dictionary <Language, LanguageGroup>();
foreach (var language in document.Languages)
{
if (!ApplyLanguageFilter(language))
{
continue;
}
languages.Add(language, new LanguageGroup());
}
foreach (var group in document.Groups)
{
foreach (var item in group.Items)
{
if (!ApplyWebPlatformFilter(item))
{
continue;
}
if (!ApplyAppFilter(item, _appsFilter))
{
continue;
}
var keys = SplitKey(item.Keys[Platforms.Web]);
foreach (var value in item.Values)
{
var language = value.Key;
if (!languages.ContainsKey(language))
{
continue;
}
var languageGroup = languages[language];
foreach (var key in keys)
{
NamespaceGroup namespaceGroup;
if (!languageGroup.Namespaces.ContainsKey(key.ns))
{
namespaceGroup = new NamespaceGroup();
languageGroup.Namespaces.Add(key.ns, namespaceGroup);
}
else
{
namespaceGroup = languageGroup.Namespaces[key.ns];
}
namespaceGroup.Translations.Add(key.value, value.Value);
}
}
}
}
var jDocument = new JObject();
foreach (var language in languages)
{
var languageId = language.Key.Id;
var jLanguage = new JObject();
jDocument.Add(new JProperty(languageId, jLanguage));
foreach (var ns in language.Value.Namespaces)
{
var jNs = new JObject();
jLanguage.Add(ns.Key, jNs);
foreach (var item in ns.Value.Translations)
{
jNs.Add(new JProperty(item.Key, item.Value));
}
}
}
using (StreamWriter sw = new StreamWriter(_fileName))
using (JsonWriter writer = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented
})
{
await jDocument.WriteToAsync(writer);
await sw.WriteLineAsync();
}
}
void DrawNamespaceGroup(NamespaceGroup group, List <string> excludedTypes, SerializedProperty excludedTypesProperty)
{
foreach (var kvp in group.children)
{
var groupName = kvp.Key;
var child = kvp.Value;
var wasExpanded = child.expanded;
var isExpanded = EditorGUILayout.Foldout(wasExpanded, groupName, true);
if (wasExpanded != isExpanded)
{
if (Event.current.alt)
{
child.SetExpandedRecursively(isExpanded);
}
else
{
child.expanded = isExpanded;
}
}
if (isExpanded)
{
using (new EditorGUI.IndentLevelScope())
{
DrawNamespaceGroup(kvp.Value, excludedTypes, excludedTypesProperty);
}
}
}
foreach (var row in group.modules)
{
var moduleType = row.type;
var show = row.show;
var excludeIndex = row.excludeIndex;
var included = excludeIndex == -1;
var disabled = included && row.isImmortal | row.dependentModules.Count > 0;
using (new EditorGUI.DisabledScope(disabled))
{
using (new GUILayout.HorizontalScope())
{
var readableTypeName = row.readableTypeName;
var serializableTypeName = moduleType.FullName;
show = EditorGUILayout.Foldout(show, readableTypeName, true);
row.show = show;
var indentedRect = EditorGUI.IndentedRect(Rect.zero);
var nowIncluded = EditorGUILayout.Toggle("", included, GUILayout.Width(k_ToggleWidth + indentedRect.x));
if (included && !nowIncluded)
{
var newIndex = excludedTypes.Count;
excludedTypesProperty.InsertArrayElementAtIndex(newIndex);
var element = excludedTypesProperty.GetArrayElementAtIndex(newIndex);
element.stringValue = serializableTypeName;
}
if (!included && nowIncluded)
{
excludedTypesProperty.DeleteArrayElementAtIndex(excludeIndex);
excludedTypes.RemoveAt(excludeIndex);
row.IncludeDependencies(m_ModuleRows, excludedTypes, excludedTypesProperty);
}
}
}
if (show)
{
DrawModuleDependencies(row);
}
}
}
public ModuleLoaderSettingsEditor()
{
foreach (var moduleType in k_ModuleTypes)
{
var moduleNamespace = moduleType.Namespace;
var group = m_RootNamespaceGroup;
if (!string.IsNullOrEmpty(moduleNamespace))
{
var namespaceParts = moduleNamespace.Split('.');
foreach (var part in namespaceParts)
{
var lastGroup = group;
if (!group.children.TryGetValue(part, out group))
{
group = new NamespaceGroup();
lastGroup.children.Add(part, group);
}
}
}
var moduleRow = new ModuleRow(moduleType);
group.modules.Add(moduleRow);
m_ModuleRows[moduleType] = moduleRow;
}
m_RootNamespaceGroup.SortModulesRecursively();
foreach (var moduleType in k_ModuleTypes)
{
foreach (var @interface in moduleType.GetInterfaces())
{
if (@interface.IsGenericType && @interface.GetGenericTypeDefinition() == typeof(IModuleDependency <>))
{
var genericArguments = @interface.GetGenericArguments();
if (genericArguments.Length != 1)
{
Debug.LogErrorFormat("Error drawing module row. {0} must have exactly one generic argument", @interface.Name);
continue;
}
var dependency = genericArguments[0];
ModuleRow row;
if (m_ModuleRows.TryGetValue(moduleType, out row))
{
row.dependencies.Add(dependency);
}
}
}
}
var scripts = MonoImporter.GetAllRuntimeMonoScripts();
foreach (var script in scripts)
{
var type = script.GetClass();
if (type == null)
{
continue;
}
ModuleRow row;
if (m_ModuleRows.TryGetValue(type, out row))
{
row.script = script;
}
}
}
// Constructor
public NamespaceNode(NamespaceGroup parent, BplNamespace bplNamespace) {
Parent = parent;
Namespace = bplNamespace;
Name = Namespace.Name;
Children = new List<ClassNode>();
foreach (var bplClass in Namespace.Classes) {
Children.Add(new ClassNode(this, bplClass));
}
UpdateSelection(true);
}
// Comparer
public static int Comparer(NamespaceGroup ns1, NamespaceGroup ns2) {
if (ns1.SortOrder < ns2.SortOrder) {
return -1;
} else if (ns1.SortOrder > ns2.SortOrder) {
return +1;
} else {
return String.CompareOrdinal(ns1.Name, ns2.Name);
}
}
// Constructor
public NamespaceTree(IEnumerable<BplNamespace> namespaces) {
Groups = new List<NamespaceGroup>();
foreach (var group in namespaces.OrderBy(ns => ns.Name).GroupBy(ns => ns.Category)) {
var groupNode = new NamespaceGroup(group.Key, group);
Groups.Add(groupNode);
}
Groups.Sort(NamespaceGroup.Comparer);
}
