static private FileType MakeFile(JadeData.Project.File file)
 {
     FileType result = new FileType();
     result.Name = file.Name;
     result.Path = file.Path;
     return result;
 }

        static private FolderType MakeFolder(JadeData.Workspace.IFolder folder)
        {
            FolderType result = new FolderType();
            result.Name = folder.Name;

            FolderType[] subs = new FolderType[folder.Folders.Count];
            for (int i = 0; i < folder.Folders.Count; i++)
            {
                subs[i] = MakeFolder(folder.Folders[i]);
            }
            result.Folders = subs;

            List<JadeData.Workspace.ProjectItem> projTemps = new List<JadeData.Workspace.ProjectItem>();
            foreach (JadeData.Workspace.ProjectItem proj in folder.Items.OfType<JadeData.Workspace.ProjectItem>())
            {
                projTemps.Add(proj);
            }
            ProjectType[] projs = new ProjectType[projTemps.Count];
            for(int i=0;i<projTemps.Count;i++)
            {
                projs[i] = MakeProject(projTemps[i]);
            }
            result.Projects = projs;

            return result;
        }

        static private ProjectType MakeProject(JadeData.Workspace.ProjectItem proj)
        {
            ProjectType result = new ProjectType();

            result.Path = proj.Path;
            Persistence.Project.Writer.Write(proj, proj.Path);
            return result;
        }

        static private FolderType MakeFolder(JadeData.Project.IFolder folder)
        {
            FolderType result = new FolderType();

            result.Name = folder.Name;
            result.Files = new FileType[folder.Items.OfType<JadeData.Project.File>().Count()];
            result.Folders = new FolderType[folder.Folders.Count];

            int idx = 0;
            foreach (JadeData.Project.File f in folder.Items.OfType<JadeData.Project.File>())
            {
                result.Files[idx] = MakeFile(f);
                idx++;
            }
            idx = 0;
            foreach (JadeData.Project.IFolder f in folder.Folders)
            {
                result.Folders[idx] = MakeFolder(f);
            }
            return result;
        }

        static private ProjectType MakeProject(JadeData.Workspace.ProjectItem proj, string workspaceDir)
        {
            ProjectType result = new ProjectType();

            string absPath = proj.Path;

            if (System.IO.Path.IsPathRooted(absPath) == false)
            {
                absPath = System.IO.Path.Combine(workspaceDir, absPath);
            }

            result.Path = proj.Path;
            Persistence.Project.Writer.Write(proj, absPath);
            return result;
        }

        public ProjectFolder(Workspace workspace, TreeNodeBase parent, JadeData.Project.IFolder data)
            :   base(data.Name, parent)
        {
            _workspace = workspace;
            _data = data;

            foreach (JadeData.Project.IFolder f in _data.Folders)
            {
                AddChildFolder(new ProjectFolder(workspace, this, f));
                
            }

            foreach (JadeData.Project.IItem i in _data.Items)
            {
                if (i is JadeData.Project.File)
                {
                    AddChildFile(new File(this, i as JadeData.Project.File));
                    
                }
            }
        }

 public Project(Workspace workspace, TreeNodeBase parent, JadeData.Project.IProject project)
     :base(workspace, parent, project)
 {
     _data = project;
 }

 public File(TreeNodeBase parent, JadeData.Project.File file)
     :   base(file.Name, parent)
 {
     _data = file;
 }

        public Workspace(JadeData.Workspace.IWorkspace workspace)
            : base(null, workspace)
        {
            this.Initialise(this);

            _data = workspace;
            _modified = false;
            this.Expanded = true;
        }

 private void AddChildProject(JadeData.Project.IProject p)
 {
     Project project = new Project(_workspace, this, p);
     project.RemoveCommand.Attach(param => OnRemoveProject(param), param => CanDoRemoveProject(param));
     Children.Add(project);
 }

 private void AddChildFolder(JadeData.Workspace.IFolder f)
 {
     WorkspaceFolder folder = new WorkspaceFolder(this, f);
     folder.Initialise(_workspace);
     folder.RemoveCommand.Attach(param => OnRemoveFolder(param), param => CanDoRemoveFolder(param));
     Children.Add(folder);
 }

 public WorkspaceFolder(TreeNodeBase parent, JadeData.Workspace.IFolder folder)
     :   base(folder.Name, parent)
 {
     _data = folder;
 }

 public void AddFolder(JadeData.Project.IFolder f) {_project.AddFolder(f);}

 public void AddItem(JadeData.Project.IItem item) { _project.AddItem(item); }

        static public void Write(JadeData.Project.IProject project, string path)
        {
            ProjectType result = new ProjectType();

            result.Name = project.Name;

            result.Files = new FileType[project.Items.OfType<JadeData.Project.File>().Count()];
            result.Folders = new FolderType[project.Folders.Count];

            int idx = 0;
            foreach (JadeData.Project.File f in project.Items.OfType<JadeData.Project.File>())
            {
                result.Files[idx] = MakeFile(f);
                idx++;
            }
            idx = 0;
            foreach (JadeData.Project.IFolder f in project.Folders)
            {
                result.Folders[idx] = MakeFolder(f);
            }
            
            System.Xml.XmlDocument doc = new XmlDocument();
            System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(result.GetType());
            System.IO.TextWriter stream = new System.IO.StreamWriter(path);
            try
            {
                serializer.Serialize(stream, result);
                stream.Close();
                return;
            }
            catch
            {
                throw;
            }
            finally
            {
                stream.Close();
                stream.Dispose();
            }
        }

 static private string GetProjectPath(JadeData.Workspace.IWorkspace workspace, JadeData.Project.IProject proj)
 {
     return "";
 }

        static public string Write(JadeData.Workspace.IWorkspace workspace, string path)
        {
            string workspaceDir = System.IO.Path.GetDirectoryName(path);

            JadeData.Workspace.IFolder folder = workspace;
            WorkspaceType result = new WorkspaceType();

            result.Name = workspace.Name;

            FolderType[] subs = new FolderType[folder.Folders.Count];
            for (int i = 0; i < folder.Folders.Count; i++)
            {
                subs[i] = MakeFolder(folder.Folders[i], workspaceDir);
            }
            result.Folders = subs;

            List<JadeData.Workspace.ProjectItem> projTemps = new List<JadeData.Workspace.ProjectItem>();
            foreach (JadeData.Workspace.ProjectItem proj in folder.Items.OfType<JadeData.Workspace.ProjectItem>())
            {
                projTemps.Add(proj);
            }
            ProjectType[] projs = new ProjectType[projTemps.Count];
            for (int i = 0; i < projTemps.Count; i++)
            {
                projs[i] = MakeProject(projTemps[i], workspaceDir);
            }
            result.Projects = projs;

            System.Xml.XmlDocument doc = new XmlDocument();
            System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(result.GetType());
            System.IO.TextWriter stream = new System.IO.StreamWriter(path); 
            try
            {                    
                serializer.Serialize(stream, result);
                stream.Close();
                return "";
            }
            catch
            {
                throw;
            }
            finally
            {
                stream.Close();
                stream.Dispose();
            }
        }

 public void OpenSourceFile(JadeData.Project.File file)
 {
     DocumentViewModel d = new DocumentViewModel(file.Name, "Test " + file.Name);
     _openDocuments.Add(d);
     SelectedDocument = d;
 }