/// <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); } }