/// <summary>Export the map to PDF</summary> /// <param name="folder">The working directory name</param> /// <returns>The filename string</returns> public string ExportToPNG(string folder) { string path = Apsim.FullPath(this.map).Replace(".Simulations.", string.Empty); string fileName = Path.Combine(folder, path + ".png"); Image rawImage = this.view.Export(); rawImage.Save(fileName, System.Drawing.Imaging.ImageFormat.Png); return(fileName); }
/// <summary>Performs the command.</summary> /// <param name="commandHistory">The command history.</param> public void Do(CommandHistory commandHistory) { string originalPath = Apsim.FullPath(this.modelToRename); // Get original value of property so that we can restore it in Undo if needed. originalName = this.modelToRename.Name; // Set the new name. Structure.Rename(modelToRename, newName); explorerView.Tree.Rename(originalPath, this.modelToRename.Name); }
/// <summary>Export the map to PDF</summary> /// <param name="workingDirectory"></param> /// <returns></returns> internal string ExportToPDF(string folder) { string path = Apsim.FullPath(map).Replace(".Simulations.", ""); string fileName = Path.Combine(folder, path + ".png"); Image rawImage = view.Export(); rawImage.Save(fileName, System.Drawing.Imaging.ImageFormat.Png); return(fileName); }
/// <summary> /// Perform the command /// </summary> public void Do(CommandHistory CommandHistory) { Simulation clonedSimulation = null; IEvent events = null; try { clonedSimulation = Apsim.Clone(simulation) as Simulation; explorerPresenter.ApsimXFile.MakeSubstitutions(clonedSimulation); events = explorerPresenter.ApsimXFile.GetEventService(clonedSimulation); events.ConnectEvents(); explorerPresenter.ApsimXFile.Links.Resolve(clonedSimulation); List <ModelDoc> models = new List <ModelDoc>(); foreach (IModel model in Apsim.ChildrenRecursively(clonedSimulation)) { ModelDoc newModelDoc = DocumentModel(model); newModelDoc.Name = Apsim.FullPath(model); models.Add(newModelDoc); } StringWriter rawXML = new StringWriter(); XmlSerializer serialiser = new XmlSerializer(typeof(List <ModelDoc>)); serialiser.Serialize(rawXML, models); rawXML.Close(); // Load the XSL transform from the resource Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream("UserInterface.Resources.DebugDoc.xsl"); var transform = new XslCompiledTransform(); using (XmlReader reader = XmlReader.Create(s)) { transform.Load(reader); } // Apply the transform to the reader and write it to a temporary file. string htmlFileName = Path.GetTempFileName() + ".html"; using (XmlReader reader = XmlReader.Create(new StringReader(rawXML.ToString()))) using (XmlWriter htmlWriter = XmlWriter.Create(htmlFileName)) { transform.Transform(reader, htmlWriter); } Process.Start(htmlFileName); } finally { if (clonedSimulation != null) { events.DisconnectEvents(); explorerPresenter.ApsimXFile.Links.Unresolve(clonedSimulation); } } }
/// <summary> /// Write a warning message to the summary /// </summary> /// <param name="model">The model writing the message</param> /// <param name="message">The warning message to write</param> public void WriteWarning(IModel model, string message) { if (this.messagesTable != null) { DataRow newRow = this.messagesTable.NewRow(); newRow["ComponentName"] = Apsim.FullPath(model); newRow["Date"] = this.clock.Today; newRow["Message"] = message; newRow["MessageType"] = Convert.ToInt32(DataStore.ErrorLevel.Warning); this.messagesTable.Rows.Add(newRow); } }
/// <summary>Write a message to the summary</summary> /// <param name="model">The model writing the message</param> /// <param name="message">The message to write</param> public void WriteMessage(IModel model, string message) { if (storage == null) { throw new ApsimXException(model, "No datastore is available!"); } string modelPath = Apsim.FullPath(model); string relativeModelPath = modelPath.Replace(Apsim.FullPath(simulation) + ".", string.Empty); object[] values = new object[] { relativeModelPath, clock.Today, message, Convert.ToInt32(Simulation.ErrorLevel.Information) }; storage.WriteRow(simulation.Name, "_Messages", summaryTableColumnNames, null, values); }
/// <summary>Perform the command</summary> /// <param name="commandHistory">The command history.</param> public void Do(CommandHistory commandHistory) { this.modelToAdd = Apsim.Add(parent, child); // The add method above may have renamed the model to avoid a clash with the // name of an existing model so just in case, reset the name for the tree. nodeDescription.Name = this.modelToAdd.Name; this.explorerView.Tree.AddChild(Apsim.FullPath(parent), nodeDescription); this.modelAdded = true; }
/// <summary>Performs the command.</summary> /// <param name="CommandHistory">The command history.</param> public void Do(CommandHistory CommandHistory) { string originalPath = Apsim.FullPath(modelToRename); // Get original value of property so that we can restore it in Undo if needed. originalName = modelToRename.Name; // Set the new name. this.modelToRename.Name = newName; Apsim.EnsureNameIsUnique(this.modelToRename); explorerView.Rename(originalPath, this.modelToRename.Name); }
/// <summary> /// Write a message to the summary /// </summary> /// <param name="model">The model writing the message</param> /// <param name="message">The message to write</param> public void WriteMessage(IModel model, string message) { string modelFullPath = Apsim.FullPath(model); string relativeModelPath = modelFullPath.Replace(Apsim.FullPath(Simulation) + ".", string.Empty); DataRow newRow = this.messagesTable.NewRow(); newRow["ComponentName"] = relativeModelPath; newRow["Date"] = this.clock.Today; newRow["Message"] = message; newRow["MessageType"] = Convert.ToInt32(DataStore.ErrorLevel.Information); this.messagesTable.Rows.Add(newRow); }
/// <summary>Undo the command.</summary> public void Undo(CommandHistory CommandHistory) { if (modelMoved) { presenter.Move(Apsim.FullPath(this.fromModel), fromParent, nodeDescription); Structure.Move(fromModel, fromParent); fromModel.Name = originalName; nodeDescription.Name = originalName; CommandHistory.InvokeModelStructureChanged(fromParent); CommandHistory.InvokeModelStructureChanged(toParent); } }
/// <summary> /// Create an initial conditions table in the DataStore. /// </summary> private void CreateInitialConditionsTable() { string simulationPath = Apsim.FullPath(simulation); object[] values = new object[] { simulationPath, "Simulation name", "Simulation name", "String", string.Empty, string.Empty, 0, simulation.Name }; storage.WriteRow(simulation.Name, "_InitialConditions", initialConditionsColumnNames, null, values); values = new object[] { simulationPath, "APSIM version", "APSIM version", "String", string.Empty, string.Empty, 0, simulation.ApsimVersion }; storage.WriteRow(simulation.Name, "_InitialConditions", initialConditionsColumnNames, null, values); values = new object[] { simulationPath, "Run on", "Run on", "String", string.Empty, string.Empty, 0, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") }; storage.WriteRow(simulation.Name, "_InitialConditions", initialConditionsColumnNames, null, values); // Get all model properties and store in 'initialConditionsTable' foreach (Model model in Apsim.FindAll(simulation)) { string thisRelativeModelPath = Apsim.FullPath(model).Replace(simulationPath + ".", string.Empty); List <VariableProperty> properties = new List <VariableProperty>(); FindAllProperties(model, properties); foreach (VariableProperty property in properties) { string propertyValue = property.ValueAsString(); if (propertyValue != string.Empty) { if (propertyValue != null && property.DataType == typeof(DateTime)) { propertyValue = ((DateTime)property.Value).ToString("yyyy-MM-dd HH:mm:ss"); } int total; if (double.IsNaN(property.Total)) { total = 0; } else { total = 1; } if (property.Units == null) { property.Units = string.Empty; } values = new object[] { thisRelativeModelPath, property.Name, property.Description, property.DataType.Name, property.Units, property.Format, total, propertyValue }; storage.WriteRow(simulation.Name, "_InitialConditions", initialConditionsColumnNames, null, values); } } } }
/// <summary> /// Main export code. /// </summary> //public void DoExportSimulation(Model modelToExport, string folderPath) //{ // //Load CSS resource // // Make sure the specified folderPath exists because we're going to // // write to it. // Directory.CreateDirectory(folderPath); // //Load CSS resource // Assembly assembly = Assembly.GetExecutingAssembly(); // StreamReader reader = new StreamReader(assembly.GetManifestResourceStream("UserInterface.Resources.Export.css")); // string css = reader.ReadToEnd(); // // Create index.html // StreamWriter index = new StreamWriter(Path.Combine(folderPath, "Index.html")); // index.WriteLine("<!DOCTYPE html><html lang=\"en-AU\"><head><style type=text/css>" + css + "</style></head>"); // index.WriteLine("<body>"); // DoExportZone(modelToExport, folderPath, index); // index.WriteLine("</body>"); // index.WriteLine("</html>"); // index.Close(); //} /// <summary> /// Export the specified zone. /// </summary> /// <param name="modelToExport"></param> /// <param name="folderPath"></param> /// <param name="index"></param> private void DoExportModel(Model modelToExport, string folderPath, StreamWriter index) { // Select the node in the tree. ExplorerPresenter.SelectNode(Apsim.FullPath(modelToExport)); // If the presenter is exportable then simply export this child. // Otherwise, if it is one of a folder, simulation, experiment or zone then // recurse down. if (ExplorerPresenter.CurrentPresenter is IExportable) { string html = (ExplorerPresenter.CurrentPresenter as IExportable).ConvertToHtml(folderPath); index.WriteLine("<p>" + html + "</p>"); } }
/// <summary>Export the contents of this graph to the specified file.</summary> /// <param name="folder">The folder.</param> /// <returns></returns> public string ExportToPDF(string folder) { // The rectange numbers below are optimised for generation of PDF document // on a computer that has its display settings at 100%. Rectangle r = new Rectangle(0, 0, 600, 450); Bitmap img = new Bitmap(r.Width, r.Height); graphView.Export(img, true); string path = Apsim.FullPath(graph).Replace(".Simulations.", ""); string fileName = Path.Combine(folder, path + ".png"); img.Save(fileName, System.Drawing.Imaging.ImageFormat.Png); return(fileName); }
/// <summary> /// Undo the command /// </summary> public void Undo(CommandHistory CommandHistory) { if (ModelMoved) { ToParent.Children.Remove(FromModel); this.explorerView.Tree.Delete(Apsim.FullPath(this.FromModel)); FromModel.Name = OriginalName; nodeDescription.Name = OriginalName; FromParent.Children.Add(FromModel); FromModel.Parent = FromParent; this.explorerView.Tree.AddChild(Apsim.FullPath(FromParent), nodeDescription); CommandHistory.InvokeModelStructureChanged(FromParent); CommandHistory.InvokeModelStructureChanged(ToParent); } }
/// <summary> /// Fill the specified table with columns and rows based on this.Properties /// </summary> /// <param name="table">The table that needs to be filled</param> public void FillTable(DataTable table) { foreach (IVariable property in properties) { if (property is VariableObject) { table.Rows.Add(new object[] { property.Value, null }); } else if (property.Value is IModel) { table.Rows.Add(new object[] { property.Description, Apsim.FullPath(property.Value as IModel) }); } else { table.Rows.Add(new object[] { property.Description, property.ValueWithArrayHandling }); } } }
/// <summary>The user has clicked the add button.</summary> /// <param name="sender">Event sender</param> /// <param name="e">Event arguments</param> private void OnAddButtonClicked(object sender, EventArgs e) { Type selectedModelType = this.allowableChildModels.Find(m => m.FullName == this.view.List.SelectedValue); if (selectedModelType != null) { this.explorerPresenter.MainPresenter.ShowWaitCursor(true); try { IModel child = (IModel)Activator.CreateInstance(selectedModelType, true); explorerPresenter.Add(child, Apsim.FullPath(this.model)); } finally { this.explorerPresenter.MainPresenter.ShowWaitCursor(false); } } }
/// <summary> /// Create and return a new Link object for member /// </summary> /// <param name="field">The member</param> /// <param name="model">Model with the link</param> private static ModelDoc.Link DocumentLink(FieldInfo field, IModel model) { ModelDoc.Link link = new ModelDoc.Link(); link.Name = field.Name; if (field.FieldType.IsGenericType && field.FieldType.GetInterface("IList") != null) { link.TypeName = "List<" + field.FieldType.GenericTypeArguments[0].Name + ">"; } else { link.TypeName = field.FieldType.Name; } UnitsAttribute units = field.GetCustomAttribute <UnitsAttribute>(); if (units != null) { link.Units = units.ToString(); } DescriptionAttribute description = field.GetCustomAttribute <DescriptionAttribute>(); if (description != null) { link.Description = description.ToString(); } LinkAttribute linkAtt = field.GetCustomAttribute <LinkAttribute>(); link.IsOptional = linkAtt.IsOptional; object linkedObject = field.GetValue(model); if (linkedObject != null) { if (linkedObject is IModel) { link.LinkedModelName = Apsim.FullPath(linkedObject as IModel); } else { } } return(link); }
/// <summary> /// Select the next node in the view. The next node is defined as the next one /// down in the tree view. It will go through child nodes if they exist. /// Will return true if next node was successfully selected. Will return /// false if no more nodes to select. /// </summary> /// <returns>True when node is selected</returns> /// <exception cref="System.Exception">Cannot find the current selected model in the .apsimx file</exception> public bool SelectNextNode() { this.HideRightHandPanel(); // Get a complete list of all models in this file. List <IModel> allModels = Apsim.ChildrenRecursivelyVisible(this.ApsimXFile); allModels.Insert(0, ApsimXFile); /* If the current node path is '.Simulations' (the root node) then * select the first item in the 'allModels' list. */ if (this.view.Tree.SelectedNode == string.Empty) { this.view.Tree.SelectedNode = Apsim.FullPath(allModels[0]); return(true); } // Find the current node in this list. int index = -1; for (int i = 0; i < allModels.Count; i++) { if (Apsim.FullPath(allModels[i]) == this.view.Tree.SelectedNode) { index = i; break; } } if (index == -1) { throw new Exception("Cannot find the current selected model in the .apsimx file"); } // If the current model is the last one in the list then return false. if (index >= allModels.Count - 1) { return(false); } // Select the next node. this.view.Tree.SelectedNode = Apsim.FullPath(allModels[index + 1]); return(true); }
/// <summary>The user has clicked the add button.</summary> /// <param name="sender">Event sender</param> /// <param name="e">Event arguments</param> private void OnAddButtonClicked(object sender, EventArgs e) { Type selectedModelType = this.allowableChildFunctions.Find(m => m.FullName == this.view.List.SelectedValue); if (selectedModelType != null) { this.explorerPresenter.MainPresenter.ShowWaitCursor(true); try { object child = Activator.CreateInstance(selectedModelType, true); string childString = FileFormat.WriteToString(child as IModel); this.explorerPresenter.Add(childString, Apsim.FullPath(this.model)); } finally { this.explorerPresenter.MainPresenter.ShowWaitCursor(false); } } }
/// <summary> /// Adds a property to the DataTable of properties. /// </summary> /// <param name="table"></param> /// <param name="property"></param> protected virtual void AddPropertyToTable(DataTable table, IVariable property) { if (property is VariableObject) { table.Rows.Add(new object[] { property.Value, null, null }); } else if (property.Value is IModel) { table.Rows.Add(new object[] { property.Description, Apsim.FullPath(property.Value as IModel), property.Name }); } else if (property is VariableProperty p) { table.Rows.Add(new object[] { property.Description, property.ValueWithArrayHandling, p.Tooltip }); } else { table.Rows.Add(new object[] { property.Description, property.ValueWithArrayHandling, property.Description }); } }
/// <summary>The user has clicked the add button.</summary> /// <param name="sender">Event sender</param> /// <param name="e">Event arguments</param> private void OnAddButtonClicked(object sender, EventArgs e) { try { Apsim.ModelDescription selectedModelType = GetModelDescription(tree.SelectedNode); if (selectedModelType != null) { this.explorerPresenter.MainPresenter.ShowWaitCursor(true); IModel child; if (!(selectedModelType.ModelType == typeof(ModelCollectionFromResource)) && selectedModelType.ResourceString != null && selectedModelType.ResourceString.Contains('.')) { List <Exception> exceptions; var contents = ReflectionUtilities.GetResourceAsString(explorerPresenter.ApsimXFile.GetType().Assembly, selectedModelType.ResourceString); child = FileFormat.ReadFromString <Model>(contents, out exceptions); if (child.Children.Count == 1) { child = child.Children[0]; } } else { child = (IModel)Activator.CreateInstance(selectedModelType.ModelType, true); child.Name = selectedModelType.ModelName; if (child is ModelCollectionFromResource resource) { resource.ResourceName = selectedModelType.ResourceString; } } var command = new AddModelCommand(Apsim.FullPath(this.model), child, explorerPresenter); explorerPresenter.CommandHistory.Add(command, true); } } finally { this.explorerPresenter.MainPresenter.ShowWaitCursor(false); } }
/// <summary>The user has clicked the add button.</summary> /// <param name="sender">Event sender</param> /// <param name="e">Event arguments</param> private void OnAddButtonClicked(object sender, EventArgs e) { Type modelType = typeof(IModel).Assembly.GetType(tree.SelectedNode); if (modelType != null) { this.explorerPresenter.MainPresenter.ShowWaitCursor(true); try { IModel child = (IModel)Activator.CreateInstance(modelType, true); child.Name = modelType.Name; explorerPresenter.Add(child, Apsim.FullPath(this.model)); } finally { this.explorerPresenter.MainPresenter.ShowWaitCursor(false); } } }
public void OnFindReferences(object sender, EventArgs e) { try { IModel model = Apsim.Get(this.explorerPresenter.ApsimXFile, this.explorerPresenter.CurrentNodePath) as IModel; if (model != null) { string modelPath = Apsim.FullPath(model); StringBuilder message = new StringBuilder($"Searching for references to model {Apsim.FullPath(model)}..."); List <Reference> references = new List <Reference>(); message.AppendLine(); message.AppendLine(); Stopwatch timer = Stopwatch.StartNew(); foreach (VariableReference reference in Apsim.FindAll(model, typeof(VariableReference))) { try { if (Apsim.Get(reference, reference.VariableName.Replace(".Value()", "")) == model) { references.Add(new Reference() { Member = typeof(VariableReference).GetProperty("VariableName"), Model = reference, Target = model }); } } catch { } } timer.Stop(); message.AppendLine(); message.AppendLine($"Finished. Elapsed time: {timer.Elapsed.TotalSeconds.ToString("#.00")} seconds"); explorerPresenter.MainPresenter.ShowMessage(message.ToString(), Simulation.MessageType.Information); var dialog = new Utility.FindAllReferencesDialog(model, references, explorerPresenter); } } catch (Exception err) { explorerPresenter.MainPresenter.ShowError(err); } }
/// <summary> /// Adds a property to the DataTable of properties. /// </summary> /// <param name="table"></param> /// <param name="property"></param> protected virtual void AddPropertyToTable(DataTable table, IVariable property) { if (property is VariableObject) { table.Rows.Add(new object[] { property.Value, null }); } else if (property.Value is IModel) { table.Rows.Add(new object[] { property.Description, Apsim.FullPath(property.Value as IModel) }); } else { string description = property.Description; if (!string.IsNullOrEmpty(property.Units)) { description += " (" + property.Units + ")"; } table.Rows.Add(new object[] { description, property.ValueWithArrayHandling }); } }
/// <summary>Perform the command</summary> /// <param name="commandHistory">The command history.</param> public void Do(CommandHistory commandHistory) { try { parent = Apsim.Get(presenter.ApsimXFile, parentPath) as IModel; if (parent == null) { throw new Exception("Cannot find model " + parentPath); } modelToAdd = Structure.Add(childString, parent); var nodeDescription = presenter.GetNodeDescription(modelToAdd); view.Tree.AddChild(Apsim.FullPath(parent), nodeDescription); modelAdded = true; } catch (Exception err) { presenter.MainPresenter.ShowError(err); modelAdded = false; } }
private string[] GetModelNames(Type t) { List <IModel> models; if (t == null) { models = Apsim.FindAll(model); } else { models = Apsim.FindAll(model, t); } List <string> modelNames = new List <string>(); foreach (IModel model in models) { modelNames.Add(Apsim.FullPath(model)); } return(modelNames.ToArray()); }
/// <summary> /// Adds a property to the DataTable of properties. /// </summary> /// <param name="table"></param> /// <param name="property"></param> protected virtual void AddPropertyToTable(DataTable table, IVariable property) { int row = properties.IndexOf(property); if (property is VariableObject) { table.Rows.Add(new object[] { property.Value, null, null }); } else if (property.Value is IModel) { table.Rows.Add(new object[] { property.Description, Apsim.FullPath(property.Value as IModel), property.Name }); } else if (property is VariableProperty p) { table.Rows.Add(new object[] { property.Description, GetCellValue(property, row, 1), p.Tooltip }); } else { table.Rows.Add(new object[] { property.Description, GetCellValue(property, row, 1), property.Description }); } }
/// <summary>Undo the command</summary> /// <param name="CommandHistory">The command history.</param> public void Undo(CommandHistory CommandHistory) { if (modelWasReplaced) { Model parent = modelToInsert.Parent as Model; int modelIndex = parent.Children.IndexOf(modelToInsert as Model); try { this.explorerView.Tree.Delete(Apsim.FullPath(this.modelToInsert)); parent.Children.Remove(modelToInsert as Model); parent.Children.Insert(modelIndex, modelToReplace as Model); modelToReplace.Parent = parent; var nodeDescription = presenter.GetNodeDescription(modelToReplace); this.explorerView.Tree.AddChild(Apsim.FullPath(parent), nodeDescription, modelIndex); } catch (Exception err) { presenter.MainPresenter.ShowError(err); modelWasReplaced = false; } } }
/// <summary>Apply fertiliser.</summary> /// <param name="Amount">The amount.</param> /// <param name="Type">The type.</param> /// <param name="Depth">The depth.</param> /// <exception cref="ApsimXException">Cannot find fertiliser type ' + Type + '</exception> public void Apply(double Amount, Types Type, double Depth = 0.0) { if (Amount > 0 && NitrogenChanged != null) { // find the layer that the fertilizer is to be added to. int layer = GetLayerDepth(Depth, Soil.Thickness); FertiliserType fertiliserType = Definitions.FirstOrDefault(f => f.Name == Type.ToString()); if (fertiliserType == null) { throw new ApsimXException(this, "Cannot find fertiliser type '" + Type + "'"); } NitrogenChangedType NitrogenChanges = new NitrogenChangedType(); NitrogenChanges.Sender = Apsim.FullPath(this); if (fertiliserType.FractionNO3 != 0) { NitrogenChanges.DeltaNO3 = new double[Soil.Thickness.Length]; NitrogenChanges.DeltaNO3[layer] = Amount * fertiliserType.FractionNO3; NitrogenApplied += Amount * fertiliserType.FractionNO3; } if (fertiliserType.FractionNH4 != 0) { NitrogenChanges.DeltaNH4 = new double[Soil.Thickness.Length]; NitrogenChanges.DeltaNH4[layer] = Amount * fertiliserType.FractionNH4; NitrogenApplied += Amount * fertiliserType.FractionNH4; } if (fertiliserType.FractionUrea != 0) { NitrogenChanges.DeltaUrea = new double[Soil.Thickness.Length]; NitrogenChanges.DeltaUrea[layer] = Amount * fertiliserType.FractionUrea; NitrogenApplied += Amount * fertiliserType.FractionUrea; } NitrogenChanged.Invoke(NitrogenChanges); Summary.WriteMessage(this, string.Format("{0} kg/ha of {1} added at depth {2} layer {3}", Amount, Type, Depth, layer + 1)); } }
/// <summary> /// Attach the view to the model. /// </summary> /// <param name="model">The initial water model</param> /// <param name="view">The initial water view</param> /// <param name="explorerPresenter">The parent explorer presenter</param> public override void Attach(object model, object view, ExplorerPresenter explorerPresenter) { this.xYPairs = model as XYPairs; this.xYPairsView = view as XYPairsView; this.presenter = explorerPresenter as ExplorerPresenter; base.Attach(model, xYPairsView.VariablesGrid, explorerPresenter); // Create a list of profile (array) properties. PpoulateView wil create a table from them and // hand the table to the variables grid. this.FindAllProperties(this.xYPairs); this.PopulateView(); this.presenter.CommandHistory.ModelChanged += OnModelChanged; // Populate the graph. this.graph = Utility.Graph.CreateGraphFromResource(model.GetType().Name + "Graph"); this.xYPairs.Children.Add(this.graph); this.graph.Parent = this.xYPairs; (this.graph.Series[0] as Series).XFieldName = Apsim.FullPath(graph.Parent) + ".X"; (this.graph.Series[0] as Series).YFieldName = Apsim.FullPath(graph.Parent) + ".Y"; this.graphPresenter = new GraphPresenter(); this.presenter.ApsimXFile.Links.Resolve(graphPresenter); this.graphPresenter.Attach(this.graph, this.xYPairsView.Graph, this.presenter); string xAxisTitle = LookForXAxisTitle(); if (xAxisTitle != null) { xYPairsView.Graph.FormatAxis(Axis.AxisType.Bottom, xAxisTitle, false, double.NaN, double.NaN, double.NaN, false); } string yAxisTitle = LookForYAxisTitle(); if (yAxisTitle != null) { xYPairsView.Graph.FormatAxis(Axis.AxisType.Left, yAxisTitle, false, double.NaN, double.NaN, double.NaN, false); } xYPairsView.Graph.FormatTitle(xYPairs.Parent.Name); }