Files
tianrunCRM/Assets/CoolapeFrame/Scripts/ui/public/CLPanelManager.cs

742 lines
24 KiB
C#
Raw Normal View History

2020-07-04 14:41:25 +08:00
/*
********************************************************************************
*Copyright(C),coolae.net
*Author: chenbin
*Version: 2.0
*Date: 2017-01-09
*Description: NGUI每个页面的
*Others:
*History:
*********************************************************************************
*/
using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
namespace Coolape
{
public class CLPanelManager : MonoBehaviour
{
public static CLPanelManager self;
bool isUnity3dType = true;
public Transform _uiPanelRoot;
public Transform uiPanelRoot
{
get
{
if (_uiPanelRoot == null)
{
_uiPanelRoot = transform;
}
return _uiPanelRoot;
}
}
public CLPanelManager()
{
self = this;
}
[NonSerialized]
public int depth = 100;
public const int Const_RenderQueue = 3000;
public int cachePanelSize = 10;
//当前
public static Hashtable showingPanels = new Hashtable();
public static ArrayList panelCacheQueue = ArrayList.Synchronized(new ArrayList());
public static void onShowPanel(CLPanelBase panel)
{
if (panel == null)
return;
showingPanels[panel.gameObject.name] = panel;
panelCacheQueue.Remove(panel);
panelCacheQueue.Insert(0, panel);
CLPanelBase bottomPanel = null;
if (panelCacheQueue.Count > self.cachePanelSize)
{
bottomPanel = (panelCacheQueue[panelCacheQueue.Count - 1]) as CLPanelBase;
panelCacheQueue.RemoveAt(panelCacheQueue.Count - 1);
if (bottomPanel.destroyWhenHide)
{
if (!bottomPanel.isActive && !CLPanelManager.panelRetainLayer.Contains(bottomPanel))
{
//虽然页面是关掉了但是如果还是在panelRetainLayer里则不能删除因为当关掉顶层页面时这个页面还是会被打开
CLPanelManager.destroyPanel(bottomPanel, false);
}
}
}
}
public static void onHidePanel(CLPanelBase panel)
{
if (panel == null)
return;
showingPanels.Remove(panel.gameObject.name);
}
//显示窗体********************************************************************
public static Queue<CLPanelBase> seaShowPanel = new Queue<CLPanelBase>();
public static bool isShowPanel = false;
public static void showPanel(CLPanelBase panel)
{
//if(panel == null) return;
//Debug.LogError("====show panel==="+panel.name);
seaShowPanel.Enqueue(panel);
isShowPanel = true;
}
//关闭窗体********************************************************************
public static bool isHidePanel = false;
public static Queue<CLPanelBase> seaHidePanel = new Queue<CLPanelBase>();
public static void hidePanel(CLPanelBase panel)
{
//if(panel == null) return;
//Debug.LogError("====hide panel==="+panel.name);
seaHidePanel.Enqueue(panel);
isHidePanel = true;
self.Update();
}
//显示窗体到最顶层********************************************************************
public static Stack<CLPanelBase> panelRetainLayer = new Stack<CLPanelBase>();
public static CLPanelBase[] panels4Retain
{
get
{
return panelRetainLayer.ToArray();
}
}
public static bool isShowTopPanel = false;
public static CLPanelBase topPanel = null;
public static CLPanelBase oldPanel = null;
public static CLPanelBase oldoldPanel = null;
public static bool isShowPrePanel = false;
public static int depthOffset = 200;
/// <summary>
/// Shows the top panel.把panel显示在顶层,如果showTopPanel用打开窗体就必须用hideTopPanel关闭窗体
/// </summary>
/// <param name='panel'>
/// Panel.
/// </param>
/// <param name='isRetainCurr'>
/// Is retain curr.是否保留当前层
/// </param>
/// <param name='isShowCurr'>
/// Is show curr.是否显示当前层
/// </param>
public static void showTopPanel(CLPanelBase panel, bool isRetainCurr, bool isShowCurr)
{
// self.StartCoroutine(doShowTopPanel(panel, isRetainCurr, isShowCurr, true));
doShowTopPanel(panel, isRetainCurr, isShowCurr, true);
}
public static void doShowTopPanel(CLPanelBase panel, bool isRetainCurr, bool isShowCurr, bool immed)
{
// yield return null;
isShowPrePanel = isShowCurr;
oldoldPanel = oldPanel;
if (panelRetainLayer.Count > 0)
{
if (!isRetainCurr)
{
self.depth -= depthOffset;
self.depth = self.depth < depthOffset ? depthOffset : self.depth;
oldPanel = panelRetainLayer.Pop();
}
else
{
oldPanel = panelRetainLayer.Peek();
}
}
else
{
oldPanel = null;
}
panelRetainLayer.Push(panel);
// if (isShowCurr) {
// self.depth += 10;
// }
topPanel = panel;
isShowTopPanel = true;
if (immed)
{
self.Update();
}
}
public static void showTopPanel(CLPanelBase panel)
{
showTopPanel(panel, false, false);
}
public string mainPanelName = "";
//关闭顶层窗体********************************************************************
public static void hideTopPanel()
{
hideTopPanel(null, true, true);
}
public static void hideTopPanel(CLPanelBase panel)
{
hideTopPanel(panel, true, true);
}
public static void hideTopPanel(CLPanelBase panel, bool showMain, bool immed)
{
if (panel == null || (panelRetainLayer.Count > 0 && panelRetainLayer.Peek() == panel))
{
if (showMain && !string.IsNullOrEmpty(self.mainPanelName)
&& topPanel != null && string.Compare(self.mainPanelName, topPanel.name) == 0)
{
topPanel.refresh();
return;
}
if (panelRetainLayer.Count > 0)
{
self.depth -= depthOffset;
self.depth = self.depth < depthOffset ? depthOffset : self.depth;
seaHidePanel.Enqueue(panelRetainLayer.Pop());
isHidePanel = true;
}
if (panelRetainLayer.Count > 0)
{
isShowTopPanel = true;
}
else
{
if (CLPBackplate.self != null)
{
CLPBackplate.self.proc(null);
}
}
oldPanel = oldoldPanel;
oldoldPanel = null;
}
else
{
rmPanelRetainLayer(panel);
seaHidePanel.Enqueue(panel);
isHidePanel = true;
}
if (immed)
{
self.Update();
}
}
public static void rmPanelRetainLayer(CLPanelBase panel)
{
Stack<CLPanelBase> tmpStack = new Stack<CLPanelBase>();
CLPanelBase p = null;
while (panelRetainLayer.Count > 0)
{
p = panelRetainLayer.Pop();
if (p != panel)
{
tmpStack.Push(p);
}
}
while (tmpStack.Count > 0)
{
panelRetainLayer.Push(tmpStack.Pop());
}
}
//关闭所有层**********************************************************************
public static void hideAllPanel(string exceptPanelName = null)
{
CLPanelBase p = null;
oldPanel = null;
oldoldPanel = null;
CLPanelBase exceptPanel = null;
int count = panelRetainLayer.Count;
for (int i = 0; i < count; i++)
{
p = panelRetainLayer.Pop();
if (p.name.Equals(exceptPanel))
{
exceptPanel = p;
self.depth -= depthOffset;
self.depth = self.depth < depthOffset ? depthOffset : self.depth;
}
else
{
self.depth -= depthOffset;
self.depth = self.depth < depthOffset ? depthOffset : self.depth;
seaHidePanel.Enqueue(p);
isHidePanel = true;
}
}
if(exceptPanel != null)
{
panelRetainLayer.Push(exceptPanel);
exceptPanel.depth = self.depth;
}
oldPanel = null;
oldoldPanel = null;
self.mask.SetActive(false);
self.Update();
foreach (DictionaryEntry cell in panelBuff)
{
p = cell.Value as CLPanelBase;
if (p != null && p.gameObject.activeInHierarchy)
{
if (!p.name.Equals(exceptPanel))
{
hidePanel(p);
}
}
}
}
public void Update()
{
if (isShowPanel)
{
isShowPanel = false;
CLPanelBase p = seaShowPanel.Dequeue();
if (p != null)
{
p.show();
p.panel.renderQueue = UIPanel.RenderQueue.StartAt;
// 设置startingRenderQueue是为了可以在ui中使用粒子效果注意在粒子中要绑定CLUIParticle角本
p.panel.startingRenderQueue = Const_RenderQueue + p.panel.depth;
}
if (seaShowPanel.Count > 0)
{
isShowPanel = true;
}
}
if (isHidePanel)
{
isHidePanel = false;
CLPanelBase p = seaHidePanel.Dequeue();
if (p != null)
{
p.hide();
}
if (seaHidePanel.Count > 0)
{
isHidePanel = true;
}
else
{
CLPBackplateProc(null);
}
}
if (isShowTopPanel)
{
isShowTopPanel = false;
if (oldPanel != null)
{
if (!isShowPrePanel)
{
oldPanel.hide();
if (oldoldPanel != null)
{
// Vector3 newPos = oldoldPanel.transform.localPosition;
// oldoldPanel.transform.localPosition = newPos;
oldPanel = oldoldPanel;
oldoldPanel = null;
}
}
else
{
// Vector3 newPos = oldPanel.transform.localPosition;
// oldPanel.transform.localPosition = newPos;
// if (oldoldPanel != null) {
// newPos = oldoldPanel.transform.localPosition;
// oldoldPanel.transform.localPosition = newPos;
// }
}
}
//置顶的处理放在后面防止oldoldPannel = curPannel的情况
if (panelRetainLayer.Count > 0)
{
//GlobalMemoryVar.curStatus.changeTo (GlobalMemoryVar.sNgui);
float panelZ = 0;
if (topPanel != null)
{
//panelZ = topPanel.transform.localPosition.z;
}
topPanel = panelRetainLayer.Peek();
if (topPanel != null)
{
if (!topPanel.isActive)
{
depth += depthOffset;
topPanel.depth = depth;
topPanel.show();
}
else
{
topPanel.depth = depth;
topPanel.refresh();
}
topPanel.panel.renderQueue = UIPanel.RenderQueue.StartAt;
// 设置startingRenderQueue是为了可以在ui中使用粒子效果注意在粒子中要绑定CLUIParticle角本
topPanel.panel.startingRenderQueue = Const_RenderQueue + depth;
//Vector3 newPos = topPanel.transform.localPosition;
//newPos.z = -topPanel.depth;
//topPanel.transform.localPosition = newPos;
}
CLPBackplateProc(topPanel);
onTopPanelChange(topPanel);
}
else
{
CLPBackplateProc(null);
}
}
}
void onTopPanelChange(CLPanelBase p)
{
// CLPanelBase[] ps = panelRetainLayer.ToArray ();
// if (ps != null) {
// for (int i = 0; i < ps.Length; i++) {
// ps [i].onTopPanelChange (p);
// }
// }
ArrayList list = MapEx.vals2List(showingPanels);
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
((CLPanelBase)(list[i])).onTopPanelChange(p);
}
list.Clear();
list = null;
}
}
void CLPBackplateProc(CLPanelBase p)
{
CLPanelBase panel = getPanel("PanelBackplate");
if (panel == null)
return;
CLPBackplate.self.proc(p);
}
//=======================================
public static Hashtable panelBuff = new Hashtable();
public static Hashtable panelAssetBundle = new Hashtable();
public static bool isFinishStart = false;
public void Start()
{
if (!isFinishStart)
{
for (int i = 0; i < uiPanelRoot.childCount; i++)
{
CLPanelBase p = uiPanelRoot.GetChild(i).GetComponent<CLPanelBase>();
if (p != null)
{
panelBuff[p.name] = p;
}
}
isFinishStart = true;
}
}
GameObject _mask;
public GameObject mask
{
get
{
if (_mask == null)
{
_mask = new GameObject("_____mask");
_mask.transform.parent = CLUIInit.self.transform;
NGUITools.SetLayer(_mask, LayerMask.NameToLayer("UI"));
UIWidget w = _mask.AddComponent<UIWidget>();
w.SetAnchor(CLUIInit.self.gameObject, -2, -2, 2, 2);
NGUITools.AddWidgetCollider(_mask);
_mask.SetActive(false);
}
return _mask;
}
}
public void clean()
{
panelBuff.Clear();
panelAssetBundle.Clear();
panelCacheQueue.Clear();
showingPanels.Clear();
topPanel = null;
isFinishStart = false;
mask.SetActive(false);
}
public void reset()
{
isFinishStart = false;
Start();
}
public static void resetPanelLua()
{
CLPanelLua p = null;
foreach (DictionaryEntry cell in CLPanelManager.panelBuff)
{
p = (CLPanelLua)(cell.Value);
p.reLoadLua();
p.setLua();
}
}
public static void destoryAllPanel()
{
ArrayList list = new ArrayList();
list.AddRange(panelAssetBundle.Values);
for (int i = 0; i < list.Count; i++)
{
destroyPanel((CLPanelBase)(list[i]));
}
panelAssetBundle.Clear();
panelRetainLayer.Clear();
topPanel = null;
}
public static void getPanelAsy(string pName, object callback)
{
getPanelAsy(pName, callback, null);
}
public static void getPanelAsy(string pName, object callback, object paras)
{
NGUITools.SetActive(self.mask, true);
if (!isFinishStart)
{
CLPanelManager.self.Start();
}
CLPanelBase p = null;
if (panelBuff[pName] != null)
{
p = ((CLPanelBase)(panelBuff[pName]));
}
if (p == null)
{
#if UNITY_5_6_OR_NEWER
Transform tr = self.transform.Find(pName);
#else
Transform tr = self.transform.FindChild (pName);
#endif
if (tr != null)
{
p = tr.GetComponent<CLPanelBase>();
if (p != null)
{
panelBuff[pName] = p;
}
}
}
if (p != null)
{
Utl.doCallback(callback, p, paras);
NGUITools.SetActive(self.mask, false);
}
else
{
self.StartCoroutine(loadPanel(pName, callback, paras));
}
}
static IEnumerator loadPanel(string pName, object callback, object paras)
{
if (CLCfgBase.self.isEditMode)
{
string path = PStr.begin().a("file://").a(CLPathCfg.persistentDataPath).a("/")
.a(CLPathCfg.self.panelDataPath).a(CLPathCfg.self.platform).a("/").a(pName).a(".unity3d").end();
if (CLCfgBase.self.isEditMode)
{
path = path.Replace("/upgradeRes/", "/upgradeRes4Publish/");
}
WWW www = new WWW(path);
yield return www;
if (string.IsNullOrEmpty(www.error))
{
finishGetPanel(pName, www.assetBundle, callback, paras);
www.Dispose();
www = null;
}
}
else
{
string path = PStr.begin().a(CLPathCfg.self.panelDataPath).a(CLPathCfg.self.platform).a("/").a(pName).a(".unity3d").end();
CLVerManager.self.getNewestRes(path, CLAssetType.assetBundle, (Callback)onGetPanelAssetBundle, true, callback, pName, paras);
}
}
public static void onGetPanelAssetBundle(params object[] args)
{
string Path = args[0].ToString();
object content = args[1];
object[] orgs = (object[])(args[2]);
object callback = null;
string pName = "";
object paras = null;
if (orgs != null && orgs.Length > 2)
{
callback = orgs[0];
pName = orgs[1].ToString();
paras = orgs[2];
}
finishGetPanel(pName, (AssetBundle)(content), callback, paras);
}
public static void finishGetPanel(string pName, AssetBundle ab, object callback, object paras)
{
if (ab != null)
{
GameObject prefab = ab.mainAsset as GameObject;
ab.Unload(false);
ab = null;
GameObject go = GameObject.Instantiate(prefab) as GameObject;
go.name = pName;
go.transform.parent = self.transform;
go.transform.localScale = Vector3.one;
go.transform.localPosition = Vector3.zero;
CLPanelBase p = go.GetComponent<CLPanelBase>();
if (p.isNeedResetAtlase)
{
CLUIUtl.resetAtlasAndFont(p.transform, false);
}
panelBuff[pName] = p;
panelAssetBundle[pName] = p;
CLSharedAssets sharedAsset = go.GetComponent<CLSharedAssets>();
if (sharedAsset != null)
{
NewList param = ObjPool.listPool.borrowObject();
param.Add(callback);
param.Add(p);
param.Add(paras);
sharedAsset.init((Callback)onGetSharedAssets, param, null);
}
else
{
if (p != null)
{
Utl.doCallback(callback, p, paras);
}
}
}
NGUITools.SetActive(self.mask, false);
return;// null;
}
static void onGetSharedAssets(params object[] param)
{
if (param == null)
{
Debug.LogWarning("param == null");
return;
}
NewList list = (NewList)(param[0]);
if (list.Count >= 3)
{
object cb = list[0];
CLPanelBase p = list[1] as CLPanelBase;
object orgs = list[2];
if (cb != null)
{
Utl.doCallback(cb, p, orgs);
}
}
else
{
Debug.LogWarning("list.Count ====0");
}
ObjPool.listPool.returnObject(list);
}
public static CLPanelBase getPanel(string pName)
{
if (!isFinishStart)
{
CLPanelManager.self.Start();
}
if (panelBuff[pName] != null)
{
return ((CLPanelBase)(panelBuff[pName]));
}
#if UNITY_5_6_OR_NEWER
Transform tr = self.transform.Find(pName);
#else
Transform tr = self.transform.FindChild (pName);
#endif
if (tr != null)
{
CLPanelBase p = tr.GetComponent<CLPanelBase>();
if (p != null)
{
panelBuff[pName] = p;
return p;
}
}
// if (self.isUnity3dType) {
//#if !UNITY_ANDROID
// string path = PStr.begin().a(PathCfg.persistentDataPath).a("/")
// .a(PathCfg.self.panelDataPath).a(PathCfg.self.platform).a("/").a(pName).a(".unity3d").end();
//#if UNITY_EDITOR
// path = path.Replace("/upgradeRes/", "/upgradeRes4Publish/");
//#endif
// AssetBundle ab = AssetBundle.LoadFromFile(path);
//#if UNITY_EDITOR
// if(ab == null) {
// Debug.LogError(pName + " is null");
// }
//#endif
// return onGetPanel(pName, ab, null, null);
//#endif
// }
return null;
}
public static void destroyPanel(CLPanelBase p)
{
destroyPanel(p, true);
}
public static void destroyPanel(CLPanelBase p, bool needCallHideFunc)
{
if (p == null || p.name == CLMainBase.self.firstPanel)
return;
string pName = p.name;
panelBuff.Remove(pName);
panelAssetBundle.Remove(pName);
if (needCallHideFunc)
{
p.hide();
}
GameObject.DestroyImmediate(p.gameObject, true);
p = null;
}
}
}