diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/DlgHandlerBase.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/DlgHandlerBase.cs | 525 |
1 files changed, 525 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/DlgHandlerBase.cs b/Client/Assets/Scripts/XMainClient/DlgHandlerBase.cs new file mode 100644 index 00000000..fc76c6c5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/DlgHandlerBase.cs @@ -0,0 +1,525 @@ +using System;
+using UILib;
+using UnityEngine;
+using XMainClient.UI.UICommon;
+using XUpdater;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ public abstract class DlgHandlerBase : IDlgHandlerMgr
+ {
+ public bool bLoaded
+ {
+ get
+ {
+ return this.m_bLoaded;
+ }
+ }
+
+ protected virtual string FileName
+ {
+ get
+ {
+ return string.Empty;
+ }
+ }
+
+ public virtual bool has3DAvatar
+ {
+ get
+ {
+ return false;
+ }
+ }
+
+ protected virtual Vector3 OffSet
+ {
+ get
+ {
+ return Vector3.zero;
+ }
+ }
+
+ protected virtual Transform parent
+ {
+ get
+ {
+ return (this.m_parent == null && this.m_gameObject != null) ? this.m_gameObject.transform.parent : this.m_parent;
+ }
+ set
+ {
+ this.m_parent = value;
+ bool flag = this.m_gameObject != null;
+ if (flag)
+ {
+ this.m_gameObject.transform.parent = this.m_parent;
+ }
+ }
+ }
+
+ protected string luaFileName
+ {
+ get
+ {
+ return base.GetType().Name;
+ }
+ }
+
+ public bool activeSelf
+ {
+ get
+ {
+ return this.m_bLoaded && this.m_gameObject != null && this.m_gameObject.activeSelf;
+ }
+ }
+
+ public virtual bool active
+ {
+ get
+ {
+ return this.m_bLoaded && this.m_gameObject != null && this.m_gameObject.activeInHierarchy;
+ }
+ }
+
+ public GameObject PanelObject
+ {
+ get
+ {
+ return this.m_gameObject;
+ }
+ set
+ {
+ bool flag = value != null && (this.m_gameObject == null || this.m_handlerState == DlgHandlerBase.HandlerState.Setup || this.m_handlerState == DlgHandlerBase.HandlerState.Error);
+ if (flag)
+ {
+ this.m_gameObject = value;
+ this.m_transform = this.m_gameObject.transform;
+ this.m_parent = this.m_gameObject.transform.parent;
+ this.m_gameObject.SetActive(true);
+ this.Loaded();
+ }
+ else
+ {
+ bool flag2 = value == null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("GameObject is NULL!", null, null, null, null, null);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("GameObject is exist!", null, null, null, null, null);
+ }
+ }
+ }
+ }
+
+ public Transform transform
+ {
+ get
+ {
+ return this.m_transform;
+ }
+ }
+
+ public DlgHandlerMgr HandlerMgr
+ {
+ get
+ {
+ return this.m_DlgHandlerMgr;
+ }
+ }
+
+ protected DlgHandlerBase.HandlerState m_handlerState = DlgHandlerBase.HandlerState.Setup;
+
+ private LoadUIFinishedEventHandler m_loadUIAsynHandler;
+
+ private bool m_bLoaded = false;
+
+ private Transform m_parent;
+
+ private GameObject m_gameObject;
+
+ private Transform m_transform;
+
+ private bool m_visible = false;
+
+ private bool m_isLoad = false;
+
+ protected bool m_bDelayInited = false;
+
+ protected int m_dummPool = -1;
+
+ private DlgHandlerMgr m_DlgHandlerMgr = null;
+
+ protected DlgHandlerMgr m_ParentHandlerMgr = null;
+
+ public enum HandlerState
+ {
+ Setup,
+ Loading,
+ Loaded,
+ Inited,
+ Show,
+ Hide,
+ Dispose,
+ Error
+ }
+
+ public DlgHandlerBase()
+ {
+ this.m_DlgHandlerMgr = new DlgHandlerMgr();
+ }
+
+ public virtual void OnUpdate()
+ {
+ this.HandlerMgr.OnUpdate();
+ }
+
+ public virtual void OnUnload()
+ {
+ }
+
+ public void UnLoad()
+ {
+ bool flag = !this.m_bLoaded;
+ if (!flag)
+ {
+ this.UnRegisterEvent();
+ ILuaEngine xluaEngine = XSingleton<XUpdater.XUpdater>.singleton.XLuaEngine;
+ xluaEngine.hotfixMgr.TryFixHandler(HotfixMode.UNLOAD, this.luaFileName, this.m_gameObject);
+ this.OnUnload();
+ this.m_loadUIAsynHandler = null;
+ this.m_handlerState = DlgHandlerBase.HandlerState.Dispose;
+ bool bDelayInited = this.m_bDelayInited;
+ if (bDelayInited)
+ {
+ this._OnDelayUnload();
+ this.m_bDelayInited = false;
+ }
+ bool flag2 = this.m_DlgHandlerMgr != null;
+ if (flag2)
+ {
+ this.m_DlgHandlerMgr.Unload();
+ this.m_DlgHandlerMgr = null;
+ }
+ bool isLoad = this.m_isLoad;
+ if (isLoad)
+ {
+ XResourceLoaderMgr.SafeDestroy(ref this.m_gameObject, false);
+ this.m_isLoad = false;
+ }
+ this.m_bLoaded = false;
+ }
+ }
+
+ public bool IsVisible()
+ {
+ return this.active;
+ }
+
+ public void SetVisible(bool bvisible)
+ {
+ this.m_visible = bvisible;
+ if (bvisible)
+ {
+ this.Show();
+ }
+ else
+ {
+ this.ExcuteHide();
+ }
+ }
+
+ protected virtual void Init()
+ {
+ }
+
+ public virtual void RegisterEvent()
+ {
+ }
+
+ public virtual void UnRegisterEvent()
+ {
+ }
+
+ protected virtual void OnShow()
+ {
+ }
+
+ protected virtual void OnHide()
+ {
+ }
+
+ public Component FindInChild(string ComponentName, string behaivorPath = "")
+ {
+ Transform transform = this.FindChild(behaivorPath);
+ bool flag = transform == null;
+ Component result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ result = transform.GetComponent(ComponentName);
+ }
+ return result;
+ }
+
+ public Transform FindChild(string behaivorPath = "")
+ {
+ return (this.m_transform == null) ? null : this.m_transform.Find(behaivorPath);
+ }
+
+ private void Show()
+ {
+ bool flag = this.m_handlerState == DlgHandlerBase.HandlerState.Setup;
+ if (flag)
+ {
+ this.Load();
+ }
+ else
+ {
+ bool flag2 = this.m_handlerState == DlgHandlerBase.HandlerState.Inited || this.m_handlerState == DlgHandlerBase.HandlerState.Hide;
+ if (flag2)
+ {
+ this.ExcuteShow();
+ }
+ }
+ }
+
+ private void Load()
+ {
+ this.m_handlerState = DlgHandlerBase.HandlerState.Loading;
+ bool flag = !string.IsNullOrEmpty(this.FileName);
+ if (flag)
+ {
+ this.m_isLoad = true;
+ bool flag2 = this.m_loadUIAsynHandler == null;
+ if (flag2)
+ {
+ this.m_loadUIAsynHandler = new LoadUIFinishedEventHandler(this.LoadUIFinish);
+ }
+ XSingleton<UIManager>.singleton.LoadUI(this.FileName, this.m_loadUIAsynHandler);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Handler FileName is Empty!", null, null, null, null, null);
+ }
+ }
+
+ private void LoadUIFinish(string location)
+ {
+ this.m_gameObject = (XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefab("UI/" + location, true, false) as GameObject);
+ bool flag = this.m_gameObject != null;
+ if (flag)
+ {
+ this.m_handlerState = DlgHandlerBase.HandlerState.Loaded;
+ this.m_transform = this.m_gameObject.transform;
+ this.m_gameObject.name = this.m_gameObject.name.Replace("(Clone)", "");
+ this.m_gameObject.transform.parent = this.m_parent;
+ this.m_gameObject.transform.localPosition = this.OffSet;
+ this.m_gameObject.transform.localScale = Vector3.one;
+ this.m_gameObject.SetActive(true);
+ this.Loaded();
+ this.ExcuteShow();
+ this.m_bLoaded = true;
+ }
+ else
+ {
+ this.m_handlerState = DlgHandlerBase.HandlerState.Error;
+ XSingleton<XDebug>.singleton.AddErrorLog(XSingleton<XCommon>.singleton.StringCombine(location, " load error!"), null, null, null, null, null);
+ }
+ }
+
+ private void ExcuteShow()
+ {
+ bool visible = this.m_visible;
+ if (visible)
+ {
+ bool flag = this.m_handlerState == DlgHandlerBase.HandlerState.Inited || this.m_handlerState == DlgHandlerBase.HandlerState.Hide;
+ if (flag)
+ {
+ bool flag2 = this.m_gameObject == null;
+ if (!flag2)
+ {
+ this.m_gameObject.SetActive(true);
+ this.m_handlerState = DlgHandlerBase.HandlerState.Show;
+ bool flag3 = !this.m_bDelayInited;
+ if (flag3)
+ {
+ this._DelayInit();
+ this.m_bDelayInited = true;
+ }
+ this.RegisterEvent();
+ ILuaEngine xluaEngine = XSingleton<XUpdater.XUpdater>.singleton.XLuaEngine;
+ bool flag4 = !xluaEngine.hotfixMgr.TryFixHandler(HotfixMode.BEFORE, this.luaFileName, this.m_gameObject);
+ if (flag4)
+ {
+ this.OnShow();
+ xluaEngine.hotfixMgr.TryFixHandler(HotfixMode.AFTER, this.luaFileName, this.m_gameObject);
+ }
+ }
+ }
+ }
+ else
+ {
+ this.ExcuteHide();
+ }
+ }
+
+ private void Loaded()
+ {
+ this.Initialize();
+ }
+
+ private void Initialize()
+ {
+ this.Init();
+ this.m_bLoaded = true;
+ this.m_handlerState = DlgHandlerBase.HandlerState.Inited;
+ }
+
+ private void ExcuteHide()
+ {
+ bool flag = this.m_handlerState == DlgHandlerBase.HandlerState.Show || this.m_handlerState == DlgHandlerBase.HandlerState.Inited;
+ if (flag)
+ {
+ bool flag2 = this.m_gameObject == null;
+ if (!flag2)
+ {
+ this.m_gameObject.SetActive(false);
+ bool flag3 = this.m_handlerState == DlgHandlerBase.HandlerState.Show;
+ if (flag3)
+ {
+ ILuaEngine xluaEngine = XSingleton<XUpdater.XUpdater>.singleton.XLuaEngine;
+ xluaEngine.hotfixMgr.TryFixHandler(HotfixMode.HIDE, this.luaFileName, this.m_gameObject);
+ this.UnRegisterEvent();
+ this.OnHide();
+ }
+ this.m_handlerState = DlgHandlerBase.HandlerState.Hide;
+ }
+ }
+ }
+
+ protected virtual void _OnDelayUnload()
+ {
+ this.m_bDelayInited = false;
+ }
+
+ protected virtual void _DelayInit()
+ {
+ }
+
+ public virtual void StackRefresh()
+ {
+ bool flag = this.m_DlgHandlerMgr != null;
+ if (flag)
+ {
+ this.m_DlgHandlerMgr.StackRefresh();
+ }
+ }
+
+ public virtual void LeaveStackTop()
+ {
+ bool flag = this.m_DlgHandlerMgr != null;
+ if (flag)
+ {
+ this.m_DlgHandlerMgr.LeaveStackTop();
+ }
+ }
+
+ public virtual void RefreshData()
+ {
+ }
+
+ protected void Alloc3DAvatarPool(string user, int maxCount = 1)
+ {
+ bool flag = this.m_dummPool < 0;
+ if (flag)
+ {
+ this.m_dummPool = XSingleton<X3DAvatarMgr>.singleton.AllocDummyPool(user, maxCount);
+ }
+ }
+
+ protected void Return3DAvatarPool()
+ {
+ XSingleton<X3DAvatarMgr>.singleton.ReturnDummyPool(this.m_dummPool);
+ this.m_dummPool = -1;
+ }
+
+ public static T EnsureCreate<T>(ref T handler, Transform parent, bool visible = true, IDlgHandlerMgr handlerMgr = null) where T : DlgHandlerBase, new()
+ {
+ bool flag = parent == null;
+ if (flag)
+ {
+ parent = XSingleton<UIManager>.singleton.UIRoot;
+ }
+ bool flag2 = handler == null;
+ if (flag2)
+ {
+ handler = Activator.CreateInstance<T>();
+ handler.parent = parent;
+ handler.SetVisible(visible);
+ bool flag3 = handlerMgr != null;
+ if (flag3)
+ {
+ handlerMgr.HandlerMgr.Add(handler);
+ handler.m_ParentHandlerMgr = handlerMgr.HandlerMgr;
+ }
+ }
+ else
+ {
+ handler.parent = parent;
+ handler.SetVisible(visible);
+ }
+ return handler;
+ }
+
+ public static T EnsureCreate<T>(ref T handler, GameObject panelObject, IDlgHandlerMgr parent = null, bool visible = true) where T : DlgHandlerBase, new()
+ {
+ bool flag = handler == null;
+ if (flag)
+ {
+ handler = DlgHandlerBase.Create<T>(panelObject, parent, visible);
+ }
+ else
+ {
+ handler.SetVisible(visible);
+ }
+ return handler;
+ }
+
+ public static T Create<T>(GameObject panelObject, IDlgHandlerMgr parent, bool visible = true) where T : DlgHandlerBase, new()
+ {
+ T t = Activator.CreateInstance<T>();
+ t.PanelObject = panelObject;
+ t.m_bLoaded = true;
+ t.SetVisible(visible);
+ bool flag = parent != null;
+ if (flag)
+ {
+ parent.HandlerMgr.Add(t);
+ t.m_ParentHandlerMgr = parent.HandlerMgr;
+ }
+ return t;
+ }
+
+ public static void EnsureUnload<T>(ref T handler) where T : DlgHandlerBase
+ {
+ bool flag = handler != null && handler.m_bLoaded;
+ if (flag)
+ {
+ handler.UnLoad();
+ handler.m_bLoaded = false;
+ bool flag2 = handler.m_ParentHandlerMgr != null;
+ if (flag2)
+ {
+ handler.m_ParentHandlerMgr.Remove(handler);
+ }
+ }
+ handler = default(T);
+ }
+ }
+}
|