/*
* Template can contains:
*
* {NAMESPACE_NAME}
* {CLASS_NAME}
* {BASE_CLASS_NAME}
* {CLASS_NAME_WITH_NAMESPACE}
*/
public static string ReplaceText(string text, Tpl.Info oldInfo, Tpl.Info newInfo)
{
var file = Resources.Load("UI.Windows/Templates/TemplateReplaceRules") as TextAsset;
if (file == null)
{
Debug.LogError("Template Loading Error: Could not load template 'TemplateReplaceRules'");
return(text);
}
var path = AssetDatabase.GetAssetPath(file);
var replaceRules = System.IO.File.ReadAllLines(path);
//text = text.Replace(oldInfo.baseNamespace, newInfo.baseNamespace);
for (int i = 0; i < replaceRules.Length; ++i)
{
// Prepare rule
var replace = replaceRules[i];
replace = replace.Replace(" ", @"\s?");
replace = replace.Replace("(", @"\(").Replace(")", @"\)");
replace = oldInfo.Replace(replace, (r) => r.Replace("{VARIABLE}", "([a-zA-Z]+[a-zA-Z0-9]*)"));
var replacement = replaceRules[i];
replacement = newInfo.Replace(replacement, (r) => r.Replace("{VARIABLE}", "$1"));
var pattern = @"" + replace + "";
var rgx = new Regex(pattern, RegexOptions.Singleline);
text = rgx.Replace(text, replacement);
}
return(text);
}
private static void Generate(string pathToData, bool recompile, bool minimalScriptsSize, System.Func <FD.FlowWindow, bool> predicate)
{
var filename = Path.GetFileName(pathToData);
if (string.IsNullOrEmpty(pathToData) == true)
{
throw new Exception(string.Format("`pathToData` is wrong: {0}. Filename: {1}", pathToData, filename));
}
var directory = pathToData.Replace(filename, string.Empty);
CompilerSystem.currentProject = Path.GetFileNameWithoutExtension(pathToData);
CompilerSystem.currentProjectDirectory = directory;
var basePath = directory + CompilerSystem.currentProject;
IO.CreateDirectory(basePath, string.Empty);
IO.CreateDirectory(basePath, FlowDatabase.OTHER_NAME);
predicate = predicate ?? delegate { return(true); };
AssetDatabase.StartAssetEditing();
{
try {
var windows = FlowSystem.GetContainersAndWindows().Where(w => w.CanCompiled() && predicate(w));
//var windows = FlowSystem.GetContainers().Where(w => w.CanCompiled() && predicate(w));
foreach (var each in windows)
{
var relativePath = IO.GetRelativePath(each, "/");
CompilerSystem.GenerateWindow(string.Format("{0}{1}/", basePath, relativePath), each, recompile, minimalScriptsSize);
}
// Generate Base Files
var newInfo = new Tpl.Info(CompilerSystem.currentNamespace, "Container", "ContainerBase", "LayoutWindowType", basePath);
var baseClassTemplate = TemplateGenerator.GenerateWindowLayoutContainerBaseClass(newInfo.baseClassname, newInfo.baseNamespace, newInfo.containerClassName);
var derivedClassTemplate = TemplateGenerator.GenerateWindowLayoutDerivedClass(newInfo.classname, newInfo.baseClassname, newInfo.baseNamespace);
IO.CreateFile(basePath, newInfo.baseClassnameFile, baseClassTemplate, rewrite: true);
IO.CreateFile(basePath, newInfo.classnameFile, derivedClassTemplate, rewrite: false);
} catch (Exception e) {
if (UnityEngine.UI.Windows.Constants.LOGS_ENABLED == true)
{
UnityEngine.Debug.LogException(e);
}
}
}
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
FlowSystem.SetDirty();
FlowSystem.Save();
}
/*
* private static bool CompiledInfoIsInvalid( FlowWindow flowWindow ) {
*
* return GetBaseClassName( flowWindow ) != flowWindow.compiledBaseClassName
|| GetNamespace( flowWindow ) != flowWindow.compiledNamespace;
||}
||
||private static void UpdateInheritedClasses( string oldBaseClassName, string newBaseClassName, string oldDerivedClassName, string newDerivedClassName, string oldNamespace, string newNamespace ) {
||
|| if ( string.IsNullOrEmpty( oldBaseClassName ) || string.IsNullOrEmpty( newBaseClassName ) ) {
||
|| return;
|| }
||
|| var oldFullClassPath = oldNamespace + oldBaseClassName;
|| var newFullClassPath = newNamespace + newBaseClassName;
||
|| AssetDatabase.StartAssetEditing();
||
|| try {
||
|| var scripts =
|| AssetDatabase.FindAssets( "t:MonoScript" )
|| .Select( _ => AssetDatabase.GUIDToAssetPath( _ ) )
|| .Select( _ => AssetDatabase.LoadAssetAtPath( _, typeof( MonoScript ) ) )
|| .OfType<MonoScript>()
|| .Where( _ => _.text.Contains( oldBaseClassName ) || _.text.Contains( oldDerivedClassName ) || _.text.Contains( oldNamespace ) )
|| .Where( _ => _.name != newBaseClassName );
||
|| foreach ( var each in scripts ) {
||
|| var path = AssetDatabase.GetAssetPath( each );
||
|| var lines = File.ReadAllLines( path );
||
|| var writer = new StreamWriter( path );
||
|| foreach ( var line in lines ) {
||
|| writer.WriteLine( line.Replace( oldFullClassPath, newFullClassPath )
|| .Replace( oldNamespace, newNamespace )
|| .Replace( oldBaseClassName, newBaseClassName )
|| .Replace( oldDerivedClassName, newDerivedClassName ) );
|| }
||
|| writer.Dispose();
|| }
|| } catch ( Exception e ) { Debug.LogException( e ); }
||
|| AssetDatabase.StopAssetEditing();
|| AssetDatabase.Refresh( ImportAssetOptions.ForceUpdate );
||
||}
||
||private static void GenerateUIWindow( string fullpath, FlowWindow window, bool recompile = false ) {
||
|| var isCompiledInfoInvalid = window.compiled && CompiledInfoIsInvalid( window );
||
|| if ( window.compiled == false || recompile == true || isCompiledInfoInvalid ) {
||
|| var baseClassName = GetBaseClassName( window );
|| var derivedClassName = GetDerivedClassName( window );
|| var classNamespace = GetNamespace( window );
||
|| var baseClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutBaseClass( baseClassName, classNamespace, GenerateTransitionMethods( window ) );
|| var derivedClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutDerivedClass( derivedClassName, baseClassName, classNamespace );
||
#if !UNITY_WEBPLAYER
|| var baseClassPath = ( fullpath + "/" + baseClassName + ".cs" ).Replace( "//", "/" );
|| var derivedClassPath = ( fullpath + "/" + derivedClassName + ".cs" ).Replace( "//", "/" );
#endif
||
|| if ( baseClassTemplate != null && derivedClassTemplate != null ) {
||
|| IO.CreateDirectory( fullpath, string.Empty );
|| IO.CreateDirectory( fullpath, FlowDatabase.COMPONENTS_FOLDER );
|| IO.CreateDirectory( fullpath, FlowDatabase.LAYOUT_FOLDER );
|| IO.CreateDirectory( fullpath, FlowDatabase.SCREENS_FOLDER );
||
#if !UNITY_WEBPLAYER
||
|| Directory.CreateDirectory( fullpath );
||
|| File.WriteAllText( baseClassPath, baseClassTemplate );
||
|| if ( !File.Exists( derivedClassPath ) ) {
||
|| File.WriteAllText( derivedClassPath, derivedClassTemplate );
||
|| AssetDatabase.ImportAsset( derivedClassName );
|| }
||
|| AssetDatabase.ImportAsset( baseClassPath );
||
#endif
||
|| } else {
||
|| return;
|| }
||
|| var oldBaseClassName = window.compiledBaseClassName;
|| var newBaseClassName = baseClassName;
|| var oldDerivedClassName = window.compiledDerivedClassName;
|| var newDerivedClassName = derivedClassName;
||
|| var oldNamespace = window.compiledNamespace;
||
|| window.compiledBaseClassName = baseClassName;
|| window.compiledDerivedClassName = derivedClassName;
|| window.compiledNamespace = classNamespace;
||
|| var newNamespace = window.compiledNamespace;
||
|| window.compiledDirectory = fullpath;
||
|| window.compiled = true;
||
|| AssetDatabase.Refresh( ImportAssetOptions.ForceUpdate );
||
|| if ( isCompiledInfoInvalid ) {
||
|| EditorApplication.delayCall += () => UpdateInheritedClasses( oldBaseClassName, newBaseClassName, oldDerivedClassName, newDerivedClassName, oldNamespace, newNamespace );
|| }
|| }
||
||}
||
||public static void GenerateUI( string pathToData, bool recompile = false, Func<FlowWindow, bool> predicate = null ) {
||
|| var filename = Path.GetFileName( pathToData );
|| var directory = pathToData.Replace( filename, "" );
||
|| currentProject = Path.GetFileNameWithoutExtension( pathToData );
|| var basePath = directory + currentProject;
||
|| CreateDirectory( basePath, string.Empty );
|| CreateDirectory( basePath, FlowDatabase.OTHER_NAME );
||
|| AssetDatabase.StartAssetEditing();
||
|| predicate = predicate ?? delegate { return true; };
||
|| try {
||
|| foreach ( var each in FlowSystem.GetWindows().Where( _ => !_.isDefaultLink && predicate( _ ) ) ) {
||
|| var relativePath = GetRelativePath( each, "/" );
||
|| if ( !string.IsNullOrEmpty( each.directory ) ) {
||
|| CreateDirectory( basePath, relativePath );
|| }
||
|| GenerateUIWindow( basePath + relativePath + "/", each, recompile );
|| }
|| } catch ( Exception e ) {
||
|| Debug.LogException( e );
|| }
||
|| AssetDatabase.StopAssetEditing();
|| AssetDatabase.Refresh( ImportAssetOptions.ForceUpdate );
||
||}*/
#endregion
private static void GenerateWindow(string newPath, FlowWindow window, bool recompile)
{
if (window.compiled == true && recompile == false)
{
return;
}
var oldPath = window.compiledDirectory;
var newInfo = new Tpl.Info(Tpl.GetNamespace(window), Tpl.GetDerivedClassName(window), Tpl.GetBaseClassName(window), window.directory);
var oldInfo = new Tpl.Info(window);
if (string.IsNullOrEmpty(oldPath) == true)
{
oldPath = newPath;
}
var path = oldPath;
if (window.compiled == true && (oldPath != newPath))
{
// If window is moving and compiled - just rename
// Replace in files
IO.ReplaceInFiles(FlowCompilerSystem.currentProjectDirectory, (file) => {
var text = file.text;
return(text.Contains(oldInfo.baseNamespace));
}, (text) => {
return(Tpl.ReplaceText(text, oldInfo, newInfo));
});
// Rename base class name
IO.RenameFile(oldPath + oldInfo.baseClassnameFile, oldPath + newInfo.baseClassnameFile);
// Rename derived class name
IO.RenameFile(oldPath + oldInfo.classnameFile, oldPath + newInfo.classnameFile);
// Rename main folder
IO.RenameDirectory(oldPath, newPath);
path = newPath;
}
// Rebuild without rename
//Debug.Log(window.title + " :: REBUILD BASE :: " + path);
IO.CreateDirectory(path, string.Empty);
IO.CreateDirectory(path, FlowDatabase.COMPONENTS_FOLDER);
IO.CreateDirectory(path, FlowDatabase.LAYOUT_FOLDER);
IO.CreateDirectory(path, FlowDatabase.SCREENS_FOLDER);
var baseClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutBaseClass(newInfo.baseClassname, newInfo.baseNamespace, Tpl.GenerateTransitionMethods(window));
var derivedClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutDerivedClass(newInfo.classname, newInfo.baseClassname, newInfo.baseNamespace);
if (baseClassTemplate != null && derivedClassTemplate != null)
{
IO.CreateFile(path, newInfo.baseClassnameFile, baseClassTemplate, rewrite: true);
IO.CreateFile(path, newInfo.classnameFile, derivedClassTemplate, rewrite: false);
}
window.compiledNamespace = newInfo.baseNamespace;
window.compiledScreenName = newInfo.screenName;
window.compiledBaseClassName = newInfo.baseClassname;
window.compiledDerivedClassName = newInfo.classname;
window.compiledDirectory = path;
window.compiled = true;
}
/*
private static bool CompiledInfoIsInvalid( FlowWindow flowWindow ) {
return GetBaseClassName( flowWindow ) != flowWindow.compiledBaseClassName
|| GetNamespace( flowWindow ) != flowWindow.compiledNamespace;
}
private static void UpdateInheritedClasses( string oldBaseClassName, string newBaseClassName, string oldDerivedClassName, string newDerivedClassName, string oldNamespace, string newNamespace ) {
if ( string.IsNullOrEmpty( oldBaseClassName ) || string.IsNullOrEmpty( newBaseClassName ) ) {
return;
}
var oldFullClassPath = oldNamespace + oldBaseClassName;
var newFullClassPath = newNamespace + newBaseClassName;
AssetDatabase.StartAssetEditing();
try {
var scripts =
AssetDatabase.FindAssets( "t:MonoScript" )
.Select( _ => AssetDatabase.GUIDToAssetPath( _ ) )
.Select( _ => AssetDatabase.LoadAssetAtPath( _, typeof( MonoScript ) ) )
.OfType<MonoScript>()
.Where( _ => _.text.Contains( oldBaseClassName ) || _.text.Contains( oldDerivedClassName ) || _.text.Contains( oldNamespace ) )
.Where( _ => _.name != newBaseClassName );
foreach ( var each in scripts ) {
var path = AssetDatabase.GetAssetPath( each );
var lines = File.ReadAllLines( path );
var writer = new StreamWriter( path );
foreach ( var line in lines ) {
writer.WriteLine( line.Replace( oldFullClassPath, newFullClassPath )
.Replace( oldNamespace, newNamespace )
.Replace( oldBaseClassName, newBaseClassName )
.Replace( oldDerivedClassName, newDerivedClassName ) );
}
writer.Dispose();
}
} catch ( Exception e ) { Debug.LogException( e ); }
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh( ImportAssetOptions.ForceUpdate );
}
private static void GenerateUIWindow( string fullpath, FlowWindow window, bool recompile = false ) {
var isCompiledInfoInvalid = window.compiled && CompiledInfoIsInvalid( window );
if ( window.compiled == false || recompile == true || isCompiledInfoInvalid ) {
var baseClassName = GetBaseClassName( window );
var derivedClassName = GetDerivedClassName( window );
var classNamespace = GetNamespace( window );
var baseClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutBaseClass( baseClassName, classNamespace, GenerateTransitionMethods( window ) );
var derivedClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutDerivedClass( derivedClassName, baseClassName, classNamespace );
#if !UNITY_WEBPLAYER
var baseClassPath = ( fullpath + "/" + baseClassName + ".cs" ).Replace( "//", "/" );
var derivedClassPath = ( fullpath + "/" + derivedClassName + ".cs" ).Replace( "//", "/" );
#endif
if ( baseClassTemplate != null && derivedClassTemplate != null ) {
IO.CreateDirectory( fullpath, string.Empty );
IO.CreateDirectory( fullpath, FlowDatabase.COMPONENTS_FOLDER );
IO.CreateDirectory( fullpath, FlowDatabase.LAYOUT_FOLDER );
IO.CreateDirectory( fullpath, FlowDatabase.SCREENS_FOLDER );
#if !UNITY_WEBPLAYER
Directory.CreateDirectory( fullpath );
File.WriteAllText( baseClassPath, baseClassTemplate );
if ( !File.Exists( derivedClassPath ) ) {
File.WriteAllText( derivedClassPath, derivedClassTemplate );
AssetDatabase.ImportAsset( derivedClassName );
}
AssetDatabase.ImportAsset( baseClassPath );
#endif
} else {
return;
}
var oldBaseClassName = window.compiledBaseClassName;
var newBaseClassName = baseClassName;
var oldDerivedClassName = window.compiledDerivedClassName;
var newDerivedClassName = derivedClassName;
var oldNamespace = window.compiledNamespace;
window.compiledBaseClassName = baseClassName;
window.compiledDerivedClassName = derivedClassName;
window.compiledNamespace = classNamespace;
var newNamespace = window.compiledNamespace;
window.compiledDirectory = fullpath;
window.compiled = true;
AssetDatabase.Refresh( ImportAssetOptions.ForceUpdate );
if ( isCompiledInfoInvalid ) {
EditorApplication.delayCall += () => UpdateInheritedClasses( oldBaseClassName, newBaseClassName, oldDerivedClassName, newDerivedClassName, oldNamespace, newNamespace );
}
}
}
public static void GenerateUI( string pathToData, bool recompile = false, Func<FlowWindow, bool> predicate = null ) {
var filename = Path.GetFileName( pathToData );
var directory = pathToData.Replace( filename, "" );
currentProject = Path.GetFileNameWithoutExtension( pathToData );
var basePath = directory + currentProject;
CreateDirectory( basePath, string.Empty );
CreateDirectory( basePath, FlowDatabase.OTHER_NAME );
AssetDatabase.StartAssetEditing();
predicate = predicate ?? delegate { return true; };
try {
foreach ( var each in FlowSystem.GetWindows().Where( _ => !_.isDefaultLink && predicate( _ ) ) ) {
var relativePath = GetRelativePath( each, "/" );
if ( !string.IsNullOrEmpty( each.directory ) ) {
CreateDirectory( basePath, relativePath );
}
GenerateUIWindow( basePath + relativePath + "/", each, recompile );
}
} catch ( Exception e ) {
Debug.LogException( e );
}
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh( ImportAssetOptions.ForceUpdate );
}*/
#endregion
private static void GenerateWindow(string newPath, FlowWindow window, bool recompile) {
if (window.compiled == true && recompile == false) return;
var oldPath = window.compiledDirectory;
var newInfo = new Tpl.Info(Tpl.GetNamespace(window), Tpl.GetDerivedClassName(window), Tpl.GetBaseClassName(window), window.directory);
var oldInfo = new Tpl.Info(window);
if (string.IsNullOrEmpty(oldPath) == true) {
oldPath = newPath;
}
var path = oldPath;
if (window.compiled == true && (oldPath != newPath)) {
// If window is moving and compiled - just rename
// Replace in files
IO.ReplaceInFiles(FlowCompilerSystem.currentProjectDirectory, (file) => {
var text = file.text;
return text.Contains(oldInfo.baseNamespace);
}, (text) => {
return Tpl.ReplaceText(text, oldInfo, newInfo);
});
// Rename base class name
IO.RenameFile(oldPath + oldInfo.baseClassnameFile, oldPath + newInfo.baseClassnameFile);
// Rename derived class name
IO.RenameFile(oldPath + oldInfo.classnameFile, oldPath + newInfo.classnameFile);
// Rename main folder
IO.RenameDirectory(oldPath, newPath);
path = newPath;
}
// Rebuild without rename
//Debug.Log(window.title + " :: REBUILD BASE :: " + path);
IO.CreateDirectory(path, string.Empty);
IO.CreateDirectory(path, FlowDatabase.COMPONENTS_FOLDER);
IO.CreateDirectory(path, FlowDatabase.LAYOUT_FOLDER);
IO.CreateDirectory(path, FlowDatabase.SCREENS_FOLDER);
var baseClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutBaseClass(newInfo.baseClassname, newInfo.baseNamespace, Tpl.GenerateTransitionMethods(window));
var derivedClassTemplate = FlowTemplateGenerator.GenerateWindowLayoutDerivedClass(newInfo.classname, newInfo.baseClassname, newInfo.baseNamespace);
if (baseClassTemplate != null && derivedClassTemplate != null) {
IO.CreateFile(path, newInfo.baseClassnameFile, baseClassTemplate, rewrite: true);
IO.CreateFile(path, newInfo.classnameFile, derivedClassTemplate, rewrite: false);
}
window.compiledNamespace = newInfo.baseNamespace;
window.compiledScreenName = newInfo.screenName;
window.compiledBaseClassName = newInfo.baseClassname;
window.compiledDerivedClassName = newInfo.classname;
window.compiledDirectory = path;
window.compiled = true;
}
private static void GenerateWindow(string newPath, FD.FlowWindow window, bool recompile, bool minimalScriptsSize)
{
if (window.compiled == true && recompile == false)
{
return;
}
var oldPath = window.compiledDirectory;
var newInfo = new Tpl.Info(Tpl.GetNamespace(window), Tpl.GetDerivedClassName(window), Tpl.GetBaseClassName(window), Tpl.GetContainerClassName(window), window.directory);
var oldInfo = new Tpl.Info(window);
if (string.IsNullOrEmpty(oldPath) == true)
{
oldPath = newPath;
}
var path = oldPath;
if (window.compiled == true && (oldPath != newPath))
{
// If window is moving and compiled - just rename
// Replace in files
IO.ReplaceInFiles(CompilerSystem.currentProjectDirectory, (file) => {
var text = file.text;
return(text.Contains(oldInfo.baseNamespace));
}, (text) => {
return(Tpl.ReplaceText(text, oldInfo, newInfo));
});
// Rename base class name
IO.RenameFile(oldPath + oldInfo.baseClassnameFile, oldPath + newInfo.baseClassnameFile);
// Rename derived class name
IO.RenameFile(oldPath + oldInfo.classnameFile, oldPath + newInfo.classnameFile);
// Rename main folder
IO.RenameDirectory(oldPath, newPath);
path = newPath;
}
// Rebuild without rename
//if (UnityEngine.UI.Windows.Constants.LOGS_ENABLED == true) UnityEngine.Debug.Log(window.title + " :: REBUILD BASE :: " + path);
string baseClassTemplate = null;
if (window.IsContainer() == true)
{
baseClassTemplate = TemplateGenerator.GenerateWindowLayoutContainerBaseClass(newInfo.baseClassname, newInfo.baseNamespace, newInfo.containerClassName);
}
else
{
baseClassTemplate = TemplateGenerator.GenerateWindowLayoutBaseClass(newInfo.baseClassname, newInfo.baseNamespace, newInfo.containerClassName, Tpl.GenerateTransitionMethods(window));
}
var derivedClassTemplate = TemplateGenerator.GenerateWindowLayoutDerivedClass(newInfo.classname, newInfo.baseClassname, newInfo.baseNamespace);
//if (UnityEngine.UI.Windows.Constants.LOGS_ENABLED == true) UnityEngine.Debug.Log(newPath + " :: " + newInfo.containerClassName + " :: " + baseClassTemplate);
//return;
if (minimalScriptsSize == true)
{
baseClassTemplate = CompilerSystem.Compress(baseClassTemplate);
}
if (window.IsContainer() == false)
{
IO.CreateFile(path, ".uiwspackage", string.Empty, import: false);
IO.CreateDirectory(path, string.Empty);
IO.CreateDirectory(path, FlowDatabase.COMPONENTS_FOLDER);
IO.CreateDirectory(path, FlowDatabase.LAYOUT_FOLDER);
IO.CreateDirectory(path, FlowDatabase.SCREENS_FOLDER);
}
else
{
IO.CreateFile(path, ".uiwscontainer", string.Empty, import: false);
}
if (baseClassTemplate != null && derivedClassTemplate != null)
{
IO.CreateFile(path, newInfo.baseClassnameFile, baseClassTemplate, rewrite: true);
IO.CreateFile(path, newInfo.classnameFile, derivedClassTemplate, rewrite: false);
}
window.compiledNamespace = newInfo.baseNamespace;
window.compiledScreenName = newInfo.screenName;
window.compiledBaseClassName = newInfo.baseClassname;
window.compiledDerivedClassName = newInfo.classname;
window.compiledDirectory = path;
window.compiled = true;
}
