public void WriteSourceItemXml(XmlWriter writer, SourceItemDefinition item, string xmlFilePath = "")
{
string name = item.IsFolder
? ((item is RootFolderDefinition) ? "RootFolder" : "Folder")
: "Header";
writer.WriteStartElement(name);
if (item == RootFolder)
{
writer.WriteAttributeString("Name", PathUtility.MakeRelativePath(xmlFilePath, item.Name));
}
else
{
writer.WriteAttributeString("Name", item.Name);
}
if (item.IsExcluded)
{
writer.WriteAttributeString("IsExcluded", "true");
}
if (!item.HasDefaultIncludeFolders)
{
WriteIncludeFolders(writer, item);
}
foreach (var child in item.Children)
{
WriteSourceItemXml(writer, child);
}
writer.WriteEndElement();
}
static void OpenSourceItem(SourceItemDefinition item)
{
var proc = new Process();
proc.StartInfo.FileName = item.FullPath;
proc.StartInfo.UseShellExecute = true;
proc.Start();
}
private void WriteIncludeFolders(XmlWriter writer, SourceItemDefinition item)
{
foreach (string includeFolder in item.IncludeFolders)
{
writer.WriteStartElement("IncludeFolder");
writer.WriteString(includeFolder);
writer.WriteEndElement();
}
}
private static TreeNode GetTreeNodeByTag(TreeNodeCollection nodes, SourceItemDefinition item)
{
foreach (TreeNode node in nodes)
{
if (ReferenceEquals(node.Tag, item))
{
return(node);
}
}
return(null);
}
private static void RenameHeaders(SourceItemDefinition item)
{
if (item.Name.StartsWith("bt"))
{
item.Name = item.Name.Substring(2);
}
foreach (var child in item.Children)
{
RenameHeaders(child);
}
}
public static void RenameCodeFiles(SourceItemDefinition item)
{
if (item is HeaderDefinition header)
{
header.Name = Path.GetFileNameWithoutExtension(header.FullPath) + ".cs";
}
else
{
foreach (SourceItemDefinition child in item.Children)
{
RenameCodeFiles(child);
}
}
}
private void ParseSourceItem(SourceItemDefinition sourceItem)
{
if (!sourceItem.IsExcluded)
{
if (sourceItem.IsFolder)
{
ParseFolder(sourceItem as FolderDefinition);
}
else
{
ParseHeader(sourceItem as HeaderDefinition);
}
}
}
private void ReadSourceItems(XmlReader reader, SourceItemDefinition parent)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case "Folder":
case "Header":
{
SourceItemDefinition item;
var name = reader.GetAttribute("Name");
var isExcluded = "true".Equals(reader.GetAttribute("IsExcluded"));
if (reader.Name.Equals("Folder"))
{
item = new FolderDefinition(name);
}
else // if (reader.Name.Equals("Header"))
{
item = new HeaderDefinition(name);
}
parent.AddChild(item);
item.IsExcluded = isExcluded;
if (item.IsFolder)
{
ReadSourceItems(reader, item);
}
}
break;
case "IncludeFolder":
ReadIncludeFolder(reader, parent);
break;
default:
throw new NotImplementedException();
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
return;
}
}
}
private IEnumerable <string> GetItemIncludeFolders(SourceItemDefinition item)
{
if (item == null)
{
return(new string[0]);
}
return(item.IncludeFolders.SelectMany(i =>
{
if (string.Equals(i, "$(Inherited)"))
{
return GetItemIncludeFolders(item.Parent);
}
return new[] { Path.Combine(item.FullPath, i) };
}));
}
private void SetNodeProperties(SourceItemDefinition item, TreeNode node)
{
if (item.IsExcluded)
{
node.ForeColor = Color.Gray;
}
if (item.IsFolder)
{
node.ImageKey = "folder";
node.SelectedImageKey = "folder";
}
else
{
node.ImageKey = "header";
node.SelectedImageKey = "header";
}
}
public void ReadIncludeFolder(XmlReader reader, SourceItemDefinition item)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Text)
{
if (item.HasDefaultIncludeFolders)
{
item.IncludeFolders.Clear();
item.IncludeFolders.Add(reader.Value);
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
return;
}
}
}
private SourceItemDefinition CloneSourceItem(SourceItemDefinition item)
{
if (item == null)
{
return(null);
}
if (_oldToNewMapping.TryGetValue(item, out SourceItemDefinition clone))
{
return(clone);
}
if (item is HeaderDefinition)
{
clone = new HeaderDefinition(item.Name);
}
else if (item is FolderDefinition)
{
clone = new FolderDefinition(item.Name);
}
else if (item is RootFolderDefinition)
{
clone = new RootFolderDefinition(item.Name);
RootFolderClone = RootFolderClone ?? clone as RootFolderDefinition;
}
else
{
throw new NotSupportedException();
}
_oldToNewMapping[item] = clone;
clone.Parent = CloneSourceItem(item.Parent);
foreach (SourceItemDefinition child in item.Children.Where(c => !c.IsExcluded))
{
var childClone = CloneSourceItem(child);
clone.Children.Add(childClone);
}
return(clone);
}
private void WriteItem(SourceItemDefinition item)
{
if (item is FolderDefinition folder)
{
Directory.CreateDirectory(folder.FullPath);
}
if (item is RootFolderDefinition rootFolder)
{
Directory.CreateDirectory(rootFolder.FullPath);
}
if (item is HeaderDefinition header)
{
WriteHeader(header);
}
foreach (SourceItemDefinition child in item.Children)
{
WriteItem(child);
}
}
