/// <summary>
/// Create pathway canvas.
/// </summary>
/// <param name="model">the EcellModel.</param>
private void CreateCanvas(EcellModel model)
{
// Create canvas
Canvas = new CanvasControl(this, model.ModelID);
m_layerView.ResetLayers(model.Layers);
m_menu.ResetEventHandler();
m_menu.Zoom(1f);
RaiseCanvasChange();
}
public void TestGetImageIndex_EcellObject()
{
EcellObject obj = null;
int expectedInt32 = -1;
int resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj = new EcellProject("", "", "", "", new List<EcellData>());
expectedInt32 = 0;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj = new EcellModel("", "", "", "", new List<EcellData>());
expectedInt32 = 1;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj = new EcellSystem("", "", "", "", new List<EcellData>());
expectedInt32 = 2;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj = new EcellProcess("", "", "", "", new List<EcellData>());
expectedInt32 = 3;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj = new EcellVariable("", "", "", "", new List<EcellData>());
expectedInt32 = 4;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj = new EcellText("", "/:Text", "", "", new List<EcellData>());
expectedInt32 = 10;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj = new EcellStepper("", "", "", "", new List<EcellData>());
expectedInt32 = 11;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
obj.Layout.Figure = "System";
expectedInt32 = 2;
resultInt32 = 0;
resultInt32 = _unitUnderTest.GetImageIndex(obj);
Assert.AreEqual(expectedInt32, resultInt32, "GetImageIndex method returned unexpected result.");
}
/// <summary>
/// Initialize the model
/// </summary>
/// <param name="modelObject">the model object.</param>
/// <param name="simulator">the loaded simulator.</param>
public static void InitializeModel(EcellModel modelObject, WrappedSimulator simulator)
{
bool isWarn = false;
string errMsg = MessageResources.WarnLoadDM + "\n";
Dictionary<string, object> processPropertyDic = new Dictionary<string, object>();
// Initialize object
foreach (EcellObject obj in modelObject.Children)
{
// Initialize Stepper
if (obj is EcellStepper)
{
try
{
simulator.CreateStepper(obj.Classname, obj.Key);
}
catch (Exception e)
{
errMsg += obj.FullID + ":" + e.Message + "\n";
Trace.WriteLine(e.ToString());
isWarn = true;
}
foreach (EcellData data in obj.Value)
{
simulator.LoadStepperProperty(
obj.Key,
data.Name,
data.Value.Value);
}
}
else if (obj is EcellSystem)
{
// Initialize System
if (!obj.Key.Equals(Constants.delimiterPath))
{
try
{
simulator.CreateEntity(
obj.Classname,
obj.FullID);
}
catch (Exception e)
{
throw new EmlParseException("Failed to create a System entity", e);
}
}
foreach (EcellData data in obj.Value)
{
simulator.LoadEntityProperty(
data.EntityPath,
data.Value.Value);
}
// Initialize Entity
foreach (EcellObject entity in obj.Children)
{
if (entity.Type.Equals(EcellObject.TEXT))
continue;
bool isCreated = true;
// 4 "EcellCoreLib"
try
{
simulator.CreateEntity(
entity.Classname,
entity.FullID);
}
catch (Exception e)
{
errMsg += entity.FullID + ":" + e.Message + "\n";
Trace.WriteLine(e.ToString());
isCreated = false;
isWarn = true;
}
foreach (EcellData data in entity.Value)
{
string entityPath = data.EntityPath;
if (obj.Type.Equals(Constants.xpathVariable))
{
if (isCreated == true)
simulator.LoadEntityProperty(entityPath, data.Value.Value);
}
else
{
processPropertyDic[entityPath] = data.Value.Value;
}
}
}
}
}
//
List<string> removeList = new List<string>();
foreach (KeyValuePair<string, object> pair in processPropertyDic)
{
try
{
simulator.LoadEntityProperty(pair.Key, pair.Value);
}
catch (WrappedException e)
{
isWarn = true;
errMsg += pair.Key + ":" + e.Message + "\n";
}
if (pair.Key.EndsWith(Constants.xpathVRL))
removeList.Add(pair.Key);
}
foreach (string entityPath in removeList)
{
processPropertyDic.Remove(entityPath);
}
if (isWarn)
{
modelObject.ErrMsg = errMsg;
}
}
private static void CheckAndConvertProcesses(EcellModel anEml)
{
foreach (EcellObject sys in anEml.Children)
{
if (!(sys is EcellSystem))
continue;
foreach (EcellObject child in sys.Children)
{
if (!(child is EcellProcess))
continue;
EcellProcess process = (EcellProcess)child;
ProcessConverter.ConvertToExpression(process);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="anEml"></param>
/// <param name="aBaseName"></param>
/// <param name="aLevel"></param>
/// <param name="aVersion"></param>
public static SBMLDocument convertToSBMLModel(EcellModel anEml, string aBaseName, int aLevel, int aVersion)
{
// Check and convert Processes.
CheckAndConvertProcesses(anEml);
SBMLDocument aSBMLDocument = new SBMLDocument();
aSBMLDocument.setLevelAndVersion((long)aLevel, (long)aVersion);
Model aSBMLModel = aSBMLDocument.createModel(aBaseName);
createModel( anEml, aSBMLModel );
// set abogadro number and EmptySet to SBML model
setEssentialEntity(aSBMLModel);
//return libsbml.libsbml.writeSBMLToString( aSBMLDocument );
return aSBMLDocument;
}
/// <summary>
/// Returns the new "EcellObject" instance with initialized arguments.
/// </summary>
/// <param name="modelID">The model ID</param>
/// <param name="key">The key</param>
/// <param name="type">The type</param>
/// <param name="classname">The class</param>
/// <param name="data">The data</param>
/// <returns>The new "EcellObject" instance</returns>
public static EcellObject CreateObject(string modelID, string key,
string type, string classname, List<EcellData> data)
{
//if (string.IsNullOrEmpty(modelID))
// throw new EcellException(string.Format(MessageResources.ErrInvalidParam, MODEL));
if (Util.IsNGforType(type))
throw new EcellException(string.Format(MessageResources.ErrInvalidParam, TYPE));
EcellObject obj = null;
if (type.Equals(MODEL))
obj = new EcellModel(modelID, key, type, classname, data);
else if (type.Equals(PROCESS))
obj = new EcellProcess(modelID, key, type, classname, data);
else if (type.Equals(VARIABLE))
obj = new EcellVariable(modelID, key, type, classname, data);
else if (type.Equals(SYSTEM))
obj = new EcellSystem(modelID, key, type, classname, data);
else if (type.Equals(TEXT))
obj = new EcellText(modelID, key, type, classname, data);
else if (type.Equals(STEPPER))
obj = new EcellStepper(modelID, key, type, classname, data);
else if (type.Equals(PROJECT))
obj = new EcellProject(modelID, key, type, classname, data);
return obj;
}
/// <summary>
///
/// </summary>
/// <param name="anEml"></param>
/// <param name="filename"></param>
public static void SaveSBML(EcellModel anEml, string filename)
{
SBMLDocument aSBMLDocument = convertToSBMLModel(anEml, anEml.ModelID, 2, 3);
string sbml = libsbml.libsbml.writeSBMLToString(aSBMLDocument);
File.WriteAllText(filename, sbml);
}
/// <summary>
/// Set the Layers to XML node.
/// </summary>
/// <param name="model">the model object.</param>
/// <param name="layers">Layer XML node.</param>
private static void SetLayers(EcellModel model, XmlNode layers)
{
if (layers == null || layers.ChildNodes.Count <= 0)
return;
List<EcellLayer> elList = new List<EcellLayer>();
foreach (XmlNode node in layers.ChildNodes)
{
if (!LemlConstants.xPathLayer.Equals(node.Name))
continue;
string name = GetStringAttribute(node, LemlConstants.xPathName);
string visible = GetStringAttribute(node, LemlConstants.xPathVisible);
elList.Add(new EcellLayer(name, bool.Parse(visible)));
}
model.Layers = elList;
}
/// <summary>
/// Set the logger to XML node.
/// </summary>
/// <param name="env">ApplicationEnvironment</param>
/// <param name="model">the model object.</param>
/// <param name="loggers">Logger XML node.</param>
private static void SetLogger(ApplicationEnvironment env, EcellModel model, XmlNode loggers)
{
if (loggers == null || loggers.ChildNodes.Count <= 0)
return;
foreach (XmlNode node in loggers.ChildNodes)
{
if (!node.Name.Equals(LemlConstants.xPathLogger))
continue;
string modelID = GetStringAttribute(node, LemlConstants.xPathModelID);
string key = GetStringAttribute(node, LemlConstants.xPathKey);
string type = GetStringAttribute(node, LemlConstants.xPathType);
EcellObject eo = GetEcellObject(model, type, key);
if (eo == null)
continue;
string fullPN = GetStringAttribute(node, LemlConstants.xpathFullPN);
LoggerEntry entry = new LoggerEntry(modelID, key, type, fullPN);
entry.Color = Color.FromName(GetStringAttribute(node, LemlConstants.xpathColor));
entry.LineStyleInt = Int32.Parse(GetStringAttribute(node, LemlConstants.xpathLineStyle));
entry.LineWidth = Int32.Parse(GetStringAttribute(node, LemlConstants.xpathLineWidth));
entry.IsShowInt = Int32.Parse(GetStringAttribute(node, LemlConstants.xpathIsShown));
entry.IsY2AxisInt = Int32.Parse(GetStringAttribute(node, LemlConstants.xpathIsY2));
foreach (EcellData d in eo.Value)
{
if (!d.EntityPath.Equals(fullPN))
continue;
d.Logged = true;
env.LoggerManager.AddLoggerEntry(entry);
}
}
}
/// <summary>
/// Set EcellObjects.
/// </summary>
/// <param name="model">the model object.</param>
/// <param name="ecellObjects">object XML node.</param>
private static void SetEcellObjects(EcellModel model, XmlNode ecellObjects)
{
if (ecellObjects == null || ecellObjects.ChildNodes.Count <= 0)
return;
foreach (XmlNode node in ecellObjects.ChildNodes)
{
if (!node.Name.Equals(LemlConstants.xPathEcellObject))
continue;
string modelID = GetStringAttribute(node, LemlConstants.xPathModelID);
string key = GetStringAttribute(node, LemlConstants.xPathKey);
string type = GetStringAttribute(node, LemlConstants.xPathType);
EcellObject eo = GetEcellObject(model, type, key);
if(eo == null)
continue;
eo.Classname = GetStringAttribute(node, LemlConstants.xPathClass);
eo.X = GetFloatAttribute(node, LemlConstants.xPathX);
eo.Y = GetFloatAttribute(node, LemlConstants.xPathY);
eo.OffsetX = GetFloatAttribute(node, LemlConstants.xPathOffsetX);
eo.OffsetY = GetFloatAttribute(node, LemlConstants.xPathOffsetY);
eo.Width = GetFloatAttribute(node, LemlConstants.xPathWidth);
eo.Height = GetFloatAttribute(node, LemlConstants.xPathHeight);
eo.Layer = GetStringAttribute(node, LemlConstants.xPathLayer);
eo.Layout.Figure = GetStringAttribute(node, LemlConstants.xPathFigure);
eo.IsLayouted = true;
}
}
/// <summary>
/// Set the alias to XML node.
/// </summary>
/// <param name="model">the model object.</param>
/// <param name="aliases">Alias XML node.</param>
private static void SetAliases(EcellModel model, XmlNode aliases)
{
if (aliases == null || aliases.ChildNodes.Count <= 0)
return;
foreach (XmlNode node in aliases.ChildNodes)
{
if (!node.Name.Equals(LemlConstants.xPathAlias))
continue;
string modelID = GetStringAttribute(node, LemlConstants.xPathModelID);
string key = GetStringAttribute(node, LemlConstants.xPathKey);
string x = GetStringAttribute(node, LemlConstants.xPathX);
string y = GetStringAttribute(node, LemlConstants.xPathY);
string layer = GetStringAttribute(node, LemlConstants.xPathLayer);
EcellVariable variable = (EcellVariable)GetEcellObject(model, EcellObject.VARIABLE, key);
if (variable == null)
continue;
EcellLayout alias = new EcellLayout();
alias.X = float.Parse(x);
alias.Y = float.Parse(y);
alias.Layer = layer;
variable.Aliases.Add(alias);
}
}
/// <summary>
/// GetEcellObject
/// </summary>
/// <param name="model">The model object.</param>
/// <param name="type">The type of object.</param>
/// <param name="key">The key of object.</param>
/// <returns>The object from XML node.</returns>
private static EcellObject GetEcellObject(EcellModel model, string type, string key)
{
EcellObject eo = null;
// Check entity
foreach (EcellObject sys in model.Children)
{
// Check
if (sys.Type.Equals(type) && sys.Key.Equals(key))
{
eo = sys;
break;
}
foreach (EcellObject child in sys.Children)
{
// Check
if (child.Type.Equals(type) && child.Key.Equals(key))
{
eo = child;
break;
}
}
}
return eo;
}
/// <summary>
/// Save EcellObjects in LEML format.
/// </summary>
/// <param name="env">ApplicationEnvironment</param>
/// <param name="model">The model object.</param>
/// <param name="filename">the file name.</param>
public static void SaveLEML(ApplicationEnvironment env, EcellModel model, string filename)
{
CheckFilePath(filename);
FileStream fs = null;
XmlTextWriter xmlOut = null;
try
{
// Create xml file
fs = new FileStream(filename, FileMode.Create);
xmlOut = new XmlTextWriter(fs, Encoding.UTF8);
// Use indenting for readability
xmlOut.Formatting = Formatting.Indented;
xmlOut.WriteStartDocument();
// Always begin file with identification and warning
xmlOut.WriteComment(LemlConstants.xPathFileHeader1);
xmlOut.WriteComment(LemlConstants.xPathFileHeader2);
// Application settings
xmlOut.WriteStartElement(LemlConstants.xPathApplication);
xmlOut.WriteAttributeString(LemlConstants.xPathName, Application.ProductName);
xmlOut.WriteAttributeString(LemlConstants.xPathApplicationVersion, Application.ProductVersion);
xmlOut.WriteAttributeString(LemlConstants.xPathConfigFileVersion, CONFIG_FILE_VERSION);
// Layer settings
xmlOut.WriteStartElement(LemlConstants.xPathLayerList);
foreach (EcellLayer layer in model.Layers)
{
xmlOut.WriteStartElement(LemlConstants.xPathLayer);
xmlOut.WriteAttributeString(LemlConstants.xPathName, layer.Name);
xmlOut.WriteAttributeString(LemlConstants.xPathVisible, layer.Visible.ToString());
xmlOut.WriteEndElement();
}
xmlOut.WriteEndElement();
// Alias
xmlOut.WriteStartElement(LemlConstants.xPathAliasList);
foreach (EcellObject eo in model.Children)
{
foreach (EcellObject child in eo.Children)
{
if (!(child is EcellVariable))
continue;
WriteAliases(xmlOut, child);
}
}
xmlOut.WriteEndElement();
// Object settings
xmlOut.WriteStartElement(LemlConstants.xPathEcellObjectList);
foreach (EcellObject stepper in model.Steppers)
{
WriteObjectElement(xmlOut, stepper);
}
foreach (EcellObject eo in model.Children)
{
WriteObjectElement(xmlOut, eo);
foreach (EcellObject child in eo.Children)
{
WriteObjectElement(xmlOut, child);
}
}
xmlOut.WriteEndElement();
// Logger
xmlOut.WriteStartElement(LemlConstants.xPathLoggerList);
foreach (string name in env.LoggerManager.GetLoggerList())
{
LoggerEntry entry = env.LoggerManager.GetLoggerEntryForFullPN(name);
WriteLoggerElement(xmlOut, entry);
}
xmlOut.WriteEndElement();
// Plugin settings.
xmlOut.WriteStartElement(LemlConstants.xPathPluginSettings);
foreach (XmlNode status in env.PluginManager.GetPluginStatus())
{
status.WriteTo(xmlOut);
}
xmlOut.WriteEndElement();
xmlOut.WriteEndElement();
xmlOut.WriteEndDocument();
}
catch (Exception ex)
{
Trace.WriteLine(ex);
Util.ShowErrorDialog(string.Format(MessageResources.ErrSaveFile, filename) + Environment.NewLine + ex.Message);
}
finally
{
if (xmlOut != null) xmlOut.Close();
if (fs != null) fs.Close();
}
}
/// <summary>
/// LoadLEML
/// </summary>
/// <param name="env">ApplicationEnvironment.</param>
/// <param name="model">the model ID.</param>
/// <param name="filename">the filename.</param>
public static void LoadLEML(ApplicationEnvironment env, EcellModel model,string filename)
{
if (!File.Exists(filename))
return;
XmlDocument xmlD = new XmlDocument();
try
{
xmlD.Load(filename);
XmlNode applicationData = GetNodeByKey(xmlD, LemlConstants.xPathApplication);
// Load Layers
XmlNode layers = GetNodeByKey(applicationData, LemlConstants.xPathLayerList);
SetLayers(model, layers);
// Load Aliases
XmlNode aliases = GetNodeByKey(applicationData, LemlConstants.xPathAliasList);
SetAliases(model, aliases);
// Load EcellObjects
XmlNode ecellObjects = GetNodeByKey(applicationData, LemlConstants.xPathEcellObjectList);
SetEcellObjects(model, ecellObjects);
// Load Logger
XmlNode loggers = GetNodeByKey(applicationData, LemlConstants.xPathLoggerList);
SetLogger(env, model, loggers);
// Load plugin settings
XmlNode settings = GetNodeByKey(applicationData, LemlConstants.xPathPluginSettings);
SetPluginSettings(env, settings);
}
catch (Exception ex)
{
Trace.WriteLine(ex);
Util.ShowErrorDialog(string.Format(MessageResources.ErrLoadFile, filename) + Environment.NewLine + ex.Message);
}
}
