/// <summary>
        /// Renders the contents of the project.
        ///
        /// Need to refactor to reduce redundant code use.
        ///
        /// </summary>
        /// <param name="HurricaneBasin">The canvas containing the basin</param>
        /// <param name="DotSize">The dot size setting. (NEEDS TO BE CHANGED)</param>
        /// <param name="StormList">The storm list to rend</param>
        public void RenderContent(Canvas HurricaneBasin, Point DotSize, List <Storm> StormList = null)
        {
            // optimise by clearing it every time (this is optimisation per v0.x standards LMAO)
            HurricaneBasin.Children.Clear();

            foreach (Layer XLayer in CurrentProject.SelectedBasin.BuildListOfZOrderedLayers())
            {
                // render loop
                foreach (Storm XStorm in XLayer.AssociatedStorms)
                {
                    if (StormList != null)
                    {
                        if (!StormList.Contains(XStorm))
                        {
                            continue;
                        }
                    }

                    Render_DrawLines(XStorm, DotSize, HurricaneBasin);

                    foreach (Node XNode in XStorm.NodeList)
                    {
                        if (XNode.NodeType.PresetShape != StormShape.Custom)
                        {
                            switch (XNode.NodeType.PresetShape)
                            {
                            // tropical systems
                            case StormShape.Circle:
                                Ellipse Ellipse = new Ellipse();

                                if (XNode.NodeType.ForceSize)
                                {
                                    DotSize = XNode.NodeType.ForcedSize;
                                }

                                Ellipse.Width  = DotSize.X;
                                Ellipse.Height = DotSize.Y;

                                // get the colour (Dano: refactor)
                                Ellipse.Fill = new SolidColorBrush(RenderBasedOnNodeIntensity(XStorm, XNode));

                                // Since there were many requests for an Invest/PTC storm type, here it is.
                                // need to fix redundant code - rc2 or iris

                                if (XNode.NodeType.ForceColour)
                                {
                                    // Invest / PTC uses [255,128,204,255] ARGB format
                                    Ellipse.Fill = new SolidColorBrush(XNode.NodeType.ForcedColour);
                                }
                                else
                                {
                                    Ellipse.Fill = new SolidColorBrush(RenderBasedOnNodeIntensity(XStorm, XNode));
                                }

                                RelativePositionConverter RPC = new RelativePositionConverter();
                                Point RP = (Point)RPC.ConvertBack(XNode.Position, typeof(Point), null, null);

                                Canvas.SetLeft(Ellipse, RP.X);
                                Canvas.SetTop(Ellipse, RP.Y);

                                HurricaneBasin.Children.Add(Ellipse);
                                continue;

                            case StormShape.Square:

                                Rectangle Rect = new Rectangle();

                                if (XNode.NodeType.ForceSize)
                                {
                                    DotSize = XNode.NodeType.ForcedSize;
                                }

                                Rect.Width  = DotSize.X - DotSize.X / 8;    // some people think the rects are too big (8/8 = 1) - this also means that all subtropical dots are 7/8ths the size of the other dots
                                Rect.Height = DotSize.Y - DotSize.Y / 8;

                                // get the colour
                                Rect.Fill = new SolidColorBrush(RenderBasedOnNodeIntensity(XStorm, XNode));

                                // Since there were many requests for an Invest/PTC storm type, here it is.
                                // need to fix redundant code - rc2 or iris

                                if (XNode.NodeType.ForceColour)
                                {
                                    // Invest / PTC uses [255,128,204,255] ARGB format
                                    Rect.Fill = new SolidColorBrush(XNode.NodeType.ForcedColour);
                                }
                                else
                                {
                                    Rect.Fill = new SolidColorBrush(RenderBasedOnNodeIntensity(XStorm, XNode));
                                }

                                // set the position
                                Canvas.SetLeft(Rect, XNode.Position.X);
                                Canvas.SetTop(Rect, XNode.Position.Y);

                                HurricaneBasin.Children.Add(Rect);
                                continue;

                            case StormShape.Triangle:

                                // draw the triangle
                                Polygon Poly = new Polygon();

                                if (XNode.NodeType.ForceSize)
                                {
                                    DotSize = XNode.NodeType.ForcedSize;
                                }

                                Poly.Points.Add(new Point(0, DotSize.Y));
                                Poly.Points.Add(new Point(DotSize.X / 2, 0));
                                Poly.Points.Add(new Point(DotSize.X, DotSize.Y));

                                // Since there were many requests for an Invest/PTC storm type, here it is.
                                if (XNode.NodeType.ForceColour)
                                {
                                    // Invest / PTC uses [255,128,204,255] ARGB format
                                    Poly.Fill = new SolidColorBrush(XNode.NodeType.ForcedColour);
                                }
                                else
                                {
                                    Poly.Fill = new SolidColorBrush(RenderBasedOnNodeIntensity(XStorm, XNode));
                                }

                                Canvas.SetLeft(Poly, XNode.Position.X);
                                Canvas.SetTop(Poly, XNode.Position.Y);

                                HurricaneBasin.Children.Add(Poly);
                                continue;
                            }
                        }
                        else // handle custom node handling
                        {
                            // We ignore forcesize for custom shapes
                            Polygon Poly = new Polygon();

                            foreach (Point Pt in XNode.NodeType.Shape.VPoints.Points) // needs some refactoring
                            {
                                Poly.Points.Add(Pt);
                            }

                            if (XNode.NodeType.Shape.IsFilled)
                            {
                                if (!XNode.NodeType.ForceColour)
                                {
                                    Poly.Fill = new SolidColorBrush(RenderBasedOnNodeIntensity(XStorm, XNode));
                                }
                                else
                                {
                                    if (XNode.NodeType.ForcedColour != null)
                                    {
                                        Poly.Fill = new SolidColorBrush(XNode.NodeType.ForcedColour);
                                    }
                                    else
                                    {
                                        // invalid forcedcolour state
                                        Poly.Fill = new SolidColorBrush(RenderBasedOnNodeIntensity(XStorm, XNode));
                                    }
                                }
                            }

                            Canvas.SetLeft(Poly, XNode.Position.X);
                            Canvas.SetTop(Poly, XNode.Position.Y);

                            HurricaneBasin.Children.Add(Poly);
                        }
                    }

                    if (ApplicationSettings.DefaultVisibleTextNames)
                    {
                        Render_DrawText(XStorm, HurricaneBasin);
                    }
                }
            }

            // Zoom and pan.
            Render_ZoomAndPan();

            // get WPF to render it
            UpdateLayout();
        }
