using Snxxz.UI;
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using TableConfig;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI
|
{
|
public class ComposeToolsWin : Window
|
{
|
[SerializeField]
|
GameObject composeUIShowObj;
|
[SerializeField]
|
GameObject noneComposeObj;
|
|
[SerializeField]
|
ScrollerController cellCtrl;
|
|
[SerializeField]
|
List<GameObject> sourceItemlist = new List<GameObject>();
|
|
[SerializeField]
|
List<GameObject> previewItemlist = new List<GameObject>();
|
|
[SerializeField]
|
Text successRateText;
|
|
[SerializeField]
|
Button composeAllBtn;
|
|
[SerializeField]
|
Button composeBtn;
|
|
[SerializeField] UIEffect composeEffect;
|
|
ComposeWinModel _composeWinModel;
|
ComposeWinModel composeWinModel
|
{
|
get { return _composeWinModel ?? (_composeWinModel = ModelCenter.Instance.GetModel<ComposeWinModel>()); }
|
}
|
|
private Dictionary<int, Dictionary<int, List<ItemCompoundConfig>>> firstTypeDict = null;
|
private Dictionary<int, List<ItemCompoundConfig>> secondTypeDict = null;
|
private List<ItemCompoundConfig> thirdTypelist = null;
|
|
private int curSecondType = 0;
|
private int curThirdType = 0;
|
private int preSecondType = 0;
|
[SerializeField] int initSuccessRate = 10000;
|
ItemCompoundConfig compoundModel = null;
|
|
SelectEquipModel _selectModel;
|
private Dictionary<int,List<int>> fixedItemIndexDict = new Dictionary<int, List<int>>();
|
|
SelectEquipModel selectModel
|
{
|
get { return _selectModel ?? (_selectModel = ModelCenter.Instance.GetModel<SelectEquipModel>()); }
|
}
|
|
ItemTipsModel _itemTipsModel;
|
ItemTipsModel itemTipsModel
|
{
|
get
|
{
|
return _itemTipsModel ?? (_itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>());
|
}
|
}
|
|
PlayerPackModel _playerPack;
|
PlayerPackModel playerPack
|
{
|
get { return _playerPack ?? (_playerPack = ModelCenter.Instance.GetModel<PlayerPackModel>()); }
|
}
|
|
GetItemPathModel ItemPathModel
|
{
|
get { return ModelCenter.Instance.GetModel<GetItemPathModel>(); }
|
}
|
|
AchievementGuideEffect guidEffect = null;
|
bool isJumpTo;
|
protected override void BindController()
|
{
|
cellCtrl.OnRefreshCell += RefreshCell;
|
cellCtrl.lockType = EnhanceLockType.KeepVertical;
|
composeWinModel.ResetModelEvent += ResetModel;
|
|
}
|
|
protected override void AddListeners()
|
{
|
composeBtn.AddListener(OnClickComposeBtn);
|
composeAllBtn.AddListener(OnClickComposeAllBtn);
|
}
|
protected override void OnPreOpen()
|
{
|
DTCA814_tagMCMakeItemAnswer.MakeItemAnswerEvent += OnComposeAnswer;
|
firstTypeDict = composeWinModel.GetFirstTypeModel((int)ComposeFuncType.Item);
|
isJumpTo = false;
|
if (AchievementGoto.guideAchievementId != 0)
|
{
|
SuccessConfig successConfig = Config.Instance.Get<SuccessConfig>(AchievementGoto.guideAchievementId);
|
if (successConfig.Type == 69)
|
{
|
isJumpTo = true;
|
curSecondType = composeWinModel.secondType;
|
curThirdType = composeWinModel.thirdType;
|
secondTypeDict = composeWinModel.GetSecondTypeModel((int)ComposeFuncType.Item,composeWinModel.secondType);
|
ClickSecondTypeUICtrl();
|
composeWinModel.ResetJumpToModel();
|
}
|
}
|
else
|
{
|
if (composeWinModel.secondType != 0)
|
{
|
isJumpTo = true;
|
curSecondType = composeWinModel.secondType;
|
curThirdType = composeWinModel.thirdType;
|
secondTypeDict = composeWinModel.GetSecondTypeModel((int)ComposeFuncType.Item, composeWinModel.secondType);
|
ClickSecondTypeUICtrl();
|
composeWinModel.ResetJumpToModel();
|
}
|
else if(composeWinModel.composeToolRed.state == RedPointState.Simple)
|
{
|
foreach(var second in composeWinModel.secondTypeRedDict.Keys)
|
{
|
if(composeWinModel.secondTypeRedDict[second].state == RedPointState.Simple)
|
{
|
string key = StringUtility.Contact(second,10);
|
foreach(var third in composeWinModel.thirdTypeRedDict.Keys)
|
{
|
if(composeWinModel.thirdTypeRedDict[third].state == RedPointState.Simple)
|
{
|
string thirdType = third.Substring(key.Length,third.Length - key.Length);
|
isJumpTo = true;
|
curSecondType = second;
|
curThirdType = int.Parse(thirdType);
|
secondTypeDict = composeWinModel.GetSecondTypeModel((int)ComposeFuncType.Item, second);
|
ClickSecondTypeUICtrl();
|
composeWinModel.ResetJumpToModel();
|
break;
|
}
|
}
|
break;
|
}
|
}
|
}
|
}
|
|
CreateCell();
|
if (curSecondType == 0)
|
{
|
RefreshUI(null);
|
}
|
}
|
|
protected override void OnAfterOpen()
|
{
|
this.transform.SetAsLastSibling();
|
StartCoroutine(SetOffestPos());
|
}
|
|
protected override void OnPreClose()
|
{
|
DTCA814_tagMCMakeItemAnswer.MakeItemAnswerEvent -= OnComposeAnswer;
|
}
|
|
protected override void OnAfterClose()
|
{
|
|
}
|
|
private void ResetModel()
|
{
|
curSecondType = 0;
|
curThirdType = 0;
|
preSecondType = 0;
|
compoundModel = null;
|
}
|
|
private void CreateCell()
|
{
|
cellCtrl.Refresh();
|
if(firstTypeDict != null)
|
{
|
foreach (int secondType in firstTypeDict.Keys)
|
{
|
cellCtrl.AddCell(ScrollerDataType.Header,secondType);
|
if(secondType == curSecondType)
|
{
|
foreach (int thirdType in firstTypeDict[secondType].Keys)
|
{
|
if (thirdType != 0)
|
{
|
ItemCompoundConfig compoundConfig = firstTypeDict[secondType][thirdType][0];
|
int makeID = ConfigParse.GetMultipleStr<int>(compoundConfig.makeID)[0];
|
if(secondType != 3)
|
{
|
cellCtrl.AddCell(ScrollerDataType.Normal, thirdType);
|
}
|
else
|
{
|
if (composeWinModel.IsComposeJobLimit(makeID))
|
{
|
cellCtrl.AddCell(ScrollerDataType.Normal, thirdType);
|
}
|
}
|
|
}
|
}
|
}
|
}
|
}
|
cellCtrl.Restart();
|
|
if (secondTypeDict != null)
|
{
|
if (secondTypeDict.Count >= 1 && curSecondType != 0)
|
{
|
cellCtrl.JumpIndex(GetCurIndex(curSecondType));
|
}
|
}
|
}
|
|
private int GetCurIndex(int secondType)
|
{
|
int curIndex = 0;
|
List<int> secondlist = firstTypeDict.Keys.ToList();
|
for (int i = 0; i < secondlist.Count; i++)
|
{
|
if (secondType == secondlist[i])
|
{
|
curIndex = i;
|
break;
|
}
|
}
|
return curIndex;
|
}
|
|
private IEnumerator SetOffestPos()
|
{
|
yield return null;
|
if (curThirdType >= 5)
|
{
|
cellCtrl.JumpIndex(curThirdType*50, 0, EnhancedUI.EnhancedScroller.EnhancedScroller.TweenType.immediate);
|
}
|
CheckJumpModel();
|
}
|
|
private void CheckJumpModel()
|
{
|
if (compoundModel != null)
|
{
|
RefreshUI(compoundModel);
|
if (isJumpTo)
|
{
|
isJumpTo = false;
|
bool isCanCompose = true;
|
if (!composeWinModel.IsEnoughFixedMat(compoundModel) || !composeWinModel.IsEnoughUnfixedMat(compoundModel))
|
{
|
MessageWin.Inst.ShowFixedTip(Language.Get("Compose101"));
|
isCanCompose = false;
|
}
|
else if (!composeWinModel.IsEnoughMoney(compoundModel))
|
{
|
MessageWin.Inst.ShowFixedTip(Language.Get("L1006"));
|
isCanCompose = false;
|
}
|
|
if (isCanCompose)
|
{
|
guidEffect = AchievementGuideEffectPool.Require(1);
|
guidEffect.transform.SetParentEx(composeBtn.transform, Vector3.zero, Quaternion.identity, Vector3.one);
|
}
|
}
|
}
|
}
|
|
private void RefreshCell(ScrollerDataType type, CellView cell)
|
{
|
Image icon = cell.transform.Find("BtnIcon").GetComponent<Image>();
|
Text name = cell.transform.Find("BtnText").GetComponent<Text>();
|
Button cellBtn = cell.GetComponent<Button>();
|
RedpointBehaviour behaviour = cell.transform.Find("RedPoint").GetComponent<RedpointBehaviour>();
|
cellBtn.RemoveAllListeners();
|
ItemCompoundConfig compoundModel = null;
|
switch (type)
|
{
|
case ScrollerDataType.Header:
|
GameObject arrowIcon = cell.transform.Find("SecondBtn").gameObject;
|
foreach (int thirdType in firstTypeDict[cell.index].Keys)
|
{
|
if(thirdType != 0)
|
{
|
arrowIcon.SetActive(true);
|
}
|
else
|
{
|
arrowIcon.SetActive(false);
|
}
|
|
compoundModel = firstTypeDict[cell.index][thirdType][0];
|
name.text = compoundModel.secondTypeName;
|
if (curSecondType == cell.index)
|
{
|
preSecondType = curSecondType;
|
arrowIcon.transform.localRotation = Quaternion.Euler(0, 0, -90);
|
icon.SetSprite("ComposeFirstClassChoosebtn");
|
secondTypeDict = composeWinModel.GetSecondTypeModel((int)ComposeFuncType.Item, curSecondType);
|
//ClickSecondTypeUICtrl();
|
}
|
else
|
{
|
arrowIcon.transform.localRotation = Quaternion.Euler(0, 0,0);
|
icon.SetSprite("ComposeFirstClassNormalbtn");
|
}
|
break;
|
}
|
cellBtn.AddListener(()=> { OnClickSecondType(cell.index); });
|
if(composeWinModel.secondTypeRedDict.ContainsKey(cell.index))
|
{
|
behaviour.redpointId = composeWinModel.secondTypeRedDict[cell.index].id;
|
}
|
break;
|
case ScrollerDataType.Normal:
|
compoundModel = secondTypeDict[cell.index][0];
|
name.text = compoundModel.thirdTypeName;
|
if (curThirdType == cell.index)
|
{
|
icon.SetSprite("ChildListBtn_Select");
|
thirdTypelist = composeWinModel.GetThirdTypeModellist(compoundModel.firstType,compoundModel.secondType,cell.index);
|
RefreshUI(compoundModel);
|
}
|
else
|
{
|
icon.SetSprite("ChildListBtn_UnSelect");
|
}
|
cellBtn.AddListener(() => { OnClickThirdType(cell.index); });
|
string key = StringUtility.Contact(compoundModel.secondType,10,compoundModel.thirdType);
|
if (composeWinModel.thirdTypeRedDict.ContainsKey(key))
|
{
|
behaviour.redpointId = composeWinModel.thirdTypeRedDict[key].id;
|
}
|
break;
|
}
|
}
|
|
private void OnClickSecondType(int secondType)
|
{
|
curSecondType = secondType;
|
secondTypeDict = composeWinModel.GetSecondTypeModel((int)ComposeFuncType.Item, curSecondType);
|
foreach (var thirdType in secondTypeDict.Keys)
|
{
|
if (thirdType != 0)
|
{
|
if (preSecondType == curSecondType)
|
{
|
curSecondType = 0;
|
preSecondType = 0;
|
}
|
|
}
|
curThirdType = 0;
|
break;
|
}
|
|
if (preSecondType != curSecondType)
|
{
|
preSecondType = curSecondType;
|
if(guidEffect != null)
|
{
|
AchievementGuideEffectPool.Recycle(guidEffect);
|
guidEffect = null;
|
}
|
}
|
ClickSecondTypeUICtrl();
|
CreateCell();
|
}
|
|
private void ClickSecondTypeUICtrl()
|
{
|
if (secondTypeDict.Count > 1)
|
{
|
RefreshUI(null);
|
}
|
else
|
{
|
if (secondTypeDict.ContainsKey(curThirdType))
|
{
|
RefreshUI(secondTypeDict[curThirdType][0]);
|
}
|
}
|
}
|
|
private void OnClickThirdType(int thirdType)
|
{
|
curThirdType = thirdType;
|
cellCtrl.m_Scorller.RefreshActiveCellViews();
|
}
|
|
private void RefreshUI(ItemCompoundConfig compoundModel)
|
{
|
this.compoundModel = compoundModel;
|
if (compoundModel == null)
|
{
|
noneComposeObj.SetActive(true);
|
composeUIShowObj.SetActive(false);
|
}
|
else
|
{
|
noneComposeObj.SetActive(false);
|
composeUIShowObj.SetActive(true);
|
successRateText.text = Language.Get("HallowsWin_Success", StringUtility.Contact(compoundModel.successRate / 100, "%"));
|
composeWinModel.SetCurComposeModel(compoundModel);
|
ControllerRightUI();
|
composeWinModel.composeBtnRed.state = composeWinModel.secondTypeRedDict[compoundModel.secondType].state;
|
}
|
}
|
|
private void ControllerRightUI()
|
{
|
int i = 0;
|
#region 合成物品UI
|
for (i = 0; i < previewItemlist.Count; i++)
|
{
|
int[] makeIds = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.MakeIds);
|
GameObject gridCell = previewItemlist[i].transform.Find("GridCell").gameObject;
|
if (i < makeIds.Length)
|
{
|
|
RefreshGridCellUI(gridCell, false,makeIds[i],NeedMatType.MakeItem);
|
}
|
else
|
{
|
RefreshGridCellUI(gridCell,true);
|
}
|
}
|
#endregion
|
|
#region 固定道具和不固定道具UI
|
int[] fixedDisplay = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedDisplay);
|
int[] fixedIds = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedIds);
|
int[] fixedCounts = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedCounts);
|
int[] unfixedIds = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.UnfixedIds);
|
int[] unfixedDisplay = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.UnfixedDisplay);
|
for (i = 0;i < sourceItemlist.Count; i++)
|
{
|
GameObject gridCell = sourceItemlist[i].transform.Find("GridCell").gameObject;
|
Text putInText = sourceItemlist[i].transform.Find("PutInText").GetComponent<Text>();
|
Button posBtn = sourceItemlist[i].GetComponent<Button>();
|
putInText.gameObject.SetActive(false);
|
RefreshGridCellUI(gridCell, true);
|
posBtn.RemoveAllListeners();
|
}
|
|
for (i = 0; i < fixedDisplay.Length; i++)
|
{
|
if (fixedDisplay[i] != 0)
|
{
|
GameObject matPos = sourceItemlist[fixedDisplay[i] - 1];
|
GameObject gridCell = matPos.transform.Find("GridCell").gameObject;
|
Text putInText = matPos.transform.Find("PutInText").GetComponent<Text>();
|
putInText.gameObject.SetActive(false);
|
RefreshGridCellUI(gridCell,false,fixedIds[i],NeedMatType.fixedItem);
|
}
|
}
|
|
for (i = 0; i < unfixedDisplay.Length; i++)
|
{
|
if (unfixedDisplay[i] != 0)
|
{
|
GameObject matPos = sourceItemlist[unfixedDisplay[i] - 1];
|
GameObject gridCell = matPos.transform.Find("GridCell").gameObject;
|
Text putInText = matPos.transform.Find("PutInText").GetComponent<Text>();
|
Button posBtn = matPos.GetComponent<Button>();
|
putInText.gameObject.SetActive(true);
|
RefreshGridCellUI(gridCell, false);
|
|
posBtn.RemoveAllListeners();
|
posBtn.AddListener(() => {
|
selectModel.SetAddParent(matPos);
|
selectModel.selectItem = SelectItemType.unfixed;
|
WindowCenter.Instance.Open<SelectItemWin>();
|
});
|
}
|
}
|
#endregion
|
|
}
|
|
private void RefreshGridCellUI(GameObject gridCell, bool islock, int itemId = -1,NeedMatType matType = NeedMatType.unfixedItem,int itemPlace = -1)
|
{
|
gridCell.SetActive(true);
|
ItemCell itemCell = gridCell.transform.Find("ItemCell").GetComponent<ItemCell>();
|
if (itemCell == null)
|
itemCell = gridCell.transform.Find("ItemCell").gameObject.AddComponent<ItemCell>();
|
|
GameObject gridlock = gridCell.transform.Find("GridLock").gameObject;
|
itemCell.cellBtn.onClick.RemoveAllListeners();
|
if (islock)
|
{
|
gridlock.gameObject.SetActive(true);
|
itemCell.gameObject.SetActive(false);
|
}
|
else
|
{
|
gridlock.gameObject.SetActive(false);
|
itemCell.gameObject.SetActive(true);
|
ItemModel itemModel = playerPack.GetItemModelByIndex(PackType.rptItem,itemPlace);
|
ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(itemId);
|
if (itemModel == null)
|
{
|
if(itemId != -1)
|
{
|
ItemCellModel cellModel = new ItemCellModel(itemId);
|
itemCell.Init(cellModel);
|
itemCell.cellBtn.onClick.AddListener(() =>
|
{
|
if (matType == NeedMatType.fixedItem)
|
{
|
if (itemConfig.GetWay != null && itemConfig.GetWay.Length > 0)
|
{
|
ItemPathModel.SetChinItemModel(itemId);
|
}
|
else
|
{
|
ItemAttrData attrData = new ItemAttrData(itemId, true);
|
itemTipsModel.SetItemTipsModel(attrData);
|
}
|
}
|
else
|
{
|
ItemAttrData attrData = new ItemAttrData(itemId, true);
|
itemTipsModel.SetItemTipsModel(attrData);
|
}
|
}
|
);
|
}
|
else
|
{
|
itemCell.gameObject.SetActive(false);
|
}
|
|
}
|
else
|
{
|
itemCell.Init(itemModel);
|
itemCell.cellBtn.onClick.AddListener(() =>
|
{
|
if (matType == NeedMatType.fixedItem)
|
{
|
if (itemConfig.GetWay != null && itemConfig.GetWay.Length > 0)
|
{
|
ItemPathModel.SetChinItemModel(itemId);
|
}
|
else
|
{
|
itemTipsModel.SetItemTipsModel(PackType.rptItem, itemModel.itemInfo.ItemGUID);
|
}
|
}
|
else
|
{
|
itemTipsModel.SetItemTipsModel(PackType.rptItem, itemModel.itemInfo.ItemGUID);
|
}
|
|
});
|
}
|
|
if(matType == NeedMatType.fixedItem)
|
{
|
int[] fixedIds = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedIds);
|
int[] fixedCounts = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedCounts);
|
itemCell.countText.gameObject.SetActive(true);
|
int haveCount = playerPack.GetItemCountByID(PackType.rptItem,itemId);
|
int i = 0;
|
for(i = 0; i < fixedIds.Length; i++)
|
{
|
if(fixedIds[i] == itemId)
|
{
|
if (haveCount >= fixedCounts[i])
|
{
|
itemCell.countText.text = StringUtility.Contact(UIHelper.GetTextColorByItemColor(TextColType.Green,haveCount.ToString()),
|
"/",fixedCounts[i].ToString());
|
}
|
else
|
{
|
itemCell.countText.text = StringUtility.Contact(UIHelper.GetTextColorByItemColor(TextColType.Red, haveCount.ToString()),
|
"/",fixedCounts[i].ToString());
|
}
|
break;
|
}
|
}
|
|
}
|
else
|
{
|
itemCell.countText.gameObject.SetActive(false);
|
}
|
|
}
|
|
}
|
|
private void OnClickComposeBtn()
|
{
|
if (compoundModel == null) return;
|
|
SetFixedItemIndexDic();
|
composeWinModel.SendComposeRequest(compoundModel, fixedItemIndexDict,composeEffect,1);
|
}
|
|
private void SetFixedItemIndexDic()
|
{
|
fixedItemIndexDict.Clear();
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptItem);
|
if (singlePack == null || compoundModel == null) return;
|
|
int minBindCnt = 0;
|
int minNoBindCnt = 0;
|
composeWinModel.GetBindOrNoBindMinCnt(out minBindCnt, out minNoBindCnt);
|
int[] fixedIds = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id,DisplayItemArray.FixedIds);
|
int[] fixedCounts = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedCounts);
|
for (int i = 0; i < fixedIds.Length; i++)
|
{
|
List<int> itemIndexlist = null;
|
if (minBindCnt >= fixedCounts[i])
|
{
|
itemIndexlist = singlePack.ItemIndexlistByIsBind(fixedIds[i],fixedCounts[i], 1);
|
}
|
else if (minNoBindCnt >= fixedCounts[i])
|
{
|
itemIndexlist = singlePack.ItemIndexlistByIsBind(fixedIds[i],fixedCounts[i], 0);
|
}
|
else
|
{
|
itemIndexlist = singlePack.ItemIndexlist(fixedIds[i],fixedCounts[i]);
|
}
|
|
if (itemIndexlist != null)
|
{
|
fixedItemIndexDict.Add(fixedIds[i], itemIndexlist);
|
}
|
}
|
|
}
|
|
private void OnClickComposeAllBtn()
|
{
|
if (compoundModel == null) return;
|
|
List<int> composeCountlist = new List<int>();
|
fixedItemIndexDict.Clear();
|
SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptItem);
|
int[] fixedIds = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedIds);
|
int[] fixedCounts = ItemCompoundConfig.GetDisplayArrayByType(compoundModel.id, DisplayItemArray.FixedCounts);
|
|
for (int i = 0; i < fixedIds.Length; i++)
|
{
|
int haveCount = playerPack.GetItemCountByID(PackType.rptItem,fixedIds[i]);
|
int canComposeCount = haveCount / fixedCounts[i];
|
composeCountlist.Add(canComposeCount);
|
List<int> itemIndexlist = null;
|
if (singlePack != null)
|
{
|
itemIndexlist = singlePack.ItemIndexlist(fixedIds[i],fixedCounts[i] * canComposeCount);
|
}
|
fixedItemIndexDict.Add(fixedIds[i], itemIndexlist);
|
}
|
composeCountlist.Sort();
|
composeWinModel.SendComposeRequest(compoundModel, fixedItemIndexDict, composeEffect, composeCountlist[0]);
|
}
|
|
private void OnComposeAnswer(HA814_tagMCMakeItemAnswer answer)
|
{
|
if (answer.MakeType != (int)MakeType.Def_mitItemCompound)
|
return;
|
|
if (answer.Result == 1)
|
{
|
MessageWin.Inst.ShowFixedTip(Language.Get("Compose102"));
|
}
|
else
|
{
|
MessageWin.Inst.ShowFixedTip(Language.Get("Compose103"));
|
}
|
|
RefreshUI(compoundModel);
|
selectModel.ClearSelectModel();
|
}
|
}
|
}
|
