public Coroutine ShowOverlayViewPage(string viewPageName, bool RePlayOnShowWhileSamePage = false, Action OnStart = null, Action OnChanged = null, Action OnComplete = null, bool ignoreTimeScale = false)
{
if (!CheckTimeProtect())
{
ViewSystemLog.LogWarning($"Method call return due to TimeProtect.");
return(null);
}
if (!viewPages.TryGetValue(viewPageName, out nextOverlayViewPage))
{
ViewSystemLog.LogError("No overlay viewPage match the name: " + viewPageName + " found");
return(null);
}
string OverlayPageStateKey = GetOverlayStateKey(nextOverlayViewPage);
if (overlayPageStatusDict.TryGetValue(OverlayPageStateKey, out ViewSystemUtilitys.OverlayPageStatus overlayPageStatus))
{
if (overlayPageStatus.IsTransition == true)
{
ViewSystemLog.LogError($"The Overlay page with same state {nextOverlayViewPage.name} is in Transition, ignore the ShowOverlayViewPage call.");
return(null);
}
if (overlayPageStatus.viewPage.name == viewPageName)
{
if (RePlayOnShowWhileSamePage == false)
{
ViewSystemLog.LogError($"The Overlay page {nextOverlayViewPage.name} is in already exsit, ignore the ShowOverlayViewPage call.");
return(null);
}
}
}
return(StartCoroutine(ShowOverlayViewPageBase(nextOverlayViewPage, RePlayOnShowWhileSamePage, OnStart, OnChanged, OnComplete, ignoreTimeScale)));
}
void CacheComponent(GameObject go, int layer, bool isPrefabRoot)
{
var so = new SerializedObject(go);
var t = new TreeViewWrapper(Id);
t.values = so;
serializedObjects.Add(t);
Id++;
CacheProperty(so);
var components = go.GetComponents(typeof(Component));
foreach (var item in components)
{
if (item == null)
{
ViewSystemLog.LogError("It seems there is some Component's script is missing, Please check your prefab");
continue;
}
// if (isPrefabRoot == true &&
// (item is UnityEngine.Transform || item is UnityEngine.RectTransform)
// )
// {
// continue;
// }
var t1 = new TreeViewWrapper(Id);
var so1 = new SerializedObject(item);
t1.values = so1;
serializedObjects.Add(t1);
Id++;
CacheProperty(so1);
}
}
internal void ApplyOverride(IEnumerable <ViewElementPropertyOverrideData> overrideDatas)
{
foreach (var item in overrideDatas)
{
Transform targetTansform = GetTransform(item.targetTransformPath);
if (targetTansform == null)
{
ViewSystemLog.LogError($"Target GameObject cannot be found [{transform.name} / {item.targetTransformPath}]");
continue;
}
var result = GetCachedComponent(targetTansform, item.targetTransformPath, item.targetComponentType);
if (result.Component == null)
{
ViewSystemLog.LogError($"Target Component cannot be found [{item.targetComponentType}]");
continue;
}
var idForProperty = result.Id + "#" + item.targetPropertyName;
if (!prefabDefaultFields.ContainsKey(idForProperty))
{
prefabDefaultFields.Add(idForProperty, new PrefabDefaultField(GetPropertyValue(result.Component, item.targetPropertyName), result.Id, item.targetPropertyName));
}
currentModifiedField.Add(idForProperty);
SetPropertyValue(result.Component, item.targetPropertyName, item.Value.GetValue());
}
}
public Coroutine ChangePage(string targetViewPageName, Action OnStart = null, Action OnChanged = null, Action OnComplete = null, bool AutoWaitPreviousPageFinish = false, bool ignoreTimeScale = false)
{
if (!CheckTimeProtect())
{
ViewSystemLog.LogWarning($"Method call return due to TimeProtect.");
return(null);
}
if (currentViewPage.name == targetViewPageName)
{
ViewSystemLog.LogWarning("The ViewPage request to change is same as current ViewPage, nothing will happen!");
return(null);
}
if (IsPageTransition && AutoWaitPreviousPageFinish == false)
{
ViewSystemLog.LogWarning("Page is in Transition. You can set AutoWaitPreviousPageFinish to 'True' then page will auto transition to next page while previous page transition finished.");
return(null);
}
else if (IsPageTransition && AutoWaitPreviousPageFinish == true)
{
ViewSystemLog.LogWarning($"Page is in Transition but AutoWaitPreviousPageFinish Leaving page is [{currentViewPage?.name}] Entering page is [{nextViewPage?.name}] next page is [{targetViewPageName}]");
ChangePageToCoroutine = StartCoroutine(WaitPrevious(targetViewPageName, OnStart, OnChanged, OnComplete, ignoreTimeScale));
return(ChangePageToCoroutine);
}
ChangePageToCoroutine = StartCoroutine(ChangePageBase(targetViewPageName, OnStart, OnChanged, OnComplete, ignoreTimeScale));
return(ChangePageToCoroutine);
}
public void GenerateDefaultUIRoot()
{
if (string.IsNullOrEmpty(data.globalSetting.ViewControllerObjectPath))
{
ViewSystemLog.LogError("Please set ViewController Object Path first");
return;
}
GameObject canvasObject = new GameObject("Canvas");
var viewControllerObject = GameObject.Find(data.globalSetting.ViewControllerObjectPath);
canvasObject.transform.SetParent(viewControllerObject.transform);
var canvas = canvasObject.AddComponent <Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
canvas.additionalShaderChannels = AdditionalCanvasShaderChannels.TexCoord1;
var canvasScaler = canvasObject.AddComponent <UnityEngine.UI.CanvasScaler>();
canvasScaler.referenceResolution = new Vector2(1080, 1920);
canvasScaler.uiScaleMode = UnityEngine.UI.CanvasScaler.ScaleMode.ScaleWithScreenSize;
canvasScaler.screenMatchMode = UnityEngine.UI.CanvasScaler.ScreenMatchMode.MatchWidthOrHeight;
canvasScaler.matchWidthOrHeight = 1;
var graphicRaycaster = canvasObject.AddComponent <UnityEngine.UI.GraphicRaycaster>();
var eventSystem = canvasObject.AddComponent <UnityEngine.EventSystems.EventSystem>();
var inputModule = canvasObject.AddComponent <UnityEngine.EventSystems.StandaloneInputModule>();
SetUIRootObject(canvasObject);
UnityEngine.Object.DestroyImmediate(canvasObject);
}
public T GetInjectionInstance <T>() where T : Component, IViewElementInjectable
{
if (InjectionDictionary.TryGetValue(typeof(T), out Component result))
{
return((T)result);
}
else
{
ViewSystemLog.LogError("Target type cannot been found, are you sure your ViewElement which attach target Component is unique?");
}
return(null);
}
// public UnityEditor.SerializedPropertyType GetSerializedPropertyType()
// {
// switch (s_Type)
// {
// case S_Type._vector3:
// return UnityEditor.SerializedPropertyType.Vector3;
// case S_Type._vector2:
// return UnityEditor.SerializedPropertyType.Vector2;
// case S_Type._float:
// return UnityEditor.SerializedPropertyType.Float;
// case S_Type._int:
// return UnityEditor.SerializedPropertyType.Integer;
// case S_Type._string:
// return UnityEditor.SerializedPropertyType.String;
// case S_Type._bool:
// return UnityEditor.SerializedPropertyType.Boolean;
// case S_Type._color:
// return UnityEditor.SerializedPropertyType.Color;
// case S_Type._objcetReferenct:
// return UnityEditor.SerializedPropertyType.ObjectReference;
// case S_Type._enum:
// return UnityEditor.SerializedPropertyType.Enum;
// case S_Type._enumFlag:
// return UnityEditor.SerializedPropertyType.Enum;
// }
// }
public void SetValue(UnityEditor.SerializedProperty property)
{
switch (property.propertyType)
{
case UnityEditor.SerializedPropertyType.Vector3:
SetValue(property.vector3Value);
break;
case UnityEditor.SerializedPropertyType.Vector2:
SetValue(property.vector2Value);
break;
case UnityEditor.SerializedPropertyType.Vector3Int:
SetValue(property.vector3IntValue);
break;
case UnityEditor.SerializedPropertyType.Float:
SetValue(property.floatValue);
break;
case UnityEditor.SerializedPropertyType.Integer:
SetValue(property.intValue);
break;
case UnityEditor.SerializedPropertyType.String:
SetValue(property.stringValue);
break;
case UnityEditor.SerializedPropertyType.Boolean:
SetValue(property.boolValue);
break;
case UnityEditor.SerializedPropertyType.Color:
SetValue(property.colorValue);
break;
case UnityEditor.SerializedPropertyType.ObjectReference:
SetValue(property.objectReferenceValue);
break;
case UnityEditor.SerializedPropertyType.Enum:
var type = TryFindEnumType(property);
if (type == null)
{
ViewSystemLog.LogError($"The override property cannot find {property.propertyPath}");
break;
}
var e = System.Enum.Parse(type, property.enumNames[property.enumValueIndex]);
SetValue(e);
break;
}
}
public void OnChangedPage()
{
if (lifeCyclesObjects != null)
{
foreach (var item in lifeCyclesObjects.ToArray())
{
try
{
item.OnChangedPage();
}
catch (Exception ex) { ViewSystemLog.LogError(ex.Message, this); }
}
}
}
IEnumerable <ViewPageItem> PrepareRuntimeReference(IEnumerable <ViewPageItem> viewPageItems)
{
foreach (var item in viewPageItems)
{
if (item.viewElement != null)
{
item.runtimeViewElement = runtimePool.RequestViewElement(item.viewElement);
}
else
{
ViewSystemLog.LogError($"The viewElement in ViewPageItem : {item.Id} is null or missing, that is all we know, please check the page you're trying to change to.");
}
}
return(viewPageItems);
}
// ViewElementNavigationData[] navigationDatas;
internal void ApplyNavigation(IEnumerable <ViewElementNavigationData> navigationDatas)
{
//this.navigationDatas = navigationDatas.ToArray();
foreach (var item in navigationDatas)
{
Transform targetTansform = GetTransform(item.targetTransformPath);
if (targetTansform == null)
{
ViewSystemLog.LogError($"Target GameObject cannot be found [{transform.name} / {item.targetTransformPath}]");
continue;
}
var result = GetCachedComponent(targetTansform, item.targetTransformPath, item.targetComponentType);
SetPropertyValue(result.Component, item.targetPropertyName, item.navigation);
}
}
public void VerifyEvents()
{
ViewSystemVisualEditor.RefreshMethodDatabase();
RefreshEventDatas();
eventDataNeedToFix.Clear();
foreach (var vpi in allEventDatas)
{
foreach (var item in vpi.eventDatas)
{
var t = MacacaGames.Utility.GetType(item.scriptName);
if (t == null)
{
ViewSystemLog.LogError(item.targetComponentType + " still not fixed cannot be found, will ignore while verify property");
eventDataNeedToFix.Add(item);
continue;
}
if (t.GetMethod(item.methodName, bindingFlags) == null)
{
ViewSystemLog.LogError($"{item.methodName} in {item.scriptName} cannot be found");
eventDataNeedToFix.Add(item);
continue;
}
}
}
if (eventDataNeedToFix.Count > 0)
{
if (EditorUtility.DisplayDialog(
"Something goes wrong!",
"There are some event data is missing, do you want to open fixer window",
"Yes, Please",
"Not now"))
{
var window = ScriptableObject.CreateInstance <EventFixerWindow>();
window.SetData(eventDataNeedToFix, ViewSystemVisualEditor.classMethodInfo, () =>
{
//Make sure SetDirty
EditorUtility.SetDirty(saveData);
});
window.ShowUtility();
}
}
else
{
ViewSystemLog.Log("Great, all events looks good!");
}
}
public void VerifyPagesAndStates()
{
if (editor == null)
{
ViewSystemLog.LogError("Cannot verify save data, is editor init correctlly?");
return;
}
if (saveData == null)
{
ViewSystemLog.LogError("Cannot verify save data, is editor init correctlly?");
return;
}
string result = "";
var viewStates = saveData.viewStates.Select(m => m.viewState).ToList();
var viewPages = saveData.viewPages.Select(m => m.viewPage).ToList();
foreach (var states in viewStates)
{
foreach (var item in states.viewPageItems)
{
if (item.viewElement == null)
{
result += $"One ViewElement in State : [{states.name}] is null.";
}
}
}
foreach (var pages in viewPages)
{
foreach (var item in pages.viewPageItems)
{
if (item.viewElement == null)
{
result += $"One ViewElement in Page : [{pages.name}] is null.";
}
}
}
if (!string.IsNullOrEmpty(result))
{
ViewSystemLog.LogError(result);
}
else
{
ViewSystemLog.Log("Great, all pages and states looks good!");
}
}
public bool IsOverPageLive(string viewPageName, bool includeLeavingPage = false)
{
if (string.IsNullOrEmpty(viewPageName))
{
return(false);
}
if (viewPages == null)
{
return(false);
}
//沒有找到
if (viewPages.TryGetValue(viewPageName, out ViewPage vp))
{
return(IsOverPageLive(vp));
}
ViewSystemLog.LogError("No view page match " + viewPageName + " Found");
return(false);
}
public Coroutine LeaveOverlayViewPage(string viewPageName, float tweenTimeIfNeed = 0.4F, Action OnComplete = null, bool ignoreTransition = false, bool ignoreTimeScale = false, bool waitForShowFinish = false)
{
if (!CheckTimeProtect())
{
ViewSystemLog.LogWarning($"Method call return due to TimeProtect.");
return(null);
}
// var nextViewPage = viewPages.SingleOrDefault(m => m.name == viewPageName);
if (!viewPages.TryGetValue(viewPageName, out nextOverlayViewPage))
{
ViewSystemLog.LogError("No overlay viewPage match the name: " + viewPageName + " found");
return(null);
}
string OverlayPageStateKey = GetOverlayStateKey(nextOverlayViewPage);
if (!overlayPageStatusDict.TryGetValue(OverlayPageStateKey, out ViewSystemUtilitys.OverlayPageStatus overlayPageStatus))
{
ViewSystemLog.LogError("No live overlay viewPage of name: " + viewPageName + " found, try to fix.");
overlayPageStatus = new ViewSystemUtilitys.OverlayPageStatus();
overlayPageStatus.viewPage = nextOverlayViewPage;
viewStates.TryGetValue(nextOverlayViewPage.viewState, out nextViewState);
if (nextViewState != null)
{
overlayPageStatus.viewState = nextViewState;
}
}
else
{
if (overlayPageStatus.transition == ViewSystemUtilitys.OverlayPageStatus.Transition.Show && waitForShowFinish == false)
{
ViewSystemLog.LogError($"The Overlay page {nextOverlayViewPage.name} is in Transition, ignore the LeaveOverlayViewPage call.");
return(null);
}
if (overlayPageStatus.transition == ViewSystemUtilitys.OverlayPageStatus.Transition.Leave)
{
ViewSystemLog.LogError($"The Overlay page {nextOverlayViewPage.name} is in Leaving, ignore the LeaveOverlayViewPage call.");
return(null);
}
}
overlayPageStatus.pageChangeCoroutine = StartCoroutine(LeaveOverlayViewPageBase(overlayPageStatus, tweenTimeIfNeed, OnComplete, ignoreTransition, ignoreTimeScale, waitForShowFinish));
return(overlayPageStatus.pageChangeCoroutine);
}
public static float CalculateOnLeaveDuration(IEnumerable <ViewElement> viewElements, float maxClampTime = 1)
{
float maxOutAnitionTime = 0;
foreach (var item in viewElements)
{
if (item == null)
{
ViewSystemLog.LogError($"One or more ViewElement is null in the page trying to Leave, ignore the item.");
continue;
}
float t = item.GetOutDuration();
if (t > maxOutAnitionTime)
{
maxOutAnitionTime = t;
}
}
return(Mathf.Clamp(maxOutAnitionTime, 0, maxClampTime));
}
void EventHandler()
{
if (ViewController.Instance.IsPageTransition)
{
ViewSystemLog.LogWarning("The page is in transition, event will not fire!");
return;
}
foreach (var item in currentEventDelegates)
{
try
{
item?.Invoke(currentComponent);
}
catch (Exception ex)
{
ViewSystemLog.LogError($"Error Occure while invoke event: {ex.ToString()}");
}
}
}
public void RecoveryViewElement(ViewElement toRecovery)
{
// Debug.Log($"Recovery {toRecovery.name}");
if (toRecovery.IsUnique)
{
// unique ViewElement just needs to disable gameObject
toRecovery.gameObject.SetActive(false);
}
else
{
if (!veDicts.TryGetValue(toRecovery.PoolKey, out Queue <ViewElement> veQueue))
{
ViewSystemLog.LogWarning("Cannot find pool of ViewElement " + toRecovery.name + ", Destroy directly.", toRecovery);
UnityEngine.Object.Destroy(toRecovery);
return;
}
toRecovery.gameObject.SetActive(false);
veQueue.Enqueue(toRecovery);
}
}
// Use this for initialization
protected override void Awake()
{
transformCache = transform;
base.Awake();
_incance = Instance = this;
//Create ViewElementPool
if (gameObject.name != viewSystemSaveData.globalSetting.ViewControllerObjectPath)
{
ViewSystemLog.LogWarning("The GameObject which attached ViewController is not match the setting in Base Setting.");
}
//Create UIRoot
rootCanvasTransform = Instantiate(viewSystemSaveData.globalSetting.UIRoot).transform;
rootCanvasTransform.SetParent(transformCache);
rootCanvasTransform.localPosition = viewSystemSaveData.globalSetting.UIRoot.transform.localPosition;
rootCanvasTransform.gameObject.name = viewSystemSaveData.globalSetting.UIRoot.name;
var go = new GameObject("ViewElementPool");
go.transform.SetParent(transformCache);
go.AddComponent <RectTransform>();
viewElementPool = go.AddComponent <ViewElementPool>();;
runtimePool = gameObject.AddComponent <ViewElementRuntimePool>();
runtimePool.Init(viewElementPool);
ViewElement.runtimePool = runtimePool;
ViewElement.viewElementPool = viewElementPool;
InjectionDictionary = new Dictionary <System.Type, Component>();
maxClampTime = viewSystemSaveData.globalSetting.MaxWaitingTime;
minimumTimeInterval = viewSystemSaveData.globalSetting.minimumTimeInterval;
try
{
breakPointsStatus = viewSystemSaveData.globalSetting.breakPoints.ToDictionary(m => m, m => false);
}
catch (Exception ex)
{
ViewSystemLog.LogError($"Error occur while proccess breakpoint {ex.Message}");
}
}
public ViewElement PrewarmUniqueViewElement(ViewElement source)
{
if (!source.IsUnique)
{
ViewSystemLog.LogWarning("The ViewElement trying to Prewarm is not an unique ViewElement");
return(null);
}
if (!uniqueVeDicts.ContainsKey(source.GetInstanceID()))
{
var temp = UnityEngine.Object.Instantiate(source, _hierachyPool.rectTransform);
temp.name = source.name;
uniqueVeDicts.Add(source.GetInstanceID(), temp);
temp.gameObject.SetActive(false);
return(temp);
}
else
{
ViewSystemLog.LogWarning("ViewElement " + source.name + " has been prewarmed");
return(uniqueVeDicts[source.GetInstanceID()]);
}
}
public (string Id, UnityEngine.Object Component) GetCachedComponent(Transform targetTansform, string targetTransformPath, string targetComponentType)
{
UnityEngine.Object c = null;
var id = targetTransformPath + "#" + targetComponentType;
if (!cachedComponent.TryGetValue(id, out c))
{
if (targetComponentType.Contains("UnityEngine.GameObject"))
{
c = targetTansform.gameObject;
}
else
{
c = ViewSystemUtilitys.GetComponent(targetTansform, targetComponentType);
}
if (c == null)
{
ViewSystemLog.LogError($"Target Component cannot be found [{targetComponentType}] on GameObject [{transform.name } / {targetTransformPath}]");
}
cachedComponent.Add(id, c);
}
return(id, c);
}
public bool SetData(Transform root, Transform root_prefab, System.Action <IEnumerable <ViewElementPropertyOverrideData> > OnImport, ViewSystemNode node)
{
this.root = root;
this.root_prefab = root_prefab;
this.node = node;
this.OnImport = OnImport;
titleContent = new GUIContent("ViewElement Overrides Importer");
propertyModification = PrefabUtility.GetPropertyModifications(root.gameObject)
.ToArray();
var group = propertyModification.GroupBy(x => x.target);
var groupedByTarget = group.Where(m => m.Key != null).ToDictionary(o => o.Key, o => o.ToList());
foreach (var target in groupedByTarget.Keys)
{
var groupedByProperty = groupedByTarget[target].GroupBy(x => x.propertyPath.Split('.')[0]).ToDictionary(o => o.Key, o => o.ToList());
foreach (var property in groupedByProperty.Keys)
{
// This find the orignal SerializedObject
var so = new SerializedObject(target);
// This find the orignal SerializedProperty
var sp = so.FindProperty(property);
if (VS_EditorUtility.IsPropertyNeedIgnore(sp))
{
continue;
}
var temp = new OverridesPropertiesCheckerData();
temp.serializedPropertyType = sp.propertyType;
temp.overrideData.targetPropertyName = property;
//temp.overrideData.targetPropertyType = sp.propertyType.ToString();
//temp.overrideData.targetPropertyPath = VS_EditorUtility.ParseUnityEngineProperty(property);
Transform t;
if (sp.serializedObject.targetObject as Component == null)
{
t = ((GameObject)sp.serializedObject.targetObject).transform;
}
else
{
t = ((Component)sp.serializedObject.targetObject).transform;
}
var path = AnimationUtility.CalculateTransformPath(t, root);
var selfName = root_prefab.name.Length + 1;
if (path.Length > selfName - 1)
{
path = path.Substring(selfName, path.Length - selfName);
}
else if (path.Length == selfName - 1)
{
path = "";
}
temp.overrideData.targetTransformPath = path;
temp.overrideData.targetComponentType = target.GetType().ToString();
temp.displayName = $"{sp.displayName} ({property})";
//Find the prefab instance SerializedObject
var overrideGameObject = root.Find(path);
if (overrideGameObject == null)
{
ViewSystemLog.LogError("Target GameObject is not found, this feature only works on a root prefab instance, make sure which is not a child of other prefab instance.");
return(false);
}
UnityEngine.Object obj;
if (target is GameObject)
{
obj = overrideGameObject.gameObject;
}
else
{
obj = overrideGameObject.GetComponent(target.GetType());
}
var so_instance = new SerializedObject(obj);
//Find the prefab instance SerializedProperty
var sp_instance = so_instance.FindProperty(property);
// Add PropertyOverride to OverridesPropertiesCheckerData
PropertyOverride overProperty = new PropertyOverride();
overProperty.SetValue(sp_instance);
temp.overrideData.Value = overProperty;
// Add OverridesPropertiesCheckerData to list wait for user check
overridesPropertiesCheckerDatas.Add(temp);
}
}
maxSize = new Vector2(800, 800);
return(true);
}
public void VerifyGameObject(VerifyTarget verifyTarget = VerifyTarget.All)
{
if (editor == null)
{
ViewSystemLog.LogError("Cannot verify save data, is editor init correctlly?");
return;
}
if (saveData == null)
{
ViewSystemLog.LogError("Cannot verify save data, is editor init correctlly?");
return;
}
gameObjectCannotBeFound.Clear();
var overrideDatasInPages = saveData.viewPages.Select(m => m.viewPage);
var overrideDatasInStates = saveData.viewStates.Select(m => m.viewState);
foreach (var viewPage in overrideDatasInPages)
{
foreach (var viewPageItem in viewPage.viewPageItems)
{
List <ViewSystemComponentData> verifyTargets = new List <ViewSystemComponentData>();
if (verifyTarget == VerifyTarget.All || verifyTarget == VerifyTarget.Override)
{
verifyTargets.AddRange(viewPageItem.overrideDatas.Cast <ViewSystemComponentData>());
}
if (verifyTarget == VerifyTarget.All || verifyTarget == VerifyTarget.Event)
{
verifyTargets.AddRange(viewPageItem.eventDatas.Cast <ViewSystemComponentData>());
}
if (viewPageItem.viewElement == null)
{
ViewSystemLog.LogError("One or more viewElement is null, verify Page and State first.");
return;
}
foreach (var verifyData in verifyTargets)
{
var transform = viewPageItem.viewElement.transform.Find(verifyData.targetTransformPath);
if (transform == null)
{
gameObjectCannotBeFound.Add(
new ViewSystemGameObjectMissingData
{
isViewState = false,
viewElement = viewPageItem.viewElement,
stateOrPageName = viewPage.name,
viewSystemComponent = verifyData
});
}
}
}
}
foreach (var viewState in overrideDatasInStates)
{
foreach (var viewPageItem in viewState.viewPageItems)
{
List <ViewSystemComponentData> verifyTargets = new List <ViewSystemComponentData>();
if (verifyTarget == VerifyTarget.All || verifyTarget == VerifyTarget.Override)
{
verifyTargets.AddRange(viewPageItem.overrideDatas.Cast <ViewSystemComponentData>());
}
if (verifyTarget == VerifyTarget.All || verifyTarget == VerifyTarget.Event)
{
verifyTargets.AddRange(viewPageItem.eventDatas.Cast <ViewSystemComponentData>());
}
foreach (var verifyData in verifyTargets)
{
var transform = viewPageItem.viewElement.transform.Find(verifyData.targetTransformPath);
if (transform == null)
{
gameObjectCannotBeFound.Add(
new ViewSystemGameObjectMissingData
{
isViewState = true,
viewElement = viewPageItem.viewElement,
stateOrPageName = viewState.name,
viewSystemComponent = verifyData
});
}
}
}
}
if (gameObjectCannotBeFound.Count > 0)
{
if (EditorUtility.DisplayDialog(
"Something goes wrong!",
"There are some GameObject is missing, do you want to open fixer window",
"Yes, Please",
"Not now"))
{
var window = ScriptableObject.CreateInstance <GameObjectFixerWindow>();
window.SetData(gameObjectCannotBeFound, saveData, () =>
{
//Make sure SetDirty
EditorUtility.SetDirty(saveData);
});
window.ShowUtility();
}
}
else
{
ViewSystemLog.Log("GameObject looks good.");
}
}
public override void OnDrawScrollArea()
{
GUILayout.Label(new GUIContent($"Event fixer will replace all saved EventData please be careful", EditorGUIUtility.FindTexture("console.erroricon")));
foreach (var item in needFixEventData)
{
using (var horizon = new EditorGUILayout.HorizontalScope("box"))
{
item.fix = EditorGUILayout.ToggleLeft(GUIContent.none, item.fix, GUILayout.Width(20));
using (var vertical = new EditorGUILayout.VerticalScope())
{
using (var horizon2 = new EditorGUILayout.HorizontalScope())
{
GUILayout.Label($"Method : [{item.originalMethodName}] in Script : [{item.originalScriptName}]");
using (var disable = new EditorGUI.DisabledGroupScope(!classMethodInfo.ContainsKey(item.originalScriptName)))
{
if (GUILayout.Button("Apply Origin Data"))
{
item.modifyScriptName = item.originalScriptName;
item.modifyMethodName = item.originalMethodName;
}
}
}
int currentSelectClass = string.IsNullOrEmpty(item.modifyScriptName) ? 0 : classMethodInfo.Values.ToList().IndexOf(classMethodInfo[item.modifyScriptName]);
using (var check = new EditorGUI.ChangeCheckScope())
{
currentSelectClass = EditorGUILayout.Popup("Event Script", currentSelectClass, classMethodInfo.Select(m => m.Key).ToArray());
if (check.changed)
{
ViewSystemLog.Log(currentSelectClass);
if (currentSelectClass != 0)
{
var c = classMethodInfo.ElementAt(currentSelectClass);
item.modifyScriptName = c.Key;
item.modifyMethodName = "";
}
else
{
item.modifyScriptName = "";
item.modifyMethodName = "";
}
}
}
if (currentSelectClass != 0)
{
using (var check = new EditorGUI.ChangeCheckScope())
{
using (var horizon2 = new EditorGUILayout.HorizontalScope())
{
var c = classMethodInfo.ElementAt(currentSelectClass).Value;
var current = c.SingleOrDefault(m => m.name == item.modifyMethodName);
CMEditorLayout.GroupedPopupField(item.GetHashCode(), new GUIContent("Event Method"), c, current,
(select) =>
{
item.modifyMethodName = select.name;
}
);
}
}
}
}
}
}
}
public void VerifyProperty(VerifyTarget verifyTarget)
{
propertyCannotBeFound.Clear();
IEnumerable <ViewSystemComponentData> targetVerifyDatas = null;
//Data may changed by Component fixer so refresh again.
if (verifyTarget == VerifyTarget.Override)
{
RefreshOverrideDatas();
targetVerifyDatas = allOverrideDatas.SelectMany(m => m.overrideDatas).Cast <ViewSystemComponentData>();
}
if (verifyTarget == VerifyTarget.Event)
{
RefreshEventDatas();
targetVerifyDatas = allEventDatas.SelectMany(m => m.eventDatas).Cast <ViewSystemComponentData>();
}
foreach (var item in targetVerifyDatas)
{
var t = MacacaGames.Utility.GetType(item.targetComponentType);
if (t == null)
{
ViewSystemLog.LogError(item.targetComponentType + " still not fixed cannot be found, will ignore while verify property");
continue;
}
var propertyName = item.targetPropertyName;
if (t.ToString().Contains("UnityEngine."))
{
propertyName = ViewSystemUtilitys.ParseUnityEngineProperty(item.targetPropertyName);
}
if (t.GetField(item.targetPropertyName, bindingFlags) == null && t.GetProperty(propertyName, bindingFlags) == null)
{
ViewSystemLog.LogError($"{item.targetPropertyName} in {item.targetComponentType} cannot be found");
if (propertyCannotBeFound.Count(m => m == item.targetComponentType + "," + item.targetPropertyName) == 0)
{
propertyCannotBeFound.Add(item.targetComponentType + "," + item.targetPropertyName);
}
}
}
if (propertyCannotBeFound.Count > 0)
{
if (EditorUtility.DisplayDialog(
"Something goes wrong!",
"There are some override property is missing, do you want to open fixer window",
"Yes, Please",
"Not now"))
{
var window = ScriptableObject.CreateInstance <PropertyFixerWindow>();
window.SetData(propertyCannotBeFound, targetVerifyDatas, saveData, () =>
{
//Make sure SetDirty
EditorUtility.SetDirty(saveData);
if (verifyTarget == VerifyTarget.Event)
{
VerifyEvents();
}
});
window.ShowUtility();
}
}
else
{
ViewSystemLog.Log("Great, everying looks good!");
}
}
public void VerifyComponent(VerifyTarget verifyTarget)
{
if (editor == null)
{
ViewSystemLog.LogError("Cannot verify save data, is editor init correctlly?");
return;
}
if (saveData == null)
{
ViewSystemLog.LogError("Cannot verify save data, is editor init correctlly?");
return;
}
typeNameCannotBeFound.Clear();
if (verifyTarget == VerifyTarget.Event)
{
RefreshEventDatas();
foreach (var vpi in allEventDatas)
{
foreach (var item in vpi.eventDatas)
{
var t = MacacaGames.Utility.GetType(item.targetComponentType);
if (t == null)
{
ViewSystemLog.LogError(item.targetComponentType + " cannot be found");
typeNameCannotBeFound.Add(item.targetComponentType);
}
}
}
}
if (verifyTarget == VerifyTarget.Override)
{
RefreshOverrideDatas();
foreach (var vpi in allOverrideDatas)
{
foreach (var item in vpi.overrideDatas)
{
var t = MacacaGames.Utility.GetType(item.targetComponentType);
if (t == null)
{
ViewSystemLog.LogError(item.targetComponentType + " cannot be found");
typeNameCannotBeFound.Add(item.targetComponentType);
}
}
}
}
if (typeNameCannotBeFound.Count > 0)
{
if (EditorUtility.DisplayDialog(
"Something goes wrong!",
"There are some override component is missing, do you want to open fixer window",
"Yes, Please",
"Not now"))
{
List <ViewSystemComponentData> componentDatas;
if (verifyTarget == VerifyTarget.Override)
{
componentDatas = allOverrideDatas.Cast <ViewSystemComponentData>().ToList();
}
else
{
componentDatas = allEventDatas.Cast <ViewSystemComponentData>().ToList();
}
var window = ScriptableObject.CreateInstance <ComponentFixerWindow>();
window.SetData(typeNameCannotBeFound, componentDatas, () =>
{
//Make sure SetDirty
EditorUtility.SetDirty(saveData);
VerifyProperty(verifyTarget);
});
window.ShowUtility();
}
}
else
{
ViewSystemLog.Log("Components looks good, let's check properties.");
VerifyProperty(verifyTarget);
}
}
private void DrawMenuBar()
{
menuBar = new Rect(0, 0, position.width, menuBarHeight);
using (var area = new GUILayout.AreaScope(menuBar, "", EditorStyles.toolbar))
{
using (var horizon = new GUILayout.HorizontalScope())
{
using (var disable = new EditorGUI.DisabledGroupScope(!CanEnterEditMode))
{
using (var changed = new EditorGUI.ChangeCheckScope())
{
EditMode = GUILayout.Toggle(EditMode, new GUIContent("Edit Mode"), EditorStyles.toolbarButton, GUILayout.Height(menuBarHeight));
if (changed.changed == true)
{
if (EditMode)
{
dataReader.EditStart();
}
else
{
dataReader.EditEnd();
}
}
}
}
GUILayout.Space(5);
if (GUILayout.Button(new GUIContent($"Save{(((ViewSystemDataReaderV2)dataReader).isDirty ? "*" : "")}", EditorGUIUtility.FindTexture("d_SaveAs@2x")), EditorStyles.toolbarButton, GUILayout.Width(50)))
{
if (isInit == false)
{
#if UNITY_2019_1_OR_NEWER
ViewSystemLog.ShowNotification(this, new GUIContent("Editor is not Initial."), 2);
#else
ViewSystemLog.ShowNotification(this, new GUIContent("Editor is not Initial."));
#endif
return;
}
if (EditorUtility.DisplayDialog("Save", "Save action will also delete all ViewElement in scene. \nDo you really want to continue?", "Yes", "No"))
{
if (dataReader.GetSaveData().globalSetting.UIRootScene == null)
{
ViewSystemLog.LogWarning("There is no UIRoot in edit, will ignore the saving of UIRoot Prefab.");
}
dataReader.Save(viewPageList, viewStateList);
}
}
if (GUILayout.Button(new GUIContent("Reload", Drawer.refreshIcon, "Reload data"), EditorStyles.toolbarButton, GUILayout.Width(80)))
{
if (overridePopupWindow != null)
{
overridePopupWindow.show = false;
}
RefreshData();
}
if (GUILayout.Button(new GUIContent("Clear Preview", "Clear all preview item"), EditorStyles.toolbarButton))
{
((ViewSystemDataReaderV2)dataReader).ClearAllViewElementInScene();
}
if (GUILayout.Button(new GUIContent("Normalized", "Normalized all item (Will Delete the Canvas Root Object in Scene)"), EditorStyles.toolbarButton))
{
overridePopupWindow.show = false;
dataReader.Normalized();
inspector.Normalized();
}
GUILayout.Space(5);
using (var check = new EditorGUI.ChangeCheckScope())
{
inspector.show = GUILayout.Toggle(inspector.show, new GUIContent(Drawer.inspectorIcon, "Show Inspector"), EditorStyles.toolbarButton, GUILayout.Height(menuBarHeight), GUILayout.Width(25));
if (check.changed)
{
inspectorContianer.parent.style.display = inspector.show ? DisplayStyle.Flex : DisplayStyle.None;
}
}
GUILayout.Space(5);
if (globalSettingWindow != null)
{
globalSettingWindow.show = GUILayout.Toggle(globalSettingWindow.show, new GUIContent("Global Setting", EditorGUIUtility.FindTexture("SceneViewTools")), EditorStyles.toolbarButton, GUILayout.Height(menuBarHeight));
}
GUILayout.Space(5);
if (viewPageOrderWindow != null)
{
viewPageOrderWindow.show = GUILayout.Toggle(viewPageOrderWindow.show, new GUIContent("Overlay Order", EditorGUIUtility.FindTexture("CustomSorting"), "Batch modify Overlay Pager Sorting Order"), EditorStyles.toolbarButton, GUILayout.Height(menuBarHeight));
}
GUILayout.Space(5);
if (GUILayout.Button(new GUIContent("Verifiers"), EditorStyles.toolbarDropDown, GUILayout.Height(menuBarHeight)))
{
GenericMenu genericMenu = new GenericMenu();
genericMenu.AddItem(new GUIContent("Verify GameObjects"), false,
() =>
{
viewSystemVerifier.VerifyGameObject(ViewSystemVerifier.VerifyTarget.All);
}
);
genericMenu.AddItem(new GUIContent("Verify Overrides"), false,
() =>
{
viewSystemVerifier.VerifyComponent(ViewSystemVerifier.VerifyTarget.Override);
}
);
genericMenu.AddItem(new GUIContent("Verify Events"), false,
() =>
{
viewSystemVerifier.VerifyComponent(ViewSystemVerifier.VerifyTarget.Event);
}
);
genericMenu.AddItem(new GUIContent("Verify Pages and States"), false,
() =>
{
viewSystemVerifier.VerifyPagesAndStates();
}
);
genericMenu.ShowAsContext();
}
using (var check = new EditorGUI.ChangeCheckScope())
{
search = EditorGUILayout.TextField(search, new GUIStyle("SearchTextField"));
}
GUILayout.FlexibleSpace();
GUILayout.Label(new GUIContent(Drawer.zoomIcon, "Zoom"), GUIStyle.none);
zoomScale = EditorGUILayout.Slider(zoomScale, zoomScaleMinMax.x, zoomScaleMinMax.y, GUILayout.Width(120));
if (GUILayout.Button(new GUIContent(EditorGUIUtility.FindTexture("AvatarCompass"), "Reset viewport to (0,0)"), EditorStyles.toolbarButton, GUILayout.Width(30)))
{
viewPortScroll = Vector2.zero;
}
if (GUILayout.Button(new GUIContent(Drawer.bakeScritpIcon, "Bake ViewPage and ViewState to script"), EditorStyles.toolbarButton, GUILayout.Width(50)))
{
ViewSystemScriptBaker.BakeAllViewPageName(
viewPageList.Select(m => m.viewPage).ToList(),
viewStateList.Select(m => m.viewState).ToList(),
saveData.globalSetting.breakPoints.ToList());
}
if (GUILayout.Button("Options", EditorStyles.toolbarDropDown))
{
UnityEditor.PopupWindow.Show(popupBtnRect, new EditorPopupSetting());
}
if (Event.current.type == EventType.Repaint)
{
popupBtnRect = GUILayoutUtility.GetLastRect();
}
}
}
}
internal void SetEvent(IEnumerable <ViewElementEventData> eventDatas)
{
currentEventDatas = eventDatas.ToArray();
//Group by Component transform_component_property
var groupedEventData = eventDatas.GroupBy(item => item.targetTransformPath + ";" + item.targetComponentType + ";" + item.targetPropertyName);
foreach (var item in groupedEventData)
{
string[] p = item.Key.Split(';');
//p[0] is targetTransformPath
Transform targetTansform = GetTransform(p[0]);
if (targetTansform == null)
{
ViewSystemLog.LogError($"Target GameObject cannot be found [{transform.name} / {p[0]}]");
continue;
}
EventRuntimeDatas eventRuntimeDatas;
// Get UnityEvent property instance
if (!cachedUnityEvent.TryGetValue(item.Key, out eventRuntimeDatas))
{
//p[1] is targetComponentType
var result = GetCachedComponent(targetTansform, p[0], p[1]);
//p[2] is targetPropertyPath
string property = p[2];
if (p[1].Contains("UnityEngine."))
{
property = ViewSystemUtilitys.ParseUnityEngineProperty(p[2]);
}
var unityEvent = (UnityEventBase)GetPropertyValue(result.Component, property);
eventRuntimeDatas = new EventRuntimeDatas(unityEvent, (Component)result.Component);
cachedUnityEvent.Add(item.Key, eventRuntimeDatas);
if (eventRuntimeDatas.unityEvent is UnityEvent events)
{
events.AddListener(EventHandler);
}
}
currentComponent = eventRuntimeDatas.component;
// Usually there is only one event on one Selectable
// But the system allow mutil event on one Selectable
foreach (var item2 in item)
{
var id_delegate = item2.scriptName + ";" + item2.methodName;
//Try to get the cached openDelegate object first
//Or create a new openDelegate
if (!cachedDelegate.TryGetValue(id_delegate, out EventDelegate <Component> openDelegate))
{
// Get Method
Type type = Utility.GetType(item2.scriptName);
//MethodInfo method = type.GetMethod(item2.methodName);
//The method impletmented Object
Component scriptInstance = (Component)FindObjectOfType(type);
if (scriptInstance == null)
{
scriptInstance = GenerateScriptInstance(type);
}
//Create Open Delegate
try
{
openDelegate = CreateOpenDelegate(item2.methodName, scriptInstance);
}
catch (Exception ex)
{
ViewSystemLog.LogError($"Create event delegate faild, make sure the method or the instance is exinst. Exception:{ex.ToString()}", this);
}
cachedDelegate.Add(id_delegate, openDelegate);
}
currentEventDelegates.Add(openDelegate);
}
}
}
public IEnumerator OnShowRunner(bool manual)
{
IsShowed = true;
if (lifeCyclesObjects != null)
{
foreach (var item in lifeCyclesObjects.ToArray())
{
try
{
item.OnBeforeShow();
}
catch (Exception ex) { ViewSystemLog.LogError(ex.ToString(), this); }
}
}
SetActive(true);
if (selfViewElementGroup != null)
{
if (selfViewElementGroup.OnlyManualMode && manual == false)
{
if (gameObject.activeSelf)
{
SetActive(false);
}
goto END;
}
selfViewElementGroup.OnShowChild();
}
if (transition == TransitionType.Animator)
{
animator.Play(AnimationStateName_In);
if (transition == TransitionType.Animator && hasLoopBool)
{
animator.SetBool(ButtonAnimationBoolKey, true);
}
}
else if (transition == TransitionType.CanvasGroupAlpha)
{
canvasGroup.alpha = 0;
if (canvasGroupCoroutine != null)
{
viewController.StopMicroCoroutine(canvasGroupCoroutine);
}
// canvasGroupCoroutine = viewController.StartMicroCoroutine(EaseMethods.EaseValue(
// canvasGroup.alpha,
// 1,
// canvasInTime,
// EaseMethods.GetEase(canvasInEase),
// (v) =>
// {
// canvasGroup.alpha = v;
// },
// () =>
// {
// canvasGroupCoroutine = null;
// }
// ));
canvasGroupCoroutine = viewController.StartMicroCoroutine(
EaseUtility.To(
canvasGroup.alpha,
1,
canvasInTime,
canvasInEase,
(v) =>
{
canvasGroup.alpha = v;
},
() =>
{
canvasGroupCoroutine = null;
}
)
);
}
else if (transition == TransitionType.Custom)
{
OnShowHandle.Invoke(null);
}
END:
if (lifeCyclesObjects != null)
{
foreach (var item in lifeCyclesObjects.ToArray())
{
try
{
item.OnStartShow();
}
catch (Exception ex) { ViewSystemLog.LogError(ex.ToString(), this); }
}
}
if (_allGraphics != null)
{
for (int i = 0; i < _allGraphics.Length; i++)
{
if (_allGraphics[i].raycastTarget == false)
{
GraphicRegistry.UnregisterGraphicForCanvas(_allGraphics[i].canvas, _allGraphics[i]);
}
}
}
showCoroutine = null;
yield break;
}
public IEnumerator OnLeaveRunner(bool NeedPool = true, bool ignoreTransition = false)
{
//ViewSystemLog.LogError("OnLeave " + name);
if (transition == TransitionType.Animator && hasLoopBool)
{
animator.SetBool(ButtonAnimationBoolKey, false);
}
needPool = NeedPool;
OnLeaveWorking = true;
if (lifeCyclesObjects != null)
{
foreach (var item in lifeCyclesObjects.ToArray())
{
try
{
item.OnBeforeLeave();
}
catch (Exception ex) { ViewSystemLog.LogError(ex.Message, this); }
}
}
if (selfViewElementGroup != null)
{
selfViewElementGroup.OnLeaveChild(ignoreTransition);
}
//在試圖 leave 時 如果已經是 disable 的 那就直接把他送回池子
//如果 ignoreTransition 也直接把他送回池子
if (gameObject.activeSelf == false || ignoreTransition)
{
goto END;
}
if (transition == TransitionType.Animator)
{
try
{
if (animatorTransitionType == AnimatorTransitionType.Direct)
{
if (animator.HasState(0, Animator.StringToHash(AnimationStateName_Out)))
{
animator.Play(AnimationStateName_Out);
}
else
{
animator.Play("Disable");
}
}
else
{
animator.ResetTrigger(AnimationStateName_Out);
animator.SetTrigger(AnimationStateName_Out);
}
}
catch
{
goto END;
}
}
else if (transition == TransitionType.CanvasGroupAlpha)
{
if (canvasGroup == null)
{
ViewSystemLog.LogError("No Canvas Group Found on this Object", this);
}
if (canvasGroupCoroutine != null)
{
viewController.StopMicroCoroutine(canvasGroupCoroutine);
}
// canvasGroupCoroutine = viewController.StartMicroCoroutine(EaseMethods.EaseValue(
// canvasGroup.alpha,
// 0,
// canvasOutTime,
// EaseMethods.GetEase(canvasOutEase),
// (v) =>
// {
// canvasGroup.alpha = v;
// },
// () =>
// {
// canvasGroupCoroutine = null;
// }
// ));
canvasGroupCoroutine = viewController.StartMicroCoroutine(
EaseUtility.To(
canvasGroup.alpha,
0,
canvasOutTime,
canvasOutEase,
(v) =>
{
canvasGroup.alpha = v;
},
() =>
{
canvasGroupCoroutine = null;
}
)
);
goto END;
}
else if (transition == TransitionType.Custom)
{
OnLeaveHandle.Invoke(OnLeaveAnimationFinish);
}
else
{
goto END;
}
END:
if (!ignoreTransition && !isSkipOutAnimation)
{
float time = 0;
var outDuration = GetOutDuration();
while (time < outDuration)
{
time += GlobalTimer.deltaTime;
yield return(null);
}
}
if (lifeCyclesObjects != null)
{
foreach (var item in lifeCyclesObjects.ToArray())
{
try
{
item.OnStartLeave();
}
catch (Exception ex) { ViewSystemLog.LogError(ex.Message, this); }
}
}
leaveCoroutine = null;
OnLeaveAnimationFinish();
// });
}
void DrawItem(ViewPageItem vpi, bool isViewState = false)
{
using (var vertical2 = new GUILayout.VerticalScope(Drawer.darkBoxStyle))
{
using (var horizon = new GUILayout.HorizontalScope())
{
GUILayout.Label(new GUIContent($"{vpi.displayName}", Drawer.prefabIcon), EditorStyles.whiteLabel, GUILayout.Height(16));
GUILayout.FlexibleSpace();
GUILayout.Label($"({vpi.Id})");
}
if (vpi.viewElement == null)
{
GUILayout.Label(new GUIContent("ViewElement is not set up!", Drawer.miniErrorIcon));
return;
}
var selectables = vpi.viewElement.GetComponentsInChildren <Selectable>();
foreach (var select in selectables)
{
using (var vertical3 = new GUILayout.VerticalScope("box"))
{
var path = AnimationUtility.CalculateTransformPath(select.transform, vpi.viewElement.transform);
var component = select.GetType().ToString();
using (var horizon = new GUILayout.HorizontalScope())
{
using (var vertical4 = new GUILayout.VerticalScope())
{
var p = path.Split('/');
GUILayout.Label(new GUIContent($"{vpi.viewElement.name}", Drawer.prefabIcon), GUILayout.Height(16));
for (int i = 0; i < p.Length; i++)
{
if (string.IsNullOrEmpty(p[i]))
{
continue;
}
using (var horizon2 = new GUILayout.HorizontalScope())
{
GUILayout.Space((i + 1) * 15);
GUILayout.Label(new GUIContent($"{p[i]}", Drawer.prefabIcon), GUILayout.Height(16));
}
}
}
GUILayout.FlexibleSpace();
GUILayout.Label(new GUIContent(Drawer.arrowIcon));
var editorContent = new GUIContent(EditorGUIUtility.ObjectContent(select, select.GetType()));
GUILayout.FlexibleSpace();
GUILayout.Label(editorContent, height);
}
ViewElementNavigationData currentNavSetting = null;
ViewElementNavigationDataViewState viewElementNavigationDataViewState = null;
if (isViewState == false)
{
currentNavSetting = vpi.navigationDatas
.SingleOrDefault(m =>
m.targetComponentType == component &&
m.targetTransformPath == path
);
}
else
{
viewElementNavigationDataViewState = viewPage.navigationDatasForViewState.SingleOrDefault(m => m.viewPageItemId == vpi.Id);
if (viewElementNavigationDataViewState != null)
{
currentNavSetting = viewElementNavigationDataViewState.navigationDatas
.SingleOrDefault(m =>
m.targetComponentType == component &&
m.targetTransformPath == path
);
}
}
bool hasSetting = currentNavSetting != null;
using (var horizon = new GUILayout.HorizontalScope())
{
if (GUILayout.Button("Select In Hierarchy", EditorStyles.miniButton))
{
if (vpi.previewViewElement)
{
Selection.objects = new UnityEngine.Object[] { vpi.previewViewElement.transform.Find(path).gameObject };
}
}
using (var disable = new EditorGUI.DisabledGroupScope(!hasSetting))
{
if (GUILayout.Button("Apply Setting", EditorStyles.miniButton))
{
ApplySetting();
}
}
}
if (!hasSetting)
{
if (GUILayout.Button("Add Navigation Setting"))
{
if (isViewState == false)
{
var nav = new ViewElementNavigationData();
nav.targetComponentType = component;
nav.targetTransformPath = path;
nav.mode = select.navigation.mode;
vpi.navigationDatas.Add(nav);
}
else
{
if (viewElementNavigationDataViewState == null)
{
viewElementNavigationDataViewState = new ViewElementNavigationDataViewState();
viewElementNavigationDataViewState.viewPageItemId = vpi.Id;
}
var nav = new ViewElementNavigationData();
nav.targetComponentType = component;
nav.targetTransformPath = path;
nav.mode = select.navigation.mode;
viewElementNavigationDataViewState.navigationDatas.Add(nav);
viewPage.navigationDatasForViewState.Add(viewElementNavigationDataViewState);
}
}
}
else
{
using (var horizon = new GUILayout.HorizontalScope())
{
using (var check = new EditorGUI.ChangeCheckScope())
{
var result = (UnityEngine.UI.Navigation.Mode)
EditorGUILayout.EnumPopup(currentNavSetting.mode);
if (result != UnityEngine.UI.Navigation.Mode.Explicit)
{
currentNavSetting.mode = result;
}
else
{
ViewSystemLog.LogError("Currently Navigation Setting doesn't support Mode with Explicit");
}
if (check.changed)
{
//Do something
if (autoApplyNavigation)
{
ApplySetting();
}
}
}
if (GUILayout.Button(new GUIContent(EditorGUIUtility.FindTexture("d_TreeEditor.Trash")), Drawer.removeButtonStyle, GUILayout.Width(25)))
{
if (isViewState == false)
{
vpi.navigationDatas.Remove(currentNavSetting);
}
else
{
viewElementNavigationDataViewState.navigationDatas.Remove(currentNavSetting);
}
}
}
}
void ApplySetting()
{
if (isViewState == false)
{
vpi.previewViewElement.ApplyNavigation(vpi.navigationDatas);
}
else
{
vpi.previewViewElement.ApplyNavigation(viewElementNavigationDataViewState.navigationDatas);
}
SceneView.RepaintAll();
}
}
}
}
}