Exemple #2
0
        public bool ExportCore(Project Proj, string FileName)
        {
            XmlDocument XDoc  = new XmlDocument();
            XmlNode     XRoot = XDoc.CreateElement("Project");

            Proj.FileName = FileName;
            // Version 2.0: Write the metadata
            XmlNode XMetadataNode = XDoc.CreateElement("Metadata");
            // Version of the format.
            XmlNode XAuthor             = XDoc.CreateElement("Author");
            XmlNode XFormatVersionMajor = XDoc.CreateElement("FormatVersionMajor");
            XmlNode XFormatVersionMinor = XDoc.CreateElement("FormatVersionMinor");
            XmlNode XProjectName        = XDoc.CreateElement("ProjectName");

            XmlNode XTimestamp = XDoc.CreateElement("Timestamp");

            XAuthor.InnerText             = Environment.UserName;
            XFormatVersionMajor.InnerText = FormatVersionMajor.ToString();
            XFormatVersionMinor.InnerText = FormatVersionMinor.ToString();
            string ProjectName = Proj.Name;

            if (ProjectName == null)
            {
                XProjectName.InnerText = Proj.Name;
            }
            else
            {
                XProjectName.InnerText = "Track Maker Project";
            }

            // ISO 8601 date format
            XTimestamp.InnerText = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            XmlNode XBasinsNode = XDoc.CreateElement("Basins");

            foreach (Basin Bas in Proj.OpenBasins)
            {
                XmlNode XBasinNode       = XDoc.CreateElement("Basin");
                XmlNode XBasinNameNode   = XDoc.CreateElement("UserTag");
                XmlNode XBasinNameBasin  = XDoc.CreateElement("Name");
                XmlNode XBasinIsOpen     = XDoc.CreateElement("IsOpen");
                XmlNode XBasinIsSelected = XDoc.CreateElement("IsSelected");
                XmlNode XBasinLayers     = XDoc.CreateElement("Layers");

                XBasinNameNode.InnerText   = Bas.UserTag;
                XBasinNameBasin.InnerText  = Bas.Name;
                XBasinIsOpen.InnerText     = Bas.IsOpen.ToString();
                XBasinIsSelected.InnerText = Bas.IsSelected.ToString();
                // build a layer

                foreach (Layer Lay in Bas.Layers)
                {
                    XmlNode XLayerNode     = XDoc.CreateElement("Layer");
                    XmlNode XLayerNameNode = XDoc.CreateElement("Name");
                    XmlNode XLayerGUIDNode = XDoc.CreateElement("GUID");
                    XmlNode XStormsNode    = XDoc.CreateElement("Storms");

                    XLayerNameNode.InnerText = Lay.Name;
                    XLayerGUIDNode.InnerText = Lay.LayerId.ToString();

                    // dump the storm info to file
                    foreach (Storm XStorm in Lay.AssociatedStorms)
                    {
                        // create the xml nodes.
                        XmlNode XStormNode          = XDoc.CreateElement("Storm");
                        XmlNode XStormFormationDate = XDoc.CreateElement("FormationDate");
                        XmlNode XStormID            = XDoc.CreateElement("ID");
                        XmlNode XStormName          = XDoc.CreateElement("Name");
                        XmlNode XStormNodeList      = XDoc.CreateElement("Nodes");
                        XmlNode XStormNodeListDel   = XDoc.CreateElement("DeletedNodes"); // the undone nodes

                        // set the basic info - name etc
                        XStormFormationDate.InnerText = XStorm.FormationDate.ToString();
                        XStormID.InnerText            = XStorm.Id.ToString();
                        XStormName.InnerText          = XStorm.Name;

                        // populate the node list
                        foreach (Node XNode in XStorm.NodeList)
                        {
                            // add new nodes
                            XmlNode XNodeNode      = XDoc.CreateElement("Node");
                            XmlNode XNodeIntensity = XDoc.CreateElement("Intensity");
                            XmlNode XNodePosition  = XDoc.CreateElement("Position");
                            XmlNode XNodePressure  = XDoc.CreateElement("Pressure");
                            XmlNode XNodeType      = XDoc.CreateElement("Type");

                            // set the info
                            XNodeIntensity.InnerText = XNode.Intensity.ToString();

                            RelativePositionConverter RPC = new RelativePositionConverter();
                            Point RP = (Point)RPC.ConvertBack(XNode.Position, typeof(Point), null, null);

                            XNodePosition.InnerText = RP.ToStringEmerald();
                            XNodePressure.InnerText = XNode.Pressure.ToString();
                            XNodeType.InnerText     = XNode.NodeType.Name;

                            // build the node list xml structure
                            XNodeNode.AppendChild(XNodeIntensity);
                            XNodeNode.AppendChild(XNodePosition);
                            XNodeNode.AppendChild(XNodePressure);
                            XNodeNode.AppendChild(XNodeType);
                            XStormNodeList.AppendChild(XNodeNode);
                        }

                        // Populate the deleted node list xmlinfo for the basin save information.

                        foreach (Node XNode in XStorm.NodeList_Deleted)
                        {
                            // add new nodes
                            XmlNode XNodeNode      = XDoc.CreateElement("Node");
                            XmlNode XNodeIntensity = XDoc.CreateElement("Intensity");
                            XmlNode XNodePosition  = XDoc.CreateElement("Position");
                            XmlNode XNodeType      = XDoc.CreateElement("Type");

                            // set the info
                            XNodeIntensity.InnerText = XNode.Intensity.ToString();

                            RelativePositionConverter RPC = new RelativePositionConverter();
                            Point RP = (Point)RPC.ConvertBack(XNode.Position, typeof(Point), null, null);

                            XNodePosition.InnerText = RP.ToStringEmerald();
                            XNodeType.InnerText     = XNode.NodeType.Name;

                            // build the node list xml structure
                            XNodeNode.AppendChild(XNodeIntensity);
                            XNodeNode.AppendChild(XNodePosition);
                            XNodeNode.AppendChild(XNodeType);
                            XStormNodeListDel.AppendChild(XNodeNode);
                        }
                        // build perstorm xml

                        XStormNode.AppendChild(XStormFormationDate);
                        XStormNode.AppendChild(XStormID);
                        XStormNode.AppendChild(XStormName);
                        XStormNode.AppendChild(XStormNodeList);
                        XStormNode.AppendChild(XStormNodeListDel);

                        XStormsNode.AppendChild(XStormNode);
                    }

                    XLayerNode.AppendChild(XLayerNameNode);
                    XLayerNode.AppendChild(XLayerGUIDNode);
                    XLayerNode.AppendChild(XStormsNode);

                    XBasinLayers.AppendChild(XLayerNode);
                }

                // Build the Basins node

                XBasinNode.AppendChild(XBasinNameNode);
                XBasinNode.AppendChild(XBasinNameBasin);
                XBasinNode.AppendChild(XBasinLayers);

                XBasinsNode.AppendChild(XBasinNode);
            }

            // build metadata

            XMetadataNode.AppendChild(XAuthor);
            XMetadataNode.AppendChild(XFormatVersionMajor);
            XMetadataNode.AppendChild(XFormatVersionMinor);
            XMetadataNode.AppendChild(XProjectName);

            XRoot.AppendChild(XMetadataNode);

            // build storms
            XRoot.AppendChild(XBasinsNode);

            XDoc.AppendChild(XRoot);

            XDoc.Save(FileName);

            // on success
            GlobalState.SetCurrentOpenFile(FileName);
            return(true);
        }