public static string GenerateReturnMethod(FlowSystemEditorWindow flowEditor, FlowWindow exitWindow)
{
var file = Resources.Load("UI.Windows/Functions/Templates/TemplateReturnMethod") as TextAsset;
if (file == null)
{
Debug.LogError("Functions Template Loading Error: Could not load template 'TemplateReturnMethod'");
return(string.Empty);
}
var data = FlowSystem.GetData();
if (data == null)
{
return(string.Empty);
}
var result = string.Empty;
var part = file.text;
var functionContainer = exitWindow.GetFunctionContainer();
var functionName = functionContainer.title;
var functionCallName = functionContainer.directory;
var classNameWithNamespace = Tpl.GetNamespace(exitWindow) + "." + Tpl.GetDerivedClassName(exitWindow);
result +=
part.Replace("{FUNCTION_NAME}", functionName)
.Replace("{FUNCTION_CALL_NAME}", functionCallName)
.Replace("{CLASS_NAME_WITH_NAMESPACE}", classNameWithNamespace);
return(result);
}
public Window Get(FlowWindow window)
{
Window result = null;
this.list.RemoveAll((info) => {
var w = Flow.FlowSystem.GetWindow(info.id);
return(w == null);
});
foreach (var item in this.list)
{
if (item.id == window.id)
{
result = item;
break;
}
}
if (result == null)
{
result = new Window(window);
this.list.Add(result);
}
return(result);
}
public override void OnFlowWindowGUI(FlowWindow window)
{
if (window.CanCompiled() == false)
{
return;
}
if (string.IsNullOrEmpty(window.compiledDirectory) == false)
{
window.compiled = System.IO.File.Exists(window.compiledDirectory + "/" + window.compiledBaseClassName + ".cs");
}
var oldColor = GUI.color;
var style = new GUIStyle("U2D.dragDotDimmed");
var styleCompiled = new GUIStyle("U2D.dragDot");
var elemWidth = style.fixedWidth - 3f;
var posY = -1f;
var posX = -1f;
GUI.color = window.compiled ? Color.white : Color.red;
GUI.Label(new Rect(posX, posY, elemWidth, style.fixedHeight), new GUIContent(string.Empty, window.compiled ? "Compiled" : "Not compiled"), window.compiled ? styleCompiled : style);
GUI.color = oldColor;
}
public Info(FlowWindow window)
{
this.baseNamespace = window.compiledNamespace;
this.classname = window.compiledDerivedClassName;
this.baseClassname = window.compiledBaseClassName;
this.screenName = window.directory;
}
public static void OnDrawWindowGUI(FlowWindow window)
{
var flowAddons = WindowUtilities.GetAddons <IWindowFlowAddon>();
foreach (var addon in flowAddons)
{
addon.OnFlowWindowGUI(window);
}
}
public static void OnDrawWindowLayoutGUI(Rect rect, FlowWindow window)
{
var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>();
foreach (var addon in flowAddons)
{
addon.OnFlowWindowLayoutGUI(rect, window);
}
}
public static void OnDrawWindowGUI(FlowSystemEditorWindow flowEditor, FlowWindow window)
{
var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>();
foreach (var addon in flowAddons)
{
addon.flowEditor = flowEditor;
addon.OnFlowWindowGUI(window);
}
}
private static IEnumerable <FlowWindow> GetParentContainers(FlowWindow window, IEnumerable <FlowWindow> containers)
{
var parent = containers.FirstOrDefault(where => where.attaches.Contains(window.id));
while (parent != null)
{
yield return(parent);
parent = containers.FirstOrDefault(where => where.attaches.Contains(parent.id));
}
}
private static IEnumerable <FlowWindow> GetParentContainers(FlowWindow window, IEnumerable <FlowWindow> containers)
{
var parent = containers.FirstOrDefault(where => where.attachItems.Any((item) => item.targetId == window.id));
while (parent != null)
{
yield return(parent);
parent = containers.FirstOrDefault(where => where.attachItems.Any((item) => item.targetId == parent.id));
}
}
public override void OnFlowWindowGUI(FlowWindow window)
{
if (Social.settings == null)
{
return;
}
var socialFlag = (window.flags & Social.settings.uniqueTag) == Social.settings.uniqueTag;
if (socialFlag == true)
{
var settings = Social.settings;
if (settings == null)
{
return;
}
var data = settings.data.Get(window);
var isActiveSelected = settings.IsPlatformActive(data.settings);
var oldColor = GUI.color;
GUI.color = isActiveSelected ? Color.white : Color.grey;
var result = GUILayoutExt.LargeButton(data.settings ? data.settings.GetPlatformName() : "None", 60f, 150f);
GUI.color = oldColor;
var rect = GUILayoutUtility.GetLastRect();
rect.y += rect.height;
if (result == true)
{
var menu = new GenericMenu();
menu.AddItem(new GUIContent("None"), data.settings == null, () => {
data.settings = null;
});
foreach (var platform in settings.activePlatforms)
{
if (platform.active == true)
{
var item = platform.settings;
menu.AddItem(new GUIContent(platform.GetPlatformName()), data.settings == platform.settings, () => {
data.settings = item;
});
}
else
{
menu.AddDisabledItem(new GUIContent(platform.GetPlatformName()));
}
}
menu.DropDown(rect);
}
}
}
public override string OnCompilerTransitionAttachedGeneration(FlowWindow windowFrom, FlowWindow windowTo, bool everyPlatformHasUniqueName)
{
if (windowTo.IsFunction() == true &&
windowTo.IsSmall() == true &&
windowTo.IsContainer() == false &&
windowTo.GetFunctionId() > 0)
{
return(FlowFunctionsTemplateGenerator.GenerateTransitionMethod(this.flowEditor, windowFrom, windowTo));
}
return(base.OnCompilerTransitionAttachedGeneration(windowFrom, windowTo, everyPlatformHasUniqueName));
}
public static string OnCompilerTransitionGeneration(FlowWindow window)
{
var result = string.Empty;
var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>();
foreach (var addon in flowAddons)
{
result += addon.OnCompilerTransitionGeneration(window);
}
return(result);
}
public static string OnCompilerTransitionAttachedGeneration(FlowWindow windowFrom, FlowWindow windowTo, bool everyPlatformHasUniqueName)
{
var result = string.Empty;
var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>();
foreach (var addon in flowAddons)
{
result += addon.OnCompilerTransitionAttachedGeneration(windowFrom, windowTo, everyPlatformHasUniqueName);
}
return(result);
}
public static string GenerateTransitionMethods(FlowWindow window)
{
var flowData = FlowSystem.GetData();
var transitions = flowData.windows.Where(w => window.attachItems.Any((item) => item.targetId == w.id) && w.CanCompiled() && !w.IsContainer());
var result = string.Empty;
foreach (var each in transitions)
{
var className = each.directory;
var classNameWithNamespace = Tpl.GetNamespace(each) + "." + Tpl.GetDerivedClassName(each);
result += FlowTemplateGenerator.GenerateWindowLayoutTransitionMethod(window, each, className, classNameWithNamespace);
}
// Make FlowDefault() method if exists
var c = 0;
var everyPlatformHasUniqueName = false;
foreach (var attachItem in window.attachItems)
{
var attachId = attachItem.targetId;
var attachedWindow = FlowSystem.GetWindow(attachId);
var tmp = UnityEditor.UI.Windows.Plugins.Flow.Flow.IsCompilerTransitionAttachedGeneration(window, attachedWindow);
if (tmp == true)
{
++c;
}
}
everyPlatformHasUniqueName = c > 1;
foreach (var attachItem in window.attachItems)
{
var attachId = attachItem.targetId;
var attachedWindow = FlowSystem.GetWindow(attachId);
if (attachedWindow.IsShowDefault() == true)
{
result += FlowTemplateGenerator.GenerateWindowLayoutTransitionMethodDefault();
}
result += UnityEditor.UI.Windows.Plugins.Flow.Flow.OnCompilerTransitionAttachedGeneration(window, attachedWindow, everyPlatformHasUniqueName);
}
// Run addons transition logic
result += UnityEditor.UI.Windows.Plugins.Flow.Flow.OnCompilerTransitionGeneration(window);
return(result);
}
public void DrawNodeCurve(FlowWindow fromContainer, FlowWindow toContainer, Rect centerStart, Rect centerEnd, Rect fromRect, Rect toRect, bool doubleSide, float size = 6f)
{
Rect start = fromRect;
Rect end = toRect;
var color1 = Color.white;
var color2 = Color.white;
if (fromContainer != toContainer)
{
color1 = Color.gray;
color2 = Color.gray;
if (toContainer != null)
{
color1 = toContainer.randomColor;
}
if (fromContainer != null)
{
color2 = fromContainer.randomColor;
}
}
var zOffset = -4f;
if (doubleSide == true)
{
var rot = Quaternion.AngleAxis(90f, Vector3.back);
var ray = new Ray(Vector3.zero, (rot * (end.center - start.center)).normalized);
var offset = ray.GetPoint(size);
var startPos = new Vector3(start.center.x + offset.x, start.center.y + offset.y, zOffset);
var endPos = new Vector3(centerEnd.center.x + offset.x, centerEnd.center.y + offset.y, zOffset);
this.DrawNodeCurve(startPos, endPos, color1);
offset = ray.GetPoint(-size);
startPos = new Vector3(centerStart.center.x + offset.x, centerStart.center.y + offset.y, zOffset);
endPos = new Vector3(end.center.x + offset.x, end.center.y + offset.y, zOffset);
this.DrawNodeCurve(endPos, startPos, color2);
}
else
{
var offset = Vector2.zero;
var startPos = new Vector3(start.center.x + offset.x, start.center.y + offset.y, zOffset);
var endPos = new Vector3(centerEnd.center.x + offset.x, centerEnd.center.y + offset.y, zOffset);
this.DrawNodeCurve(startPos, endPos, color1);
}
}
public static bool IsCompilerTransitionAttachedGeneration(FlowWindow windowFrom, FlowWindow windowTo)
{
var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>();
foreach (var addon in flowAddons)
{
if (addon.IsCompilerTransitionAttachedGeneration(windowFrom, windowTo) == true)
{
return(true);
}
}
return(false);
}
public override string OnCompilerTransitionGeneration(FlowWindow window)
{
var functionContainer = window.GetFunctionContainer();
if (functionContainer != null)
{
var exit = FlowSystem.GetWindow(functionContainer.functionExitId);
if (exit != null && exit.id == window.id)
{
return(FlowFunctionsTemplateGenerator.GenerateReturnMethod(this.flowEditor, exit));
}
}
return(base.OnCompilerTransitionGeneration(window));
}
public override bool IsCompilerTransitionAttachedGeneration(FlowWindow windowFrom, FlowWindow windowTo)
{
var settings = Social.settings;
if (settings != null)
{
var data = settings.data.Get(windowTo);
if (data != null && data.settings != null && settings.IsPlatformActive(data.settings) == true)
{
return(true);
}
}
return(false);
}
public override string OnCompilerTransitionAttachedGeneration(FlowWindow windowFrom, FlowWindow windowTo, bool everyPlatformHasUniqueName)
{
var settings = Social.settings;
if (settings != null)
{
var data = settings.data.Get(windowTo);
if (data != null && data.settings != null && settings.IsPlatformActive(data.settings) == true)
{
return(FlowSocialTemplateGenerator.GenerateTransitionMethod(data.settings, everyPlatformHasUniqueName));
}
}
return(base.OnCompilerTransitionAttachedGeneration(windowFrom, windowTo, everyPlatformHasUniqueName));
}
public static void SetControl(FlowSystemEditorWindow rootWindow, FlowWindow window, System.Action <float> onProgress)
{
if (EditorApplication.SaveCurrentSceneIfUserWantsTo() == true)
{
FlowSceneView.editAnimation = new UnityEditor.AnimatedValues.AnimFloat(0f, () => {
onProgress(FlowSceneView.editAnimation.value);
});
FlowSceneView.editAnimation.value = 0f;
FlowSceneView.editAnimation.speed = 2f;
FlowSceneView.editAnimation.target = 1f;
FlowSceneView.currentItem = new FlowSceneItem(rootWindow, window, FlowSceneView.editAnimation);
FlowSceneView.isActive = true;
}
}
public static string GetRelativePath(FlowWindow window, string token)
{
var result = GetParentContainers(window, FlowSystem.GetContainers())
.Reverse()
.Select(w => w.directory)
.Aggregate(string.Empty, (total, path) => total + token + path);
if (string.IsNullOrEmpty(result) == true)
{
result = token + FlowDatabase.OTHER_NAME;
}
result += token + window.directory;
return(result);
}
public static string GenerateWindowLayoutTransitionMethod(FlowWindow from, FlowWindow to, string targetClassName, string targetClassNameWithNamespace)
{
var file = Resources.Load("UI.Windows/Templates/TemplateTransitionMethod") as TextAsset;
if (file == null)
{
Debug.LogError("Template Loading Error: Could not load template 'TemplateTransitionMethod'");
return(null);
}
return(file.text.Replace("{CLASS_NAME}", targetClassName)
.Replace("{FLOW_FROM_ID}", from.id.ToString())
.Replace("{FLOW_TO_ID}", to.id.ToString())
.Replace("{CLASS_NAME_WITH_NAMESPACE}", targetClassNameWithNamespace));
}
public void DrawComponentCurve(FlowWindow from, ref UnityEngine.UI.Windows.Plugins.Flow.FlowWindow.ComponentLink link, FlowWindow to)
{
if (from.IsEnabled() == false || to.IsEnabled() == false)
{
return;
}
var component = from.GetLayoutComponent(link.sourceComponentTag);
if (component != null)
{
var rect = component.tempEditorRect;
var start = new Rect(from.rect.x + rect.x, from.rect.y + rect.y, rect.width, rect.height);
var end = to.rect;
var zOffset = -4f;
var offset = Vector2.zero;
var startPos = new Vector3(start.center.x + offset.x, start.center.y + offset.y, zOffset);
var endPos = new Vector3(end.center.x + offset.x, end.center.y + offset.y, zOffset);
var scale = FlowSystem.GetData().flowWindowWithLayoutScaleFactor;
var side1 = from.rect.size.x * 0.5f;
var side2 = from.rect.size.y * 0.5f;
var stopDistance = Mathf.Sqrt(side1 * side1 + side2 * side2);
var color = Color.white;
if (from.GetContainer() != to.GetContainer())
{
color = Color.gray;
if (to.GetContainer() != null)
{
color = to.GetContainer().randomColor;
}
}
var comment = this.DrawComponentCurve(startPos, endPos, color, stopDistance + 50f * scale, link.comment);
if (link.comment != comment)
{
link.comment = comment;
FlowSystem.SetDirty();
}
}
}
public static string GenerateTransitionMethods(FlowWindow window)
{
var flowData = FlowSystem.GetData();
var transitions = flowData.windows.Where(w => window.attaches.Contains(w.id) && !w.isDefaultLink && !w.isContainer);
var result = string.Empty;
foreach (var each in transitions)
{
var className = each.directory;
var classNameWithNamespace = Tpl.GetNamespace(each) + "." + Tpl.GetDerivedClassName(each); //GetBaseClassName( each );
result = result + FlowTemplateGenerator.GenerateWindowLayoutTransitionMethod(className, classNameWithNamespace);
}
return(result);
}
public static string GetNamespace(FlowWindow window)
{
return(Tpl.GetNamespace() + IO.GetRelativePath(window, "."));
}
public static string GetDerivedClassName(FlowWindow flowWindow)
{
return(flowWindow.directory.UppercaseFirst() + "Screen");
}
public static void GenerateByWindow(string pathToData, bool recompile = false, FlowWindow window = null)
{
FlowCompilerSystem.Generate(pathToData, recompile, flowWindow => flowWindow == window);
}
/*
* 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;
}
public virtual bool IsCompilerTransitionAttachedGeneration(FlowWindow windowFrom, FlowWindow windowTo)
{
return(false);
}
public virtual string OnCompilerTransitionAttachedGeneration(FlowWindow windowFrom, FlowWindow windowTo, bool everyPlatformHasUniqueName)
{
return(string.Empty);
}
