public void New(IBxStorageNode nodeSva)
{
_nodeSva = nodeSva;
_nodeVS = _nodeSva.CreateChildNode(BxSSL.nodeVS);
_items = new List <Item>();
_tSaver = null;
}
public void SaveStorageNode(IBxStorageNode node)
{
if (_dynItem != null)
{
_dynItem.SaveStorageNode(node);
}
}
public override void LoadStorageNode(IBxStorageNode node)
{
int count = Convert.ToInt32(node.GetElementValue(BxStorageLable.elementCount));
RemoveAll();
AppendRange(count);
IEnumerable <IBxElementSite> elements = ChildSites;
IEnumerable <IBxStorageNode> childs = node.ChildNodes;
using (IEnumerator <IBxStorageNode> itor = childs.GetEnumerator())
{
itor.Reset();
foreach (IBxElementSite one in elements)
{
if (one is IBxPersistStorageNode)
{
if (!itor.MoveNext())
{
break;
}
(one as IBxPersistStorageNode).LoadStorageNode(itor.Current);
}
}
}
}
public override void LoadStorageNode(IBxStorageNode node)
{
IEnumerable <IBxElementSite> elements = ChildSites;
IEnumerable <IBxStorageNode> childs = node.ChildNodes;
//List<IBxStorageNode> subNodes = new List<IBxStorageNode>();
//foreach (IBxStorageNode n in childs)
//{
// subNodes.Add(n);
//}
using (IEnumerator <IBxStorageNode> itor = childs.GetEnumerator())
{
itor.Reset();
foreach (IBxElementSite one in elements)
{
if (one is IBxPersistStorageNode)
{
if (!itor.MoveNext())
{
break;
}
(one as IBxPersistStorageNode).LoadStorageNode(itor.Current);
}
}
}
}
public void SaveStorageNode(IBxStorageNode node)
{
if (_uiConfig != null)
{
_uiConfig.SaveStorageNode(node);
}
}
public void LoadStorageNode(IBxStorageNode node)
{
if (node.HasElement(BxXmlConfigField.name))
{
Name = node.GetElementValue(BxXmlConfigField.name);
}
if (node.HasElement(BxXmlConfigField.flag))
{
if (_flag == null)
{
InitFlag();
}
_flag.LoadFromString(node.GetElementValue(BxXmlConfigField.flag));
}
if (node.HasElement(BxXmlConfigField.controlType))
{
ControlType = Convert.ToInt32(node.GetElementValue(BxXmlConfigField.controlType));
}
if (node.HasElement(BxXmlConfigField.unitCate))
{
string s1 = node.GetElementValue(BxXmlConfigField.unitCate);
string s2 = node.GetElementValue(BxXmlConfigField.unit);
Unit = BxSystemInfo.Instance.UnitsCenter.Parse(s1).Parse(s2);
}
}
public virtual void SaveStorageNode(IBxStorageNode node)
{
if ((_config != null) && _config.NeedSave())
{
IBxStorageNode cfgNode = node.CreateChildNode(BxStorageLable.nodeConfig);
_config.SaveStorageNode(cfgNode);
}
}
public virtual void SaveStorageNode(IBxStorageNode node)
{
if (!_valid)
{
return;
}
node.SetElement(BxStorageLable.elementValue, SaveToString());
}
public override void SaveStorageNode(IBxStorageNode node)
{
base.SaveStorageNode(node);
if (!_valid)
{
return;
}
node.SetElement(BxStorageLable.elementValue, SaveToString());
}
public override void SaveStorageNode(IBxStorageNode node)
{
string curVersion = Version;
if (!string.IsNullOrEmpty(curVersion))
{
BxVersionHelp.SetVersion(node, curVersion);
}
SaveStorageNodeSameVersion(node);
}
public virtual void LoadStorageNode(IBxStorageNode node)
{
IBxStorageNode cfgNode = node.GetChildNode(BxStorageLable.nodeConfig);
if (cfgNode == null)
{
return;
}
GetUIConfigItemEx().LoadStorageNode(cfgNode);
}
//#region IBxCompound 成员
//public IEnumerable<IBxElement> Elements
//{
// get
// {
// if (_value == null)
// return null;
// return _value.ChildSites;
// }
//}
//#endregion
#region IBxPersistStorageNode 成员
public override void SaveStorageNode(IBxStorageNode node)
{
base.SaveStorageNode(node);
if (_value == null)
{
return;
}
string id = node.Storage.SVA.SaveValue(_value);
node.SetElement(BxStorageLable.elementValueID, id);
}
public override void LoadStorageNode(IBxStorageNode node)
{
base.LoadStorageNode(node);
string sID = node.GetElementValue(BxStorageLable.elementValueID);
if (string.IsNullOrEmpty(sID))
{
return;
}
node.Storage.SVA.RequestRestoreRefer(this, sID);
}
public void Save()
{
if (_tSaver != null)
{
if (_nodeSva.HasChildNode(BxSSL.nodeTS))
{
_nodeSva.RemoveChildNode(BxSSL.nodeTS);
}
IBxStorageNode nodeTS = _nodeSva.CreateChildNode(BxSSL.nodeTS);
_tSaver.Save(nodeTS);
}
}
public override void LoadStorageNode(IBxStorageNode node)
{
string val = node.GetElementValue(BxStorageLable.elementValue);
string uc = node.GetElementValue(BxStorageLable.elementUnitCate);
string u = node.GetElementValue(BxStorageLable.elementUnit);
if (!string.IsNullOrEmpty(uc))
{
IBxUnit unit = BxSystemInfo.Instance.UnitsCenter.Parse(uc).Parse(u);
SetUIValue(val, unit);
}
}
public virtual void LoadStorageNode(IBxStorageNode node)
{
string sVal = node.GetElementValue(BxStorageLable.elementValue);
if (string.IsNullOrEmpty(sVal))
{
_valid = false;
}
else
{
LoadFromString(sVal);
}
}
public override void SaveStorageNode(IBxStorageNode node)
{
base.SaveStorageNode(node);
if (Value.HasReferer)
{
string id = node.Storage.SVA.SaveValue(_value);
node.SetElement(BxStorageLable.elementValueID, id);
}
else
{
_value.SaveStorageNode(node);
}
}
public void LoadStorageNode(IBxStorageNode node)
{
int index;
foreach (IBxStorageNode one in node.ChildNodes)
{
index = int.Parse(one.Name.Substring(4));
if ((0 <= index) && (index < _columns.Count))
{
_columns[index].LoadStorageNode(one);
}
}
}
protected void Load(XmlElement node)
{
_xmlRoot = node;
_stg = new BxStorageNode(_xmlRoot.FirstChild as XmlElement, this);
IBxStorageNode svaNode = _stg.GetChildNode(BxSSL.nodeSVA);
if (svaNode != null)
{
_sva = new BxSVA();
_sva.Load(svaNode);
}
_elementsNode = _stg.GetChildNode(BxSSL.nodeEles);
}
public override void SaveStorageNode(IBxStorageNode node)
{
IEnumerable <IBxElementSite> elements = ChildSites;
IBxStorageNode subNode;
foreach (IBxElementSite one in elements)
{
if (one is IBxPersistStorageNode)
{
subNode = node.CreateChildNode(BxStorageLable.nodeEle);
(one as IBxPersistStorageNode).SaveStorageNode(subNode);
}
}
}
public override void LoadStorageNode(IBxStorageNode node)
{
base.LoadStorageNode(node);
string id = node.GetElementValue(BxStorageLable.elementValueID);
if (string.IsNullOrEmpty(id))
{
Value.LoadStorageNode(node);
}
else
{
node.Storage.SVA.LoadValue(_value, id);
}
}
public void Save(IBxStorageNode node)
{
node.SetElement(BxSSL.elementValue, _ass.FullName);
IBxStorageNode childNode = null;
int index = 0;
foreach (Type one in _types)
{
childNode = node.CreateChildNode(BxSSL.nodeItem + index.ToString());
childNode.SetElement(BxSSL.elementValue, one.FullName);
index++;
}
}
public void Save(IBxStorageNode node)
{
if (_assList == null)
{
return;
}
IBxStorageNode assNode = null;
foreach (BxAssembly one in _assList)
{
assNode = node.CreateChildNode(BxSSL.nodeAss + one.Index.ToString());
one.Save(assNode);
}
}
protected virtual void SaveElement(IBxStorageNode node)
{
IBxElement element = Element;
bool needShare = (element is IBxReferableElement) && (IsRefer || (element as IBxReferableElement).HasReferer);
if (needShare)
{
string id = node.Storage.SVA.SaveValue(element as IBxReferableElement);
node.SetElement(BxStorageLable.elementValueID, id);
}
else
{
(element as IBxPersistStorageNode).SaveStorageNode(node);
}
}
public void SaveStorageNode(IBxStorageNode node)
{
FieldInfo[] fields = this.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
IBxStorageNode subNode;
foreach (FieldInfo one in fields)
{
if (one.GetCustomAttributes(typeof(BxCarrierElement), false).Length > -1)
{
IBxPersistStorageNode ele = one.GetValue(this) as IBxPersistStorageNode;
subNode = node.CreateChildNode(BxStorageLable.nodeEle);
ele.SaveStorageNode(subNode);
}
}
}
public virtual void SaveStorageNode(IBxStorageNode node)
{
if ((_config != null) && _config.NeedSave())
{
IBxStorageNode cfgNode = node.CreateChildNode(BxStorageLable.nodeConfig);
_config.SaveStorageNode(cfgNode);
IBxStorageNode valueNode = node.CreateChildNode(BxStorageLable.nodeValue);
SaveElement(valueNode);
}
else
{
SaveElement(node);
}
}
protected void New()
{
XmlDocument doc = new XmlDocument();
_xmlRoot = doc.CreateElement("root");
doc.AppendChild(_xmlRoot);
XmlElement stg = doc.CreateElement(BxSSL.nodeStg);
_xmlRoot.AppendChild(stg);
_stg = new BxStorageNode(stg, this);
_sva = new BxSVA();
_sva.New(_stg.CreateChildNode(BxSSL.nodeSVA));
_elementsNode = _stg.CreateChildNode(BxSSL.nodeEles);
}
public void Load(IBxStorageNode node)
{
IEnumerable <IBxStorageNode> childs = node.ChildNodes;
_assList.Clear();
BxAssembly temp;
int index = 0;
foreach (IBxStorageNode one in childs)
{
temp = new BxAssembly(null, index);
index++;
_assList.Add(temp);
temp.Load(one);
}
}
public virtual void LoadStorageNode(IBxStorageNode node)
{
IBxStorageNode cfgNode = node.GetChildNode(BxStorageLable.nodeConfig);
if (cfgNode != null)
{
GetUIConfigItemEx().LoadStorageNode(cfgNode);
IBxStorageNode valueNode = node.GetChildNode(BxStorageLable.nodeValue);
LoadElement(valueNode);
}
else
{
LoadElement(node);
}
}
public override void SaveStorageNode(IBxStorageNode node)
{
IEnumerable <IBxElementSite> elements = ChildSites;
int index = 0;
string sNodeName;
foreach (IBxElementSite one in elements)
{
if (one is IBxPersistStorageNode)
{
sNodeName = BxStorageLable.nodeArrayElement + index.ToString();
(one as IBxPersistStorageNode).SaveStorageNode(node.CreateChildNode(sNodeName));
index++;
}
}
node.SetElement(BxStorageLable.elementCount, index.ToString());
}
