public void AddTag(Data.FlowWindow window, FlowTag tag) { var contains = this.tags.FirstOrDefault((t) => t.title.ToLower() == tag.title.ToLower()); if (contains == null) { this.tags.Add(tag); } else { tag = contains; } window.AddTag(tag); this.isDirty = true; }
public void Setup(int id, FlowWindow.Flags flags) { this.Init(id, flags: flags); }
public bool HasContainer(FlowWindow predicate) { return(this.attachItems.Any((item) => item.targetId == predicate.id && FlowSystem.GetWindow(item.targetId).IsContainer() == true && FlowSystem.GetWindow(item.targetId).IsFunction() == false)); }
public FlowSceneItem(FlowSystemEditorWindow rootWindow, FD.FlowWindow window, AnimatedValues.AnimFloat progressValue) { this.isLocked = false; this.rootWindow = rootWindow; this.window = window; this.currentScene = EditorApplication.currentScene; this.layouts = new List<WindowLayout>(); this.layoutPrefab = null; this.screens = new List<WindowBase>(); this.screenPrefab = null; #if UNITY_5_0 EditorApplication.NewEmptyScene(); #else EditorApplication.NewScene(); #endif var popupOffset = 100f; var popupSize = new Vector2(rootWindow.position.width - popupOffset * 2f, rootWindow.position.height - popupOffset * 2f); var popupRect = new Rect(rootWindow.position.x + popupOffset, rootWindow.position.y + popupOffset, popupSize.x, popupSize.y); this.view = FlowSceneViewWindow.CreateInstance<FlowSceneViewWindow>(); FlowSceneView.recompileChecker = this.view; var title = "UI.Windows Flow Screen Editor ('{0}')"; title = string.Format(title, this.window.title); #if !UNITY_4 this.view.titleContent = new GUIContent(string.Format(title, this.window.title)); #else this.view.title = string.Format(title, this.window.title); #endif this.view.position = popupRect; this.view.rootWindow = rootWindow; /*this.inspector = FlowInspectorWindow.CreateInstance<FlowInspectorWindow>(); this.inspector.position = popupRect; this.inspector.rootWindow = rootWindow; this.inspector.Repaint(); this.inspector.Focus(); this.hierarchy = FlowHierarchyWindow.CreateInstance<FlowHierarchyWindow>(); this.hierarchy.position = popupRect; this.hierarchy.rootWindow = rootWindow; this.hierarchy.Repaint(); this.hierarchy.Focus();*/ this.Show(); //this.inspector.Repaint(); //this.inspector.Focus(); //this.hierarchy.Repaint(); //this.hierarchy.Focus(); this.view.Repaint(); this.view.Focus(); this.autoloadedScreen = false; this.ReloadScreens(); this.autoloadedLayout = false; this.ReloadLayouts(); this.defaultRects = false; progressValue.valueChanged.AddListener(() => { this.view.DrawProgress(progressValue.value); //this.inspector.DrawProgress(progressValue.value); //this.hierarchy.DrawProgress(progressValue.value); if (progressValue.value == progressValue.target) { this.view.Repaint(); this.view.Focus(); } }); }
public static string GetDerivedClassName(FD.FlowWindow flowWindow) { return(flowWindow.directory.UppercaseFirst() + "Screen"); }
public static string GetClassNameWithNamespace(FD.FlowWindow window) { return(Tpl.GetNamespace(window) + "." + Tpl.GetDerivedClassName(window)); }
public static void OnFlowWindowScreenMenuGUI(FlowSystemEditorWindow flowEditor, FD.FlowWindow window, GenericMenu menu) { var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>(); foreach (var addon in flowAddons) { addon.flowEditor = flowEditor; addon.OnFlowWindowScreenMenuGUI(window, menu); } }
public static void GenerateByWindow(string pathToData, bool recompile = false, bool minimalScriptsSize = false, FD.FlowWindow window = null) { CompilerSystem.Generate(pathToData, recompile, minimalScriptsSize, flowWindow => flowWindow == window); }
public static Vector2 OnDrawNodeCurveOffset(FlowSystemEditorWindow flowEditor, UnityEngine.UI.Windows.AttachItem attachItem, FD.FlowWindow fromWindow, FD.FlowWindow toWindow, bool doubleSide) { var offset = Vector2.zero; var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>(); foreach (var addon in flowAddons) { addon.flowEditor = flowEditor; offset += addon.OnFlowDrawNodeCurveOffset(attachItem, fromWindow, toWindow, doubleSide); } return(offset); }
public static void OnFlowWindowTransition(FlowSystemEditorWindow flowEditor, int index, FD.FlowWindow fromWindow, FD.FlowWindow toWindow, bool doubleSided, Vector2 centerOffset) { var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>(); foreach (var addon in flowAddons) { addon.flowEditor = flowEditor; addon.OnFlowWindowTransition(index, fromWindow, toWindow, doubleSided, centerOffset); } }
public virtual void OnFlowWindowTransition(int index, FD.FlowWindow windowFrom, FD.FlowWindow windowTo, bool doubleSided, Vector2 centerOffset) { }
public virtual Vector2 OnFlowDrawNodeCurveOffset(UnityEngine.UI.Windows.AttachItem attachItem, FD.FlowWindow fromWindow, FD.FlowWindow toWindow, bool doubleSide) { return(Vector2.zero); }
public virtual bool IsCompilerTransitionAttachedGeneration(FD.FlowWindow windowFrom, FD.FlowWindow windowTo) { return(false); }
public bool HasContainer(FlowWindow predicate) { return this.attachItems.Any((item) => item.targetId == predicate.id && FlowSystem.GetWindow(item.targetId).IsContainer()); }
public static bool IsCompilerTransitionAttachedGeneration(FD.FlowWindow windowFrom, FD.FlowWindow windowTo) { var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>(); foreach (var addon in flowAddons) { if (addon.IsCompilerTransitionAttachedGeneration(windowFrom, windowTo) == true) { return(true); } } return(false); }
public virtual string OnCompilerTransitionTypedAttachedGeneration(FD.FlowWindow windowFrom, FD.FlowWindow windowTo, bool everyPlatformHasUniqueName, System.Type[] types, string[] names) { return(string.Empty); }
public static string OnCompilerTransitionTypedAttachedGeneration(FD.FlowWindow windowFrom, FD.FlowWindow windowTo, bool everyPlatformHasUniqueName, System.Type[] types, string[] names) { var result = string.Empty; var flowAddons = CoreUtilities.GetAddons <IWindowFlowAddon>(); foreach (var addon in flowAddons) { result += addon.OnCompilerTransitionTypedAttachedGeneration(windowFrom, windowTo, everyPlatformHasUniqueName, types, names); } return(result); }
public static string GenerateTransitionMethods(FD.FlowWindow window) { var flowData = FlowSystem.GetData(); var transitions = flowData.windowAssets.Where(w => window.attachItems.Any((item) => item.targetId == w.id) && !w.IsContainer()); var result = string.Empty; foreach (var each in transitions) { var className = each.directory; var classNameWithNamespace = Tpl.GetNamespace(each) + "." + Tpl.GetDerivedClassName(each); if (each.IsShowDefault() == true) { // Collect all default windows foreach (var defaultWindowId in FlowSystem.GetDefaultWindows()) { var defaultWindow = FlowSystem.GetWindow(defaultWindowId); className = defaultWindow.directory; classNameWithNamespace = Tpl.GetNamespace(defaultWindow) + "." + Tpl.GetDerivedClassName(defaultWindow); result += TemplateGenerator.GenerateWindowLayoutTransitionMethod(window, each, className, classNameWithNamespace); WindowSystem.CollectCallVariations(each.GetScreen(), (listTypes, listNames) => { result += TemplateGenerator.GenerateWindowLayoutTransitionTypedMethod(window, each, className, classNameWithNamespace, listTypes, listNames); }); } continue; } else { if (each.CanCompiled() == false) { continue; } } result += TemplateGenerator.GenerateWindowLayoutTransitionMethod(window, each, className, classNameWithNamespace); WindowSystem.CollectCallVariations(each.GetScreen(), (listTypes, listNames) => { result += TemplateGenerator.GenerateWindowLayoutTransitionTypedMethod(window, each, className, classNameWithNamespace, listTypes, listNames); }); } 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) { // Collect all default windows foreach (var defaultWindowId in FlowSystem.GetDefaultWindows()) { var defaultWindow = FlowSystem.GetWindow(defaultWindowId); result += UnityEditor.UI.Windows.Plugins.Flow.Flow.OnCompilerTransitionAttachedGeneration(window, defaultWindow, everyPlatformHasUniqueName); WindowSystem.CollectCallVariations(attachedWindow.GetScreen(), (listTypes, listNames) => { result += UnityEditor.UI.Windows.Plugins.Flow.Flow.OnCompilerTransitionTypedAttachedGeneration(window, defaultWindow, everyPlatformHasUniqueName, listTypes, listNames); }); } result += TemplateGenerator.GenerateWindowLayoutTransitionMethodDefault(); } /*if (withFunctionRoot == true) { * * var functionId = attachedWindow.GetFunctionId(); * var functionContainer = flowData.GetWindow(functionId); * if (functionContainer != null) { * * var root = flowData.GetWindow(functionContainer.functionRootId); * if (root != null) { * * attachedWindow = root; * * } * * } * * }*/ result += UnityEditor.UI.Windows.Plugins.Flow.Flow.OnCompilerTransitionAttachedGeneration(window, attachedWindow, everyPlatformHasUniqueName); WindowSystem.CollectCallVariations(attachedWindow.GetScreen(), (listTypes, listNames) => { result += UnityEditor.UI.Windows.Plugins.Flow.Flow.OnCompilerTransitionTypedAttachedGeneration(window, attachedWindow, everyPlatformHasUniqueName, listTypes, listNames); }); } // Run addons transition logic result += UnityEditor.UI.Windows.Plugins.Flow.Flow.OnCompilerTransitionGeneration(window); return(result); }
public virtual void OnFlowWindowGUI(FD.FlowWindow window) { }
public static string GetNamespace(FD.FlowWindow window) { return(Tpl.GetNamespace() + IO.GetRelativePath(window, ".")); }
public virtual void OnFlowWindowLayoutGUI(Rect rect, FD.FlowWindow window) { }
public static void CreateTransition <T>(FD.FlowWindow windowWithScreen, FD.FlowWindow flowWindow, FD.FlowWindow toWindow, int attachIndex, string localPath, string namePrefix, System.Action <T> callback = null) where T : TransitionInputTemplateParameters { if (windowWithScreen.GetScreen() == null) { return; } var screenPath = AssetDatabase.GetAssetPath(windowWithScreen.GetScreen().Load <WindowBase>()); screenPath = System.IO.Path.GetDirectoryName(screenPath); var splitted = screenPath.Split(new string[] { "/" }, System.StringSplitOptions.RemoveEmptyEntries); var packagePath = string.Join("/", splitted, 0, splitted.Length - 1); var path = packagePath + localPath; FlowChooserFilterWindow.Show <T>( root: null, onSelect: (element) => { // Clean up previous transitions if exists var attachItem = flowWindow.GetAttachItem(toWindow.id, (x) => x.index == attachIndex); if (attachItem != null) { if (FlowSystem.GetData().modeLayer == ModeLayer.Flow) { if (attachItem.transitionParameters != null) { AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(attachItem.transitionParameters.gameObject)); } attachItem.transition = null; attachItem.transitionParameters = null; } else if (FlowSystem.GetData().modeLayer == ModeLayer.Audio) { if (attachItem.audioTransitionParameters != null) { AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(attachItem.audioTransitionParameters.gameObject)); } attachItem.audioTransition = null; attachItem.audioTransitionParameters = null; } } if (System.IO.Directory.Exists(path) == false) { System.IO.Directory.CreateDirectory(path); } if (element == null) { return; } var prefix = string.Empty; if (FlowSystem.GetData().modeLayer == ModeLayer.Flow) { prefix = "Transition-" + namePrefix; } else if (FlowSystem.GetData().modeLayer == ModeLayer.Audio) { prefix = "AudioTransition-" + namePrefix; } var elementPath = AssetDatabase.GetAssetPath(element.gameObject); var targetName = prefix + "-" + element.gameObject.name + "-" + (toWindow.IsFunction() == true ? FlowSystem.GetWindow(toWindow.functionId).directory : toWindow.directory); var targetPath = path + "/" + targetName + ".prefab"; if (AssetDatabase.CopyAsset(elementPath, targetPath) == true) { AssetDatabase.ImportAsset(targetPath); var newInstance = AssetDatabase.LoadAssetAtPath <GameObject>(targetPath); var instance = newInstance.GetComponent <T>(); instance.useDefault = false; instance.useAsTemplate = false; EditorUtility.SetDirty(instance); if (FlowSystem.GetData().modeLayer == ModeLayer.Flow) { attachItem.transition = instance.transition; attachItem.transitionParameters = instance; } else if (FlowSystem.GetData().modeLayer == ModeLayer.Audio) { attachItem.audioTransition = instance.transition; attachItem.audioTransitionParameters = instance; } if (callback != null) { callback(instance); } } }, onEveryGUI: (element) => { // on gui var style = new GUIStyle(GUI.skin.label); style.wordWrap = true; if (element != null) { GUILayout.Label(element.name, style); } else { GUILayout.Label("None", style); } }, predicate: (element) => { var elementPath = AssetDatabase.GetAssetPath(element.gameObject); var isInPackage = FlowEditorUtilities.IsValidPackage(elementPath + "/../"); if (element.transition != null && (isInPackage == true || element.useAsTemplate == true)) { var name = element.GetType().FullName; var baseName = name.Substring(0, name.IndexOf("Parameters")); var type = System.Type.GetType(baseName + ", " + element.GetType().Assembly.FullName, throwOnError: true, ignoreCase: true); if (type != null) { var attribute = type.GetCustomAttributes(inherit: true).OfType <TransitionCameraAttribute>().FirstOrDefault(); if (attribute != null) { return(true); } else { if (UnityEngine.UI.Windows.Constants.LOGS_ENABLED == true) { UnityEngine.Debug.Log("No Attribute: " + baseName, element); } } } else { if (UnityEngine.UI.Windows.Constants.LOGS_ENABLED == true) { UnityEngine.Debug.Log("No type: " + baseName); } } } return(false); }, strongType: false, directory: null, useCache: false, drawNoneOption: true, updateRedraw: true); }
public virtual void OnFlowWindowScreenMenuGUI(FD.FlowWindow window, GenericMenu menu) { }
public static void RemoveTag(Data.FlowWindow window, FlowTag tag) { FlowSystem.instance.data.RemoveTag(window, tag); }
public virtual string OnCompilerTransitionGeneration(FD.FlowWindow window) { return(string.Empty); }
public void RemoveTag(Data.FlowWindow window, FlowTag tag) { window.RemoveTag(tag); this.isDirty = true; }
public override void OnFlowWindowTransition(int index, FD.FlowWindow fromWindow, FD.FlowWindow toWindow, bool doubleSided, Vector2 centerOffset) { var factor = 0.5f; if (fromWindow.IsSmall() == true && fromWindow.IsABTest() == true) { factor = 0.2f; } var point = Vector2.Lerp(fromWindow.rect.center, toWindow.rect.center, factor) + centerOffset; var rect = new Rect(point, Vector2.zero); if (this.flowEditor.ContainsRect(rect) == false) { return; } if (doubleSided == true) { var q = Quaternion.LookRotation(toWindow.rect.center - fromWindow.rect.center, Vector3.back); this.DrawBubble(rect, index, fromWindow.id, toWindow.id, q * Vector2.left); this.DrawBubble(rect, index, toWindow.id, fromWindow.id, q * Vector2.right); } else { this.DrawBubble(rect, index, fromWindow.id, toWindow.id, Vector2.zero); } }
public AttachItem GetAttachItem(FlowWindow window) { return(this.attachItems.FirstOrDefault((item) => item.targetId == window.id)); }
public override void OnFlowWindowLayoutGUI(Rect rect, FD.FlowWindow window) { if (window.isVisibleState == false) { return; } if (window.IsContainer() == true) { return; } if (window.IsSmall() == true && window.IsFunction() == true) { return; } if (window.IsShowDefault() == true) { return; } if (Heatmap.settings == null) { Heatmap.settings = Heatmap.GetSettingsFile(); } var settings = Heatmap.settings; if (settings != null) { var data = settings.data.Get(window); if (data == null) { return; } LayoutWindowType screen; var layout = HeatmapSystem.GetLayout(window.id, out screen); if (layout == null) { return; } var targetScreenSize = new Vector2(layout.root.editorRect.width, layout.root.editorRect.height); foreach (var item in settings.items) { if (item.show == true && item.enabled == true) { foreach (var serviceBase in this.editor.services) { var service = serviceBase as IAnalyticsService; if (service.GetServiceName() == item.serviceName) { var key = string.Format("{0}_{1}", item.serviceName, window.id); HeatmapResult result; if (this.heatmapResultsCache.TryGetValue(key, out result) == true) { if (result != null) { var texture = this.heatmapTexturesCache[key]; if (texture != null) { var scaleFactor = HeatmapSystem.GetFactor(targetScreenSize, rect.size); //var scaleFactorCanvas = layout.editorScale > 0f ? 1f / layout.editorScale : 1f; //scaleFactor *= scaleFactorCanvas; var r = layout.root.editorRect; r.x *= scaleFactor; r.y *= scaleFactor; r.x += rect.x + rect.width * 0.5f; r.y += rect.y + rect.height * 0.5f; r.width *= scaleFactor; r.height *= scaleFactor; var c = Color.white; GUI.color = c; GUI.DrawTexture(r, texture, ScaleMode.StretchToFill, alphaBlend: true); GUI.color = Color.white; } else { if (this.noDataTexture != null) { GUI.DrawTexture(rect, this.noDataTexture, ScaleMode.ScaleToFit, alphaBlend: true); } } } else { // still loading... } } else { if (Event.current.type == EventType.Repaint) { var rectSize = targetScreenSize; //rect.size; var rootRect = layout.root.editorRect; this.heatmapResultsCache.Add(key, null); this.heatmapTexturesCache.Add(key, null); service.GetHeatmapData(window.id, (int)targetScreenSize.x, (int)targetScreenSize.y, item.userFilter, (_result) => { var heatmapResult = _result as HeatmapResult; // Convert normalized points to real points for (int i = 0; i < heatmapResult.points.Length; ++i) { var root = layout.GetRootByTag((LayoutTag)heatmapResult.points[i].tag); if (root != null) { var xn = heatmapResult.points[i].x; var yn = heatmapResult.points[i].y; var sourceRect = root.editorRect; var radius = (float)HeatmapVisualizer.GetRadius(); sourceRect.x += radius; sourceRect.y += radius; sourceRect.width -= radius * 2f; sourceRect.height -= radius * 2f; var scaleFactor = HeatmapSystem.GetFactor(targetScreenSize, rectSize); var r = sourceRect; r.x *= scaleFactor; r.y *= scaleFactor; r.x += rootRect.width * 0.5f; r.y = rootRect.height * 0.5f - r.y; r.width *= scaleFactor; r.height *= scaleFactor; heatmapResult.points[i].realPoint = new Vector2(r.x + xn * r.width, r.y - yn * r.height); } } this.heatmapResultsCache[key] = heatmapResult; HeatmapSystem.GenerateTextureFromData((int)targetScreenSize.x, (int)targetScreenSize.y, this.heatmapResultsCache[key], (texture) => { this.heatmapTexturesCache[key] = texture; }); }); } } } } } } } }
public void Init(int id, FlowWindow.Flags flags = Flags.Default) { this.states = new CompletedState[STATES_COUNT]; this.tags = new List<int>(); this.id = id; this.flags = flags; //this.attaches = new List<int>(); this.attachItems = new List<AttachItem>(); this.attachedComponents = new List<ComponentLink>(); this.rect = new Rect(0f, 0f, 200f, 200f);//new Rect(Screen.width * 0.5f, Screen.height * 0.5f, 200f, 200f); this.title = (this.IsContainer() == true ? "Container" : "Window " + this.id.ToString()); this.directory = (this.IsContainer() == true ? "ContainerDirectory" : "Window" + this.id.ToString() + "Directory"); this.randomColor = ColorHSV.GetDistinctColor(); this.smallStyleDefault = "flow node 4"; this.smallStyleSelected = "flow node 4 on"; this.compiled = false; }
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), 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 //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 = TemplateGenerator.GenerateWindowLayoutBaseClass(newInfo.baseClassname, newInfo.baseNamespace, Tpl.GenerateTransitionMethods(window)); var derivedClassTemplate = TemplateGenerator.GenerateWindowLayoutDerivedClass(newInfo.classname, newInfo.baseClassname, newInfo.baseNamespace); if (minimalScriptsSize == true) { baseClassTemplate = CompilerSystem.Compress(baseClassTemplate); } 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 AttachItem GetAttachItem(FlowWindow window) { return this.attachItems.FirstOrDefault((item) => item.targetId == window.id); }
public virtual string OnCompilerTransitionAttachedGeneration(FD.FlowWindow windowFrom, FD.FlowWindow windowTo, bool everyPlatformHasUniqueName) { return(string.Empty); }