/*
         * 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);
        }
示例#2
0
        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();
        }
示例#3
0
        /*
         * 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;

		}
示例#5
0
        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;
        }