public List <MemoryMap> LoadFromFile(string filePath)
        {
            List <MemoryMap> maps = new List <MemoryMap>();

            m_execRegionOrderMap.Clear();

            using (XmlReader reader = XmlReader.Create(filePath))
            {
                try
                {
                    XPathDocument  doc = new XPathDocument(reader);
                    XPathNavigator nav = doc.CreateNavigator();

                    XPathNodeIterator lrs = nav.SelectDescendants("LoadRegion", ScatterfileNamespace, false);
                    while (lrs.MoveNext())
                    {
                        int order = 0;

                        string lrName = lrs.Current.GetAttribute("Name", "");

                        XPathNodeIterator ers = nav.SelectDescendants("ExecRegion", ScatterfileNamespace, false);

                        while (ers.MoveNext())
                        {
                            string erName = ers.Current.GetAttribute("Name", "");

                            m_execRegionOrderMap[lrName + ":" + erName] = order++;
                        }
                    }
                }
                catch
                {
                    System.Diagnostics.Debug.WriteLine("Invalid scatterfile format");
                }
            }

            using (XmlReader reader = XmlReader.Create(filePath))
            {
                try
                {
                    XmlSerializer xmlSer  = new XmlSerializer(typeof(ScatterFile));
                    ScatterFile   scatter = xmlSer.Deserialize(reader) as ScatterFile;

                    MemoryMap map = new MemoryMap();
                    map.Name = "MAP";
                    maps.Add(map);

                    LoadScatterElements(map, scatter, maps, new ArrayList());
                }
                catch
                {
                    System.Diagnostics.Debug.WriteLine("Invalid scatterfile format");
                }
            }
            return(maps);
        }
        public void GenerateScatterFile(string path)
        {
            m_execRegionOrderMap.Clear();

            string fileName = path + "\\" + ScatterfileNameStart + m_project.Name + ScatterfileExtension;

            if (File.Exists(fileName))
            {
                File.Delete(fileName);
            }

            ScatterFile scatterData = new ScatterFile();

            //TODO: FIX THIS
            MemoryMap map = m_project.MemoryMap;

            object baseOwner = AddConditional(scatterData, map.Conditional);

            AddEnvVarCollection(baseOwner, map.EnvironmentVariables);

            foreach (MemoryRegion region in map.Regions) //CreateSortedList(map.RegionsCollection))
            {
                object owner = AddConditional(baseOwner, region.Conditional);

                IList list = GetCollectionFromObject(owner, typeof(List <LoadRegion>));

                LoadRegion lr = new LoadRegion();
                lr.Name    = region.Name;
                lr.Base    = region.Address;
                lr.Options = region.Options;
                lr.Size    = region.Size;

                list.Add(lr);

                SortedList erList = new SortedList();
                m_execRegionOrderMap[lr.Name] = erList;

                foreach (MemorySection sec in CreateSortedList(region.Sections))
                {
                    owner = AddConditional(lr, sec.Conditional);

                    list = GetCollectionFromObject(owner, typeof(List <ExecRegion>));

                    ExecRegion er = new ExecRegion();
                    er.Name    = sec.Name;
                    er.Base    = sec.Address;
                    er.Options = sec.Options;
                    er.Size    = sec.Size;

                    erList.Add(sec.Order, er);

                    list.Add(er);

                    /*
                     * SortedList symList = new SortedList();
                     * m_symOrderMap[er.Name] = symList;
                     */

                    foreach (MemorySymbol sym in CreateSortedList(sec.Symbols))
                    {
                        owner = AddConditional(er, sym.Conditional);

                        list = GetCollectionFromObject(owner, typeof(List <FileMapping>));

                        FileMapping fm = new FileMapping();
                        fm.Name    = sym.Name;
                        fm.Options = sym.Options;

                        //symList.Add(sym.Order, fm);

                        list.Add(fm);
                    }
                }
            }

            using (MemoryStream stream = new MemoryStream())
            {
                XmlSerializer xmlSer = new XmlSerializer(typeof(ScatterFile));
                xmlSer.Serialize(stream, scatterData);

                stream.Seek(0, SeekOrigin.Begin);

                XPathDocument     xp  = new XPathDocument(stream);
                XPathNavigator    nav = xp.CreateNavigator();
                XPathNodeIterator lrs = nav.SelectDescendants("LoadRegion", ScatterfileNamespace, false);

                while (lrs.MoveNext())
                {
                    string lrName = lrs.Current.GetAttribute("Name", "");

                    XPathNodeIterator ers = lrs.Current.SelectDescendants("ExecRegion", ScatterfileNamespace, false);

                    while (ers.MoveNext())
                    {
                        string erName = ers.Current.GetAttribute("Name", "");

                        XPathNavigator navParent = ers.Current.CreateNavigator();
                        XPathNavigator navTrail  = navParent.CreateNavigator();

                        while (navParent.MoveToParent())
                        {
                            if (navParent.Name == "LoadRegion")
                            {
                                break;
                            }
                            navTrail.MoveToParent();
                        }

                        m_execRegionsToNavNode[lrName + ":" + erName] = navTrail.CreateNavigator();

                        /*
                         * XPathNodeIterator files = ers.Current.SelectDescendants("FileMapping", ScatterfileNamespace, false);
                         * while (files.MoveNext())
                         * {
                         *  string fm = ers.Current.GetAttribute("Name", "");
                         *
                         *  navParent = files.Current.CreateNavigator();
                         *  navTrail = navParent.CreateNavigator();
                         *
                         *  while (navParent.MoveToParent())
                         *  {
                         *      if (navParent.Name == "ExecRegion")
                         *      {
                         *          break;
                         *      }
                         *      navTrail.MoveToParent();
                         *  }
                         *
                         *  m_symToNavNode[erName + ":" + fm] = navTrail.CreateNavigator();
                         * }
                         */
                    }
                }

                XmlWriterSettings xmlSet = new XmlWriterSettings();
                xmlSet.Indent       = true;
                xmlSet.NewLineChars = "\r\n";


                using (XmlWriter writer = XmlWriter.Create(fileName, xmlSet))
                {
                    writer.WriteStartDocument();
                    nav.MoveToFirstChild();

                    WriteNextNode(writer, nav, true);

                    writer.WriteEndDocument();
                    //writer.WriteNode(nav, false);
                    writer.Flush();
                }
            }
        }