public void Initialize(
Project project,
ProjectFolder projectFolder)
{
_project = project;
_projectFolder = projectFolder;
}
private void FilterViews(ProjectFolder folder, Dictionary<string, ProjectFile> views)
{
// Collect
Traverse(folder, file => views.Add(file.RelativePath, file));
// Filter
Traverse(folder, file => RemoveDeviceSpecificWithCorrespondingDesktop(file, views));
}
private void Traverse(ProjectFolder folder, Action<ProjectFile> action) {
foreach (var file in folder.Files) {
if (file.RelativePath.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase)) {
action(file);
}
}
foreach (var subfolder in folder.Folders) {
Traverse(subfolder, action);
}
}
private void BrowserProductFolder(TreeNode treeNode, ProjectFolder projectFolder)
{
TreeNode node;
foreach (ProjectFolder pf in (IEnumerable<ProjectFolder>)projectFolder)
{
node = new TreeNode(pf.Name);
pf.LinkReference = node;
treeNode.Nodes.Add(node);
BrowserProductFolder(node, pf);
}
}
private void CollectViews(ProjectFolder folder, Dictionary<string, ProjectFile> views) {
foreach (var file in folder.Files) {
if (file.Name.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase)) {
if (!IsMobileWithCorrespondingDesktop(file, views)) {
views.Add(file.RelativePath, file);
}
}
}
foreach (var subfolder in folder.Folders) {
CollectViews(subfolder, views);
}
}
public bool Execute(ProjectFolder folder) {
var model = new ViewMobilizerModel(folder);
var form = new ViewMobilizerForm(model);
var result = form.ShowDialog();
if (result == DialogResult.OK) {
foreach (var view in model.SelectedViews) {
var file = view.Item1;
string mobileFileName = view.Item2;
File.Copy(file.FullName, mobileFileName);
folder.DteProjectItems.AddFromFile(mobileFileName);
}
}
return true;
}
private static List<string> GetCandidateFilesToConvert(ProjectFolder folder)
{
var folderLoweredName = folder.FullName.ToLower();
var razorFiles = (from f in folder.Files.Select(y => y.Name.ToLower())
where f.EndsWith("cshtml")
select Path.Combine(folderLoweredName, f)).ToList();
var candidateFilesToConvert = (from f in folder.Files
where f.Name.ToLower().EndsWith("aspx")
select Path.Combine(folder.FullName, f.Name)).ToList();
//var razorFiles = Directory.EnumerateFiles(@"c:\temp\").Where(f => f.ToLower().EndsWith("cshtml")).Select(f => f.ToLower());
//var candidateFilesToConvert = Directory.EnumerateFiles(@"c:\temp\").Where(f => f.ToLower().EndsWith("aspx"));
candidateFilesToConvert = (from f in candidateFilesToConvert
where !razorFiles.Contains(f.ToLower().Substring(0, f.Length - 4) + "cshtml")
select f).ToList();
return candidateFilesToConvert;
}
public bool Execute(ProjectFolder folder)
{
var candidateFilesToConvert = GetCandidateFilesToConvert(folder);
if (candidateFilesToConvert.Count == 0)
{
MessageBox.Show(
"No files to convert. Check if you have already converted files and remove the existing cshtml files for the aspx's you want to convert.",
"No files found", MessageBoxButton.OK, MessageBoxImage.Warning);
return true;
}
var filesToConvert = AskUserToSelectFiles(candidateFilesToConvert);
var convertedFiles = AspxToRazor.ConvertFiles(filesToConvert);
foreach (var convertedFile in convertedFiles)
folder.DteProjectItems.AddFromFile(convertedFile);
return true;
}
private void BrowserFolder(ProjectFolder projectFolder)
{
ProjectFolder subFolder;
ProjectFile projectFile;
DirectoryInfo dir = new DirectoryInfo(projectFolder.Path);
/// Add all files to curent folder
foreach (FileInfo fileInfo in dir.GetFiles())
{
projectFile = new ProjectFile(fileInfo.Name,fileInfo.FullName);
projectFolder.AddFile(projectFile);
//Log.Write(fileInfo.FullName, this, "BrowserFolder", Log.LogType.DEBUG);
}
/// Add all subfolders to curent folder and ...
foreach (DirectoryInfo di in dir.GetDirectories())
{
subFolder = new ProjectFolder(di.Name, di.FullName);
projectFolder.AddFolder(subFolder);
BrowserFolder(subFolder);
}
}
private void buttonAddProjectFolder_ItemClick(object sender, ItemClickEventArgs e)
{
using (var form = new ProjectFolderEditForm())
{
var pf =
new ProjectFolder(Project)
{
Name = Resources.SR_ProjectFilesUserControl_buttonAddProjectFolderItemClick_NewProjectFolder
};
form.Initialize(pf);
if (form.ShowDialog(this) == DialogResult.OK)
{
var parentProjectFolder =
treeView.SelectedNode.Tag as ProjectFolder;
if (parentProjectFolder != null)
{
pf.Parent = parentProjectFolder;
}
Project.ProjectFolders.Add(pf);
Project.MarkAsModified();
var node = addProjectFolderToTree(treeView.SelectedNode, pf);
// --
sortTree();
treeView.SelectedNode = node;
UpdateUI();
}
}
}
public static bool IsFigmaDirectory(this ProjectFolder pr)
{
return(pr.Path.Extension == FigmaBundle.FigmaDirectoryName &&
pr.Parent is Project);
}
/*
/// <summary>
/// Does the automatically add resource files.
/// </summary>
/// <param name="backgroundWorker">The background worker.</param>
/// <param name="parentProjectFolder">The parent project folder.</param>
/// <param name="fileGroupCount">The file group count.</param>
/// <param name="fileCount">The file count.</param>
/// <param name="folderPath">The folder path.</param>
private void doAutomaticallyAddResourceFiles(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ZlpDirectoryInfo folderPath)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
// Omit hidden or system folders.
if ((folderPath.Attributes & FileAttributes.Hidden) == 0 &&
(folderPath.Attributes & FileAttributes.System) == 0)
{
var filePaths = folderPath.GetFiles(@"*.resx");
if (filePaths.Length > 0)
{
FileGroup fileGroup = null;
string previousBaseFileName = null;
foreach (var filePath in filePaths)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
var baseFileName =
filePath.Name.Substring(0, filePath.Name.IndexOf('.'));
var wantAddResourceFile =
checkWantAddResourceFile(filePath);
if (wantAddResourceFile)
{
if (fileGroup == null ||
previousBaseFileName == null ||
string.Compare(baseFileName, previousBaseFileName, true) != 0)
{
if (fileGroup != null && fileGroup.Count > 0)
{
// Look for same entries.
if (!_project.FileGroups.HasFileGroupWithChecksum(
fileGroup.GetChecksum(_project)))
{
_project.FileGroups.Add(fileGroup);
fileGroupCount++;
fileCount += fileGroup.Count;
}
}
fileGroup =
new FileGroup(_project)
{
ProjectFolder = parentProjectFolder
};
}
fileGroup.Add(
new FileInformation(fileGroup)
{
File = filePath
});
previousBaseFileName = baseFileName;
}
}
// Add remaining.
if (fileGroup != null && fileGroup.Count > 0)
{
// Look for same entries.
if (!_project.FileGroups.HasFileGroupWithChecksum(
fileGroup.GetChecksum(_project)))
{
_project.FileGroups.Add(fileGroup);
fileGroupCount++;
fileCount += fileGroup.Count;
}
}
}
}
// Recurse childs.
foreach (var childFolderPath in folderPath.GetDirectories())
{
doAutomaticallyAddResourceFiles(
backgroundWorker,
parentProjectFolder,
ref fileGroupCount,
ref fileCount,
childFolderPath);
}
}
*/
private void doAutomaticallyAddResourceFiles(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ZlpDirectoryInfo folderPath)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
// Omit hidden or system folders.
if ((folderPath.Attributes & ZetaLongPaths.Native.FileAttributes.Hidden) == 0 &&
(folderPath.Attributes & ZetaLongPaths.Native.FileAttributes.System) == 0)
{
//CHANGED use comon method to look load new files:
var filePaths = new List<ZlpFileInfo>(folderPath.GetFiles(@"*.resx"));
filePaths.AddRange(new List<ZlpFileInfo>(folderPath.GetFiles(@"*.resw")));
new VisualStudioImporter(Project).
DoAutomaticallyAddResourceFilesFromList(
backgroundWorker,
parentProjectFolder,
ref fileGroupCount,
ref fileCount,
filePaths);
}
// Recurse childs.
foreach (var childFolderPath in folderPath.GetDirectories())
{
doAutomaticallyAddResourceFiles(
backgroundWorker,
parentProjectFolder,
ref fileGroupCount,
ref fileCount,
childFolderPath);
}
}
public bool IsValidTarget(ProjectFolder folder)
{
throw new System.NotImplementedException();
}
public AddNewFile(ProjectFolder projectFolder, bool OpenFileAfterCreation = true)
: this(Schematix.SchematixCore.Core, projectFolder, OpenFileAfterCreation)
{
this.openFileAfterCreation = OpenFileAfterCreation;
}
private static void ParseFolder(ProjectFolder folder, string dir)
{
//Directory.CreateDirectory(dir);
var path = Path.Combine(dir, NormalizeFolderName(folder.Name));
foreach (var projectFolder in folder.SubItems)
{
ParseFolder(projectFolder, path);
}
if (folder is IBlocksFolder)
{
var blkFld = folder as IBlocksFolder;
foreach (var projectBlockInfo in blkFld.BlockInfos)
{
try
{
var src = projectBlockInfo.Export(ExportFormat.Default);
if (src != null)
{
var ext = "xml";
if (projectBlockInfo.BlockLanguage == PLCLanguage.DB && projectBlockInfo.BlockType == PLCBlockType.DB)
{
ext = "db";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.SCL)
{
ext = "scl";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.KOP)
{
ext = "lad";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.FUP)
{
ext = "fbd";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.AWL)
{
ext = "stl";
}
var file = Path.Combine(path, projectBlockInfo.Name.Replace("\\", "_").Replace("/", "_") + "." + ext);
var xmlValid = false;
XmlDocument xmlDoc = new XmlDocument();
try
{
xmlDoc.LoadXml(src);
xmlValid = true;
}
catch
{
xmlValid = false;
}
if (xmlValid)
{
try
{
var nodes = xmlDoc.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc.Save(writer);
}
src = sb.ToString();
}
if (src != null)
{
Directory.CreateDirectory(path);
File.WriteAllText(file, src /*, Encoding.UTF8*/);
}
else
{
Console.WriteLine("Skipping Block (null)" + projectBlockInfo.Name);
}
}
else
{
Console.WriteLine("Skipping Block (null)" + projectBlockInfo.Name);
}
}
catch (Exception ex)
{
Console.WriteLine("Skipping Block: \"" + projectBlockInfo.Name + "\" Exception: " + ex.Message);
}
}
}
}
// ADDED: adds resources from file Info lists.
// I have changed a method doAutomaticallyAddResourceFiles to fill file groups.
// You can use same method if you call this method from there.
// ATTENTION: LanguageCodeDetection was modified a bit to support variable amount
// of point in base name. New method GetBaseName(IInheritedSettings settings, string fileName)
// was added to get same base name FileGroup gets.
public void DoAutomaticallyAddResourceFilesFromList(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ICollection<ZlpFileInfo> fileList)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
else if (fileList != null && fileList.Count > 0)
{
var fileGroups = Project.FileGroups;
//if (parentProjectFolder != null)
//{
// fileGroups = parentProjectFolder.ChildFileGroups;
//}
foreach (var filePath in fileList)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
//other algorithm to determine base name to allow multiple points inside name
var baseFileName = LanguageCodeDetection.GetBaseName(Project, filePath.Name);
var wantAddResourceFile =
checkWantAddResourceFile(filePath);
if (wantAddResourceFile)
{
//find right file group
var path = filePath;
var fileGroup = fileGroups.Find(
g =>
string.Compare(g.BaseName, baseFileName, true) == 0 &&
string.Compare(g.FolderPath.FullName, path.Directory.FullName, true) == 0);
if (fileGroup == null)
{
fileGroup =
new FileGroup(Project)
{
ProjectFolder = parentProjectFolder
};
// Look for same entries.
if (!Project.FileGroups.HasFileGroupWithChecksum(
fileGroup.GetChecksum(Project)))
{
fileGroups.Add(fileGroup);
fileGroupCount++;
}
}
fileGroup.Add(
new FileInformation(fileGroup)
{
File = filePath
});
fileCount++;
}
}
}
}
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
if (myConn != null)
{
myConn.Disconnect();
}
viewBlockList.Visible = false;
dtaSymbolTable.Visible = false;
hexBox.Visible = false;
txtTextBox.Visible = false;
lblToolStripFileSystemFolder.Text = "";
lblStatus.Text = "";
tableLayoutPanelVisu.ColumnStyles[1].Width = 0;
datablockView.Visible = false;
lblToolStripFileSystemFolder.Text = "";
blkFld = null;
if (treeStep7Project.SelectedNode != null)
{
ProjectFolder fld = (ProjectFolder)((myTreeNode)treeStep7Project.SelectedNode).myObject;
lblProjectName.Text = fld.Project.ProjectName;
lblProjectInfo.Text = fld.Project.ProjectDescription;
var tmp = (myTreeNode)treeStep7Project.SelectedNode;
if (tmp.myObject is IBlocksFolder)
{
blkFld = (IBlocksFolder)tmp.myObject;
}
if (tmp.myObject.GetType() == typeof(SymbolTable))
{
var tmp2 = (SymbolTable)tmp.myObject;
if (oldNode != treeStep7Project.SelectedNode)
{
dtaSymbolTable.Rows.Clear();
foreach (var step7SymbolTableEntry in tmp2.SymbolTableEntrys)
{
dtaSymbolTable.Rows.Add(new object[]
{
step7SymbolTableEntry.Symbol, step7SymbolTableEntry.DataType,
step7SymbolTableEntry.Operand, step7SymbolTableEntry.Comment
});
}
}
dtaSymbolTable.Visible = true;
lblToolStripFileSystemFolder.Text = tmp2.Folder;
}
else if (blkFld != null)
{
if (oldNode != treeStep7Project.SelectedNode)
{
lstListBox.Items.Clear();
//ProjectBlockInfo[] arr =
//NumericComparer nc = new NumericComparer();
//Array.Sort(arr, nc);
lstListBox.Items.AddRange(blkFld.readPlcBlocksList().ToArray());
}
viewBlockList.Visible = true;
if (tmp.myObject.GetType() == typeof(BlocksOfflineFolder))
{
lblToolStripFileSystemFolder.Text = ((BlocksOfflineFolder)blkFld).Folder;
}
}
else if (tmp.myObject.GetType() == typeof(SourceFolder))
{
src = (SourceFolder)tmp.myObject;
if (oldNode != treeStep7Project.SelectedNode)
{
lstListBox.Items.Clear();
lstListBox.Items.AddRange(src.readPlcBlocksList().ToArray());
}
viewBlockList.Visible = true;
lblToolStripFileSystemFolder.Text = src.Folder;
}
else if (tmp.myObject is CPUFolder)
{
var cpu = tmp.myObject as CPUFolder;
if (oldNode != treeStep7Project.SelectedNode)
{
lstListBox.Items.Clear();
lstListBox.Items.Add("Password: "******"CpuType: " + cpu.CpuType);
}
viewBlockList.Visible = true;
}
}
oldNode = treeStep7Project.SelectedNode;
}
public static void BuildProjectFromDirectoriesRecursive(string path, ref ProjectFolder project)
{
foreach (string directory in Directory.GetDirectories(path))
{
ProjectFolder folder = (new DomNode(DotaObjectsSchema.FolderType.Type)).As<ProjectFolder>();
folder.Path = directory;
folder.Name = directory.Substring(directory.LastIndexOf(Path.DirectorySeparatorChar) + 1);
project.Files.Add(folder);
BuildProjectFromDirectoriesRecursive(directory, ref folder);
}
foreach (string File in Directory.GetFiles(path))
{
string ext = Path.GetExtension(File);
ProjectFile f;
if(FileTypes.ContainsKey(ext))
{
FileTypeResolver resolver = FileTypes[ext];
f = (ProjectFile)(new DomNode(resolver.DomNodeType)).As(resolver.WrapperType);
}
else
{
f = (new DomNode(DotaObjectsSchema.FileType.Type)).As<ProjectFile>();
}
string name = Path.GetFileName(File);
f.Path = File;
f.Name = name;
project.Files.Add(f);
}
}
public void DoAutomaticallyAddResourceFilesFromVsProject(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ZlpFileInfo vsProjectPath)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
else if (vsProjectPath != null && vsProjectPath.Exists)
{
if (@".sln" == vsProjectPath.Extension.ToLowerInvariant())
{
//file is solution, so add all projects from solution
doAutomaticallyAddResourceFilesFromVSSolution(
backgroundWorker,
parentProjectFolder,
ref fileGroupCount,
ref fileCount,
vsProjectPath);
}
else
{
//load fom solution
var pdoc = new XmlDocument();
//using (var fs = vsProjectPath.OpenRead())
{
pdoc.LoadXml(ZlpIOHelper.ReadAllText(vsProjectPath.FullName));
}
var nameMgr = new XmlNamespaceManager(pdoc.NameTable);
nameMgr.AddNamespace(@"mb", @"http://schemas.microsoft.com/developer/msbuild/2003");
const string xpath = @"/mb:Project/mb:ItemGroup/mb:EmbeddedResource/@Include";
var resNodes = pdoc.SelectNodes(xpath, nameMgr);
var filePaths = new List <ZlpFileInfo>(); //get all files
if (resNodes != null)
{
// ReSharper disable LoopCanBeConvertedToQuery
foreach (XmlNode node in resNodes)
// ReSharper restore LoopCanBeConvertedToQuery
{
var include = node.Value;
if (!string.IsNullOrEmpty(include) &&
(include.ToLowerInvariant().EndsWith(@".resx") ||
include.ToLowerInvariant().EndsWith(@".resw")))
{
var fullPath = ZlpPathHelper.Combine(vsProjectPath.DirectoryName, include);
filePaths.Add(new ZlpFileInfo(fullPath));
}
}
}
//add all files from list
DoAutomaticallyAddResourceFilesFromList(
backgroundWorker,
parentProjectFolder,
ref fileGroupCount,
ref fileCount,
filePaths);
}
}
}
public bool IsValidTarget(ProjectFolder folder)
{
return(true);
}
private void doAutomaticallyAddResourceFilesFromVSSolution(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ZlpFileInfo vsSolutionPath)
{
if (vsSolutionPath != null && vsSolutionPath.Exists)
{
string solutionText;
//using (var sr = vsSolutionPath.OpenText())
{
//we can read it line by line to reduce memory usage, but solution files are not very big
solutionText = ZlpIOHelper.ReadAllText(vsSolutionPath.FullName); // sr.ReadToEnd();
}
//solution files looks like:
//Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZetaResourceEditor", "Main\ZetaResourceEditor.csproj", "{367758E7-0435-440A-AC76-1F30ABBA3ED8}"
//EndProject
//known projectTypes:
//c#: FAE04EC0-301F-11D3-BF4B-00C04F79EFBC, VB: F184B08F-C81C-45F6-A57F-5ABD9991F28F
//@see http://msdn.microsoft.com/en-us/library/hb23x61k%28VS.80%29.aspx
//TODO: support virtual folders
var supportedProjectTypes =
new[]
{
@"FAE04EC0-301F-11D3-BF4B-00C04F79EFBC",
@"F184B08F-C81C-45F6-A57F-5ABD9991F28F"
};
//we need some regular expression to find required info:
const string pattern =
@"Project\(""{(?<projectType>[^}]*)}""\)\s*=\s*""(?<projectName>[^""]*)"",\s*""(?<projectRelPath>[^""]*)"",\s*""{(?<projectID>[^}]*)}""";
foreach (Match m in Regex.Matches(solutionText, pattern))
{
if (!m.Success)
{
continue;
}
var g = m.Groups[@"projectType"];
if (g == null || !g.Success)
{
continue;
}
var projectType = g.Value;
//compare with known project types.
// Currently only CS Projects are supported.
// But other types like VB can be simply added.
if (!Array.Exists(supportedProjectTypes, a => a == projectType))
{
continue;
}
var projectRelPath = m.Groups[@"projectRelPath"].Value;
var projectFile = new ZlpFileInfo(ZlpPathHelper.Combine(vsSolutionPath.Directory.FullName, projectRelPath));
//add all files from project
//we can add each using separate sub folder
var projectName = m.Groups[@"projectName"].Value;
//look in subfolders only
var subFolders = Project.ProjectFolders;
if (parentProjectFolder != null)
{
subFolders = parentProjectFolder.ChildProjectFolders;
}
var pf = subFolders.Find(f => f.Name == projectName);
if (pf == null)
{
pf =
new ProjectFolder(Project)
{
Name = projectName,
Parent = parentProjectFolder
};
Project.ProjectFolders.Add(pf);
}
Project.MarkAsModified();
DoAutomaticallyAddResourceFilesFromVsProject(
backgroundWorker,
pf,
ref fileGroupCount,
ref fileCount,
projectFile);
}
}
}
// ADDED: adds resources from file Info lists.
// I have changed a method doAutomaticallyAddResourceFiles to fill file groups.
// You can use same method if you call this method from there.
// ATTENTION: LanguageCodeDetection was modified a bit to support variable amount
// of point in base name. New method GetBaseName(IInheritedSettings settings, string fileName)
// was added to get same base name FileGroup gets.
public void DoAutomaticallyAddResourceFilesFromList(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ICollection <ZlpFileInfo> fileList)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
else if (fileList != null && fileList.Count > 0)
{
var fileGroups = Project.FileGroups;
//if (parentProjectFolder != null)
//{
// fileGroups = parentProjectFolder.ChildFileGroups;
//}
foreach (var filePath in fileList)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
//other algorithm to determine base name to allow multiple points inside name
//var baseFileName = LanguageCodeDetection.GetBaseName(Project, filePath.Name);
var info = new FileInfo(filePath.FullName);
var baseFileName = info.Name;
var wantAddResourceFile =
checkWantAddResourceFile(filePath);
if (wantAddResourceFile)
{
//find right file group
var path = filePath;
var fileGroup = fileGroups.Find(
g =>
string.Compare(g.BaseName, baseFileName, true) == 0 &&
string.Compare(g.FolderPath.FullName, path.Directory.FullName, true) == 0);
if (fileGroup == null)
{
fileGroup =
new FileGroup(Project)
{
ProjectFolder = parentProjectFolder
};
// Look for same entries.
if (!Project.FileGroups.HasFileGroupWithChecksum(
fileGroup.GetChecksum(Project)))
{
fileGroups.Add(fileGroup);
fileGroupCount++;
}
}
fileGroup.Add(
new FileInformation(fileGroup)
{
File = filePath
});
fileCount++;
}
}
}
}
public ViewMobilizerModel(ProjectFolder folder) {
var views = new Dictionary<string, ProjectFile>(StringComparer.OrdinalIgnoreCase);
CollectViews(folder, views);
Views = views;
SelectedViews = new List<Tuple<ProjectFile, string>>();
}
public ViewMobilizerModel(ProjectFolder folder, string suffix)
{
Folder = folder;
Populate(suffix);
}
public void Initialize(ProjectFolder projectFolder)
{
_projectFolder = projectFolder;
}
//private string path;
public Project(string path)
{
this.RootFolder = new ProjectFolder("Root", path);
}
public static VersionControlItem CreateItem(object obj, bool projRecurse = true)
{
string path;
bool isDir;
WorkspaceObject pentry;
VersionInfo versionInfo = null;
if (obj is ProjectFile)
{
ProjectFile file = (ProjectFile)obj;
path = file.FilePath;
isDir = false;
pentry = file.Project;
}
else if (obj is SystemFile)
{
SystemFile file = (SystemFile)obj;
path = file.Path;
isDir = false;
pentry = file.ParentWorkspaceObject;
}
else if (obj is ProjectFolder)
{
ProjectFolder f = (ProjectFolder)obj;
path = f.Path;
isDir = true;
pentry = f.ParentWorkspaceObject;
}
else if (!projRecurse && obj is Solution)
{
Solution sol = (Solution)obj;
path = sol.FileName;
isDir = false;
pentry = sol;
}
else if (!projRecurse && obj is Project)
{
Project proj = (Project)obj;
path = proj.FileName;
isDir = false;
pentry = proj;
}
else if (!projRecurse && obj is UnknownSolutionItem)
{
UnknownSolutionItem item = (UnknownSolutionItem)obj;
path = item.FileName;
isDir = false;
pentry = item;
}
else if (obj is WorkspaceObject)
{
pentry = ((WorkspaceObject)obj);
path = pentry.BaseDirectory;
isDir = true;
}
else
{
return(null);
}
if (pentry == null)
{
return(null);
}
return(new VersionControlItem(VersionControlService.GetRepository(pentry), pentry, path, isDir, versionInfo));
}
public void DoAutomaticallyAddResourceFilesFromVsProject(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ZlpFileInfo vsProjectPath)
{
if (backgroundWorker.CancellationPending)
{
throw new OperationCanceledException();
}
else if (vsProjectPath != null && vsProjectPath.Exists)
{
if (@".sln" == vsProjectPath.Extension.ToLowerInvariant())
{
//file is solution, so add all projects from solution
doAutomaticallyAddResourceFilesFromVSSolution(
backgroundWorker,
parentProjectFolder,
ref fileGroupCount,
ref fileCount,
vsProjectPath);
}
else
{
//load fom solution
var pdoc = new XmlDocument();
//using (var fs = vsProjectPath.OpenRead())
{
pdoc.LoadXml(ZlpIOHelper.ReadAllText(vsProjectPath.FullName));
}
var nameMgr = new XmlNamespaceManager(pdoc.NameTable);
nameMgr.AddNamespace(@"mb", @"http://schemas.microsoft.com/developer/msbuild/2003");
const string xpath = @"/mb:Project/mb:ItemGroup/mb:EmbeddedResource/@Include";
var resNodes = pdoc.SelectNodes(xpath, nameMgr);
var filePaths = new List<ZlpFileInfo>(); //get all files
if (resNodes != null)
{
// ReSharper disable LoopCanBeConvertedToQuery
foreach (XmlNode node in resNodes)
// ReSharper restore LoopCanBeConvertedToQuery
{
var include = node.Value;
if (!string.IsNullOrEmpty(include) &&
(include.ToLowerInvariant().EndsWith(@".resx")||
include.ToLowerInvariant().EndsWith(@".resw")))
{
var fullPath = ZlpPathHelper.Combine(vsProjectPath.DirectoryName, include);
filePaths.Add(new ZlpFileInfo(fullPath));
}
}
}
//add all files from list
DoAutomaticallyAddResourceFilesFromList(
backgroundWorker,
parentProjectFolder,
ref fileGroupCount,
ref fileCount,
filePaths);
}
}
}
/// <summary>
/// Открыть файл
/// </summary>
/// <param name="filePath"></param>
/// <param name="searchItemInSolution"></param>
/// <param name="projFolder"></param>
public Schematix.Windows.SchematixBaseWindow OpenNewWindow(string filePath, bool searchItemInSolution = true, ProjectFolder projFolder = null)
{
ProjectElementBase elem = null;
//Ищем в решении файл (если необходимо)
if (searchItemInSolution == true)
{
elem = SearchItemInSolution(filePath);
}
//Если файл не нашелся, создаем объект ProjectElementBase вручную
if (elem == null)
{
elem = ProjectElementBase.CreateProjectElementByPath(filePath, projFolder);
}
return(OpenNewWindow(elem));
}
public bool Execute(ProjectFolder folder)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Открыть файл с исходным кодом и поставить курсор в нужную позицию
/// </summary>
/// <param name="filePath"></param>
/// <param name="searchItemInSolution"></param>
/// <param name="projFolder"></param>
/// <param name="LineNumber"></param>
public Schematix.Windows.Code.Code OpenSource(string filePath, bool searchItemInSolution = true, ProjectFolder projFolder = null, int LineNumber = 0, int position = 0)
{
ProjectElementBase elem = null;
//Ищем в решении файл (если необходимо)
if (searchItemInSolution == true)
{
elem = SearchItemInSolution(filePath);
}
//Если файл не нашелся, создаем объект ProjectElementBase вручную
if (elem == null)
{
elem = ProjectElementBase.CreateProjectElementByPath(filePath, projFolder);
}
Schematix.Windows.SchematixBaseWindow window = null;
Schematix.Windows.Code.Code codeWindow = null;
mainWindow.Dispatcher.Invoke(
System.Windows.Threading.DispatcherPriority.Background, new System.Windows.Threading.DispatcherOperationCallback(delegate
{
window = OpenNewWindow(elem);
codeWindow = window as Schematix.Windows.Code.Code;
if (LineNumber >= 0)
{
codeWindow.textEditor.Loaded += new System.Windows.RoutedEventHandler(delegate { codeWindow.SetPosition(LineNumber, position); });
}
if (codeWindow.ProjectElement.Parent == null)
{
codeWindow.textEditor.IsReadOnly = true;
}
return(null);
}
), null);
return(codeWindow);
}
public TreeViewProjectFolders(TreeNode treeNode, ProjectFolder productFolder)
{
this.treeNode = treeNode;
this.productFolder = productFolder;
this.productFolder.LinkReference = treeNode;
}
private ProjectFolder BrowserProductFolder(ProjectFolder projectFolder, object linkReference)
{
ProjectFolder resultProductFolder = null;
if (object.ReferenceEquals(projectFolder.LinkReference, linkReference))
{
return projectFolder;
}
foreach (ProjectFolder pf in (IEnumerable<ProjectFolder>)projectFolder)
{
resultProductFolder = BrowserProductFolder(pf, linkReference);
if (resultProductFolder != null)
{
// Object found, exit
break;
}
}
return resultProductFolder;
}
public ListViewProjectFiles(ListView listView, ProjectFolder projectFolder)
{
this.listView = listView;
this.projectFolder = projectFolder;
}
private TreeListNode addProjectFolderToTree(
TreeListNode parentNode,
ProjectFolder projectFolder)
{
var projectFolderNode =
treeView.AppendNode(
new object[]
{
null
},
parentNode);
// --
updateProjectFolderInTree(
projectFolderNode,
projectFolder);
// --
foreach (var childProjectFolder in projectFolder.ChildProjectFolders)
{
addProjectFolderToTree(projectFolderNode, childProjectFolder);
}
foreach (var fileGroup in projectFolder.ChildFileGroups)
{
addFileGroupToTree(projectFolderNode, fileGroup);
}
// --
return projectFolderNode;
}
public bool IsValidTarget(ProjectFolder folder)
{
return folder.IsMvcViewsFolderOrDescendent() && GetCandidateFilesToConvert(folder).Count > 0;
}
public override void BuildNode(ITreeBuilder builder, object dataObject, NodeInfo nodeInfo)
{
if (!builder.Options["ShowVersionControlOverlays"])
{
return;
}
// Add status overlays
if (dataObject is IWorkspaceObject)
{
IWorkspaceObject ce = (IWorkspaceObject)dataObject;
Repository rep = VersionControlService.GetRepository(ce);
if (rep != null)
{
rep.GetDirectoryVersionInfo(ce.BaseDirectory, false, false);
AddFolderOverlay(rep, ce.BaseDirectory, nodeInfo, false);
}
return;
}
else if (dataObject is ProjectFolder)
{
ProjectFolder ce = (ProjectFolder)dataObject;
if (ce.ParentWorkspaceObject != null)
{
Repository rep = VersionControlService.GetRepository(ce.ParentWorkspaceObject);
if (rep != null)
{
rep.GetDirectoryVersionInfo(ce.Path, false, false);
AddFolderOverlay(rep, ce.Path, nodeInfo, true);
}
}
return;
}
IWorkspaceObject prj;
FilePath file;
if (dataObject is ProjectFile)
{
ProjectFile pfile = (ProjectFile)dataObject;
prj = pfile.Project;
file = pfile.FilePath;
}
else
{
SystemFile pfile = (SystemFile)dataObject;
prj = pfile.ParentWorkspaceObject;
file = pfile.Path;
}
if (prj == null)
{
return;
}
Repository repo = VersionControlService.GetRepository(prj);
if (repo == null)
{
return;
}
VersionInfo vi = repo.GetVersionInfo(file);
nodeInfo.OverlayBottomRight = VersionControlService.LoadOverlayIconForStatus(vi.Status);
}
public bool IsValidTarget(ProjectFolder folder)
{
return true;
}
public override void BuildNode(ITreeBuilder builder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
{
if (!builder.Options["ShowVersionControlOverlays"])
{
return;
}
// Add status overlays
if (dataObject is IWorkspaceObject)
{
IWorkspaceObject ce = (IWorkspaceObject)dataObject;
ClearDirCache(ce.BaseDirectory);
Repository rep = VersionControlService.GetRepository(ce);
if (rep != null)
{
AddFolderOverlay(rep, ce.BaseDirectory, ref icon, ref closedIcon);
}
return;
}
else if (dataObject is ProjectFolder)
{
ProjectFolder ce = (ProjectFolder)dataObject;
if (ce.ParentWorkspaceObject != null)
{
ClearDirCache(ce.Path);
Repository rep = VersionControlService.GetRepository(ce.ParentWorkspaceObject);
if (rep != null)
{
AddFolderOverlay(rep, ce.Path, ref icon, ref closedIcon);
}
}
return;
}
IWorkspaceObject prj;
FilePath file;
if (dataObject is ProjectFile)
{
ProjectFile pfile = (ProjectFile)dataObject;
prj = pfile.Project;
file = pfile.FilePath;
}
else
{
SystemFile pfile = (SystemFile)dataObject;
prj = pfile.ParentWorkspaceObject;
file = pfile.Path;
}
if (prj == null)
{
return;
}
Repository repo = VersionControlService.GetRepository(prj);
if (repo == null)
{
return;
}
VersionInfo vi = GetVersionInfo(repo, file);
if (dataObject is ProjectFile)
{
((ProjectFile)dataObject).ExtendedProperties [typeof(VersionInfo)] = vi;
}
Gdk.Pixbuf overlay = VersionControlService.LoadOverlayIconForStatus(vi.Status);
if (overlay != null)
{
AddOverlay(ref icon, overlay);
}
}
public ViewMobilizerModel(ProjectFolder folder)
: this(folder, "mobile")
{
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Compare this ProjectId to another ProjectId return true if they point to the same
/// local project, but ignoring the file extension (because one of the projects is
/// expected to be a newly restored XML project).
/// For example c:\TestLangProj.fwdata and c:\TestLangProj.fwdb would be equal.
/// </summary>
/// <param name="otherProjectId">The other project id.</param>
/// ------------------------------------------------------------------------------------
public bool IsSameLocalProject(ProjectId otherProjectId)
{
return(ProjectFolder.Equals(otherProjectId.ProjectFolder, StringComparison.InvariantCultureIgnoreCase) &&
ProjectInfo.ProjectsAreSame(Name, otherProjectId.Name));
}
private void updateProjectFolderInTree(
TreeListNode projectFolderNode,
ProjectFolder projectFolder)
{
projectFolderNode[0] = projectFolder.Name;
projectFolderNode.ImageIndex = projectFolderNode.SelectImageIndex = getImageIndex(@"projectfolder");
projectFolderNode.Tag = projectFolder;
projectFolderNode.StateImageIndex = (int)FileGroupStateColor.Grey; // (int)projectFolder.TranslationStateColor;
updateNodeStateImage(projectFolderNode, AsynchronousMode.Asynchronous);
}
private void doAutomaticallyAddResourceFilesFromVSSolution(
BackgroundWorker backgroundWorker,
ProjectFolder parentProjectFolder,
ref int fileGroupCount,
ref int fileCount,
ZlpFileInfo vsSolutionPath)
{
if (vsSolutionPath != null && vsSolutionPath.Exists)
{
string solutionText;
//using (var sr = vsSolutionPath.OpenText())
{
//we can read it line by line to reduce memory usage, but solution files are not very big
solutionText = ZlpIOHelper.ReadAllText(vsSolutionPath.FullName);// sr.ReadToEnd();
}
//solution files looks like:
//Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZetaResourceEditor", "Main\ZetaResourceEditor.csproj", "{367758E7-0435-440A-AC76-1F30ABBA3ED8}"
//EndProject
//known projectTypes:
//c#: FAE04EC0-301F-11D3-BF4B-00C04F79EFBC, VB: F184B08F-C81C-45F6-A57F-5ABD9991F28F
//@see http://msdn.microsoft.com/en-us/library/hb23x61k%28VS.80%29.aspx
//TODO: support virtual folders
var supportedProjectTypes =
new[]
{
@"FAE04EC0-301F-11D3-BF4B-00C04F79EFBC",
@"F184B08F-C81C-45F6-A57F-5ABD9991F28F"
};
//we need some regular expression to find required info:
const string pattern =
@"Project\(""{(?<projectType>[^}]*)}""\)\s*=\s*""(?<projectName>[^""]*)"",\s*""(?<projectRelPath>[^""]*)"",\s*""{(?<projectID>[^}]*)}""";
foreach (Match m in Regex.Matches(solutionText, pattern))
{
if (!m.Success)
{
continue;
}
var g = m.Groups[@"projectType"];
if (g == null || !g.Success)
{
continue;
}
var projectType = g.Value;
//compare with known project types.
// Currently only CS Projects are supported.
// But other types like VB can be simply added.
if (!Array.Exists(supportedProjectTypes, a => a == projectType))
{
continue;
}
var projectRelPath = m.Groups[@"projectRelPath"].Value;
var projectFile = new ZlpFileInfo(ZlpPathHelper.Combine(vsSolutionPath.Directory.FullName, projectRelPath));
//add all files from project
//we can add each using separate sub folder
var projectName = m.Groups[@"projectName"].Value;
//look in subfolders only
var subFolders = Project.ProjectFolders;
if (parentProjectFolder != null)
{
subFolders = parentProjectFolder.ChildProjectFolders;
}
var pf = subFolders.Find(f => f.Name == projectName);
if (pf == null)
{
pf =
new ProjectFolder(Project)
{
Name = projectName,
Parent = parentProjectFolder
};
Project.ProjectFolders.Add(pf);
}
Project.MarkAsModified();
DoAutomaticallyAddResourceFilesFromVsProject(
backgroundWorker,
pf,
ref fileGroupCount,
ref fileCount,
projectFile);
}
}
}
private void UpdateSolution(ITaskItem solutionRootItem)
{
string solutionRootPath = Path.GetFullPath(solutionRootItem.ItemSpec);
string projectExclude = solutionRootItem.GetMetadata("ExcludePattern");
List <ProjectFolder> projectFolders = new List <ProjectFolder>();
if (!solutionRootPath.EndsWith(Path.DirectorySeparatorChar.ToString()))
{
solutionRootPath += Path.DirectorySeparatorChar;
}
ProjectFolder testFolder = new ProjectFolder(solutionRootPath, "tests", "{1A2F9F4A-A032-433E-B914-ADD5992BB178}", projectExclude, true);
if (testFolder.FolderExists)
{
projectFolders.Add(testFolder);
}
ProjectFolder srcFolder = new ProjectFolder(solutionRootPath, "src", "{E107E9C1-E893-4E87-987E-04EF0DCEAEFD}", projectExclude);
if (srcFolder.FolderExists)
{
testFolder.DependsOn.Add(srcFolder);
projectFolders.Add(srcFolder);
}
;
ProjectFolder refFolder = new ProjectFolder(solutionRootPath, "ref", "{2E666815-2EDB-464B-9DF6-380BF4789AD4}", projectExclude);
if (refFolder.FolderExists)
{
srcFolder.DependsOn.Add(refFolder);
projectFolders.Add(refFolder);
}
if (projectFolders.Count == 0)
{
Log.LogMessage($"Directory '{solutionRootPath}' does not contain a 'src', 'tests', or 'ref' directory so skipping solution generation.");
return;
}
Log.LogMessage($"Generating solution for '{solutionRootPath}'...");
string solutionName = GetNameForSolution(solutionRootPath);
string slnFile = Path.Combine(solutionRootPath, solutionName + ".sln");
Solution solution = new Solution(slnFile);
StringBuilder slnBuilder = new StringBuilder();
slnBuilder.AppendLine("Microsoft Visual Studio Solution File, Format Version 12.00");
slnBuilder.AppendLine("# Visual Studio 15");
slnBuilder.AppendLine("VisualStudioVersion = 15.0.27213.1");
slnBuilder.AppendLine("MinimumVisualStudioVersion = 10.0.40219.1");
// Output project items
foreach (var projectFolder in projectFolders)
{
foreach (var slnProject in projectFolder.Projects)
{
string projectName = Path.GetFileNameWithoutExtension(slnProject.ProjectPath);
// Normalize the directory separators to the windows version given these are projects for VS and only work on windows.
string relativePathFromCurrentDirectory = slnProject.ProjectPath.Replace(solutionRootPath, "").Replace("/", "\\");
slnBuilder.AppendLine($"Project(\"{slnProject.SolutionGuid}\") = \"{projectName}\", \"{relativePathFromCurrentDirectory}\", \"{slnProject.ProjectGuid}\"");
bool writeEndProjectSection = false;
foreach (var dependentFolder in projectFolder.DependsOn)
{
foreach (var depProject in dependentFolder.Projects)
{
string depProjectId = depProject.ProjectGuid;
slnBuilder.AppendLine(
$"\tProjectSection(ProjectDependencies) = postProject\r\n\t\t{depProjectId} = {depProjectId}");
writeEndProjectSection = true;
}
}
if (writeEndProjectSection)
{
slnBuilder.AppendLine("\tEndProjectSection");
}
slnBuilder.AppendLine("EndProject");
}
}
// Output the solution folder items
foreach (var projectFolder in projectFolders)
{
slnBuilder.AppendLine($"Project(\"{projectFolder.SolutionGuid}\") = \"{projectFolder.Name}\", \"{projectFolder.Name}\", \"{projectFolder.ProjectGuid}\"\r\nEndProject");
}
string anyCPU = "Any CPU";
string slnDebug = "Debug|" + anyCPU;
string slnRelease = "Release|" + anyCPU;
// Output the solution configurations
slnBuilder.AppendLine("Global");
slnBuilder.AppendLine("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution");
slnBuilder.AppendLine($"\t\t{slnDebug} = {slnDebug}");
slnBuilder.AppendLine($"\t\t{slnRelease} = {slnRelease}");
slnBuilder.AppendLine("\tEndGlobalSection");
slnBuilder.AppendLine("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution");
// Output the solution to project configuration mappings
foreach (var projectFolder in projectFolders)
{
foreach (var slnProject in projectFolder.Projects)
{
string projectConfig = slnProject.GetBestConfiguration("netcoreapp-Windows_NT");
if (!string.IsNullOrEmpty(projectConfig))
{
projectConfig += "-";
}
string[] slnConfigs = new string[] { slnDebug, slnRelease };
string[] markers = new string[] { "ActiveCfg", "Build.0" };
foreach (string slnConfig in slnConfigs)
{
foreach (string marker in markers)
{
slnBuilder.AppendLine($"\t\t{slnProject.ProjectGuid}.{slnConfig}.{marker} = {projectConfig}{slnConfig}");
}
}
}
}
slnBuilder.AppendLine("\tEndGlobalSection");
slnBuilder.AppendLine("\tGlobalSection(SolutionProperties) = preSolution");
slnBuilder.AppendLine("\t\tHideSolutionNode = FALSE");
slnBuilder.AppendLine("\tEndGlobalSection");
// Output the project to solution folder mappings
slnBuilder.AppendLine("\tGlobalSection(NestedProjects) = preSolution");
foreach (var projectFolder in projectFolders)
{
foreach (var slnProject in projectFolder.Projects)
{
slnBuilder.AppendLine($"\t\t{slnProject.ProjectGuid} = {projectFolder.ProjectGuid}");
}
}
slnBuilder.AppendLine("\tEndGlobalSection");
// Output the extensibility globals
slnBuilder.AppendLine("\tGlobalSection(ExtensibilityGlobals) = postSolution");
slnBuilder.AppendLine($"\t\tSolutionGuid = {solution.Guid}");
slnBuilder.AppendLine("\tEndGlobalSection");
slnBuilder.AppendLine("EndGlobal");
File.WriteAllText(slnFile, slnBuilder.ToString());
}
private static void ParseFolder(ProjectFolder folder, string dir, List <string> skippedBlocksList)
{
//Directory.CreateDirectory(dir);
var path = Path.Combine(dir, NormalizeFolderName(folder.Name));
foreach (var projectFolder in folder.SubItems)
{
ParseFolder(projectFolder, path, skippedBlocksList);
}
if (folder is IBlocksFolder)
{
var blkFld = folder as IBlocksFolder;
foreach (var projectBlockInfo in blkFld.BlockInfos)
{
try
{
var src = projectBlockInfo.Export(ExportFormat.Default);
string xml = null;
if (src != null)
{
if (!removeNoBlanks)
{
/*var startIndex = src.IndexOf(" VAR ");
* var endIndex = src.IndexOf(" END_VAR", startIndex);*/
var startIndex = 0;
var endIndex = src.IndexOf("BEGIN", startIndex);
if (endIndex == -1)
{
endIndex = src.IndexOf("END_TYPE", startIndex);
}
if (endIndex != -1)
{
var search = src;
var pattern = " // ";
var indexes = Enumerable.Range(startIndex, endIndex - startIndex)
.Select(index =>
{
return(new
{
Index = index,
Length = index + pattern.Length > search.Length
? search.Length - index
: pattern.Length
});
})
.Where(searchbit =>
searchbit.Length == pattern.Length && pattern.Equals(
search.Substring(searchbit.Index, searchbit.Length),
StringComparison.OrdinalIgnoreCase))
.Select(searchbit => searchbit.Index);
var updatedSrc = src;
foreach (var x in indexes.Reverse())
{
if (removeOnlyOneBlank)
{
updatedSrc = updatedSrc.Remove(x + 5, 1);
}
else if (removeAllBlanks)
{
while (updatedSrc[x + 5].ToString() == " ")
{
updatedSrc = updatedSrc.Remove(x + 5, 1);
}
}
}
src = updatedSrc;
}
}
var ext = "xml";
if (projectBlockInfo.BlockLanguage == PLCLanguage.DB && projectBlockInfo.BlockType == PLCBlockType.DB)
{
ext = "db";
xml = projectBlockInfo.Export(ExportFormat.Xml);
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.SCL)
{
ext = "scl";
xml = projectBlockInfo.Export(ExportFormat.Xml);
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.KOP)
{
ext = "xml";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.FUP)
{
ext = "xml";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.AWL)
{
ext = "awl";
xml = projectBlockInfo.Export(ExportFormat.Xml);
}
else if (projectBlockInfo.BlockType == PLCBlockType.UDT)
{
ext = "udt";
}
var file = Path.Combine(path, projectBlockInfo.Name.Replace("\\", "_").Replace("/", "_") + "." + ext);
var xmlfile = Path.Combine(path, projectBlockInfo.Name.Replace("\\", "_").Replace("/", "_") + ".xml");
var xmlValid = false;
XmlDocument xmlDoc = new XmlDocument();
try
{
xmlDoc.LoadXml(src);
xmlValid = true;
}
catch
{
xmlValid = false;
}
if (xmlValid)
{
try
{
var nodes = xmlDoc.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc.Save(writer);
}
src = sb.ToString();
}
if (src != null && ext != "db")
{
Directory.CreateDirectory(path);
File.WriteAllText(file, src, new UTF8Encoding(true));
}
if (xml != null)
{
var xmlValid2 = false;
XmlDocument xmlDoc2 = new XmlDocument();
try
{
xmlDoc2.LoadXml(xml);
xmlValid2 = true;
}
catch
{
xmlValid2 = false;
}
if (xmlValid2)
{
if (!removeNoBlanks)
{
try
{
XmlNodeList nodes = xmlDoc2.GetElementsByTagName("MultiLanguageText");
var pattern = "^( *)(.*)";
foreach (var n in nodes.Cast <XmlNode>())
{
if (removeOnlyOneBlank)
{
n.InnerText = Regex.Replace(n.InnerText, pattern, m => m.Groups[1].Value.Substring(0, m.Groups[1].Value.Length - 1) + m.Groups[2].Value);
}
else if (removeAllBlanks)
{
n.InnerXml = Regex.Replace(n.InnerXml, pattern, m => "" + m.Groups[2].Value);
}
}
}
catch
{ }
}
try
{
var nodes = xmlDoc2.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{ }
try
{
var nodes = xmlDoc2.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{ }
if (removeCodeFromXml && !xml.Contains("$$GITHANDLER-KEEPCODE$$"))
{
try
{
var nodes = xmlDoc2.SelectNodes("//SW.Blocks.CompileUnit");
var node = nodes[0];
node.InnerXml = "";
var parent = node.ParentNode;
foreach (var nd in nodes.Cast <XmlNode>().Skip(1).ToList())
{
parent.RemoveChild(nd);
}
}
catch
{ }
}
try
{
var nodes = xmlDoc2.SelectNodes("//MultilingualText");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{ }
try
{
var nodes = xmlDoc2.SelectNodes("//MultilingualText");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{ }
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc2.Save(writer);
}
xml = sb.ToString();
if (_projectType == ProjectType.Tia14SP1)
{
xml = xml.Replace("<ProgrammingLanguage>SCL</ProgrammingLanguage>", "<ProgrammingLanguage>STL</ProgrammingLanguage>");
}
}
Directory.CreateDirectory(path);
File.WriteAllText(xmlfile, xml, new UTF8Encoding(true));
}
}
else
{
Console.WriteLine("Skipping Block (null)" + projectBlockInfo.Name);
}
}
catch (Exception ex)
{
Console.WriteLine("Skipping Block: \"" + projectBlockInfo.Name + "\" Exception: " + ex.Message);
skippedBlocksList.Add(projectBlockInfo.Name);
}
}
}
}
private static void ParseFolder(ProjectFolder folder, string dir, List <string> skippedBlocksList)
{
//Directory.CreateDirectory(dir);
var path = Path.Combine(dir, NormalizeFolderName(folder.Name));
foreach (var projectFolder in folder.SubItems)
{
ParseFolder(projectFolder, path, skippedBlocksList);
}
if (folder is IBlocksFolder)
{
var blkFld = folder as IBlocksFolder;
foreach (var projectBlockInfo in blkFld.BlockInfos.ToList())
{
try
{
var src = projectBlockInfo.Export(ExportFormat.Default);
string xml = null;
if (src != null)
{
if (!removeNoBlanks)
{
/*var startIndex = src.IndexOf(" VAR ");
* var endIndex = src.IndexOf(" END_VAR", startIndex);*/
var startIndex = 0;
var endIndex = src.IndexOf("BEGIN", startIndex);
if (endIndex == -1)
{
endIndex = src.IndexOf("END_TYPE", startIndex);
}
if (endIndex != -1)
{
var search = src;
var pattern = " // ";
var indexes = Enumerable.Range(startIndex, endIndex - startIndex)
.Select(index =>
{
return(new
{
Index = index,
Length = index + pattern.Length > search.Length
? search.Length - index
: pattern.Length
});
})
.Where(searchbit =>
searchbit.Length == pattern.Length && pattern.Equals(
search.Substring(searchbit.Index, searchbit.Length),
StringComparison.OrdinalIgnoreCase))
.Select(searchbit => searchbit.Index);
var updatedSrc = src;
foreach (var x in indexes.Reverse())
{
if (removeOnlyOneBlank)
{
updatedSrc = updatedSrc.Remove(x + 5, 1);
}
else if (removeAllBlanks)
{
while (updatedSrc[x + 5].ToString() == " ")
{
updatedSrc = updatedSrc.Remove(x + 5, 1);
}
}
}
src = updatedSrc;
}
}
var ext = "xml";
if (projectBlockInfo.BlockLanguage == PLCLanguage.DB && projectBlockInfo.BlockType == PLCBlockType.DB)
{
ext = "db";
xml = projectBlockInfo.Export(ExportFormat.Xml);
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.SCL)
{
ext = "scl";
xml = projectBlockInfo.Export(ExportFormat.Xml);
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.KOP)
{
ext = "xml";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.FUP)
{
ext = "xml";
}
else if (projectBlockInfo.BlockLanguage == PLCLanguage.AWL)
{
ext = "awl";
xml = projectBlockInfo.Export(ExportFormat.Xml);
}
else if (projectBlockInfo.BlockType == PLCBlockType.UDT)
{
ext = "udt";
xml = projectBlockInfo.Export(ExportFormat.Xml);
}
var file = Path.Combine(path, projectBlockInfo.Name.Replace("\\", "_").Replace("/", "_") + "." + ext);
var xmlfile = Path.Combine(path, projectBlockInfo.Name.Replace("\\", "_").Replace("/", "_") + ".xml");
var xmlValid = false;
XmlDocument xmlDoc = new XmlDocument();
XmlNamespaceManager ns = new XmlNamespaceManager(xmlDoc.NameTable);
ns.AddNamespace("smns", "http://www.siemens.com/automation/Openness/SW/NetworkSource/FlgNet/v3");
ns.AddNamespace("smns2", "http://www.siemens.com/automation/Openness/SW/Interface/v3");
try
{
xmlDoc.LoadXml(src);
xmlValid = true;
}
catch
{
xmlValid = false;
}
if (xmlValid)
{
try
{
var nodes = xmlDoc.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//CodeModifiedDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//CompileDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//CreationDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//InterfaceModifiedDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//ModifiedDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//ParameterModified");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//StructureModified");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//smns:DateAttribute[@Name='ParameterModifiedTS']", ns);
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
//try
//{
// var nodes = xmlDoc.SelectNodes("//smns:Address[@Area='None' and @Informative='true']", ns);
// foreach (var node in nodes.Cast<XmlNode>())
// {
// node.ParentNode.RemoveChild(node);
// }
//}
//catch
//{
//}
//try
//{
// var nodes = xmlDoc.SelectNodes("//smns2:IntegerAttribute[@Name='Offset' and @Informative='true']", ns);
// foreach (var node in nodes.Cast<XmlNode>())
// {
// node.ParentNode.RemoveChild(node);
// }
//}
//catch
//{
//}
try
{
var nodes = xmlDoc.SelectNodes("//*[@Informative='true']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//*[local-name()='InstanceOfNumber']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//*[local-name()='LibraryConformanceStatus']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//*[local-name()='Member'][contains(@Datatype,'\"')]//*[local-name()='Sections']");
foreach (var node in nodes.Cast <XmlNode>())
{
if (!node.OuterXml.Contains("Remanence=\"Retain\"") && !node.OuterXml.Contains("StartValue"))
{
node.ParentNode.RemoveChild(node);
}
}
}
catch
{
}
if (resetSetpoints)
{
try
{
var nodes = xmlDoc.SelectNodes("//smns2:BooleanAttribute[@Name='SetPoint']", ns);
foreach (var node in nodes.Cast <XmlNode>())
{
node.InnerText = "false";
}
}
catch
{
}
}
try
{
var nodes = xmlDoc.SelectNodes("//*[@ReadOnly='true']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc.Save(writer);
}
src = sb.ToString();
}
if (src != null && ext != "db")
{
Directory.CreateDirectory(path);
File.WriteAllText(file, src, new UTF8Encoding(true));
}
if (xml != null)
{
var xmlValid2 = false;
XmlDocument xmlDoc2 = new XmlDocument();
XmlNamespaceManager ns2 = new XmlNamespaceManager(xmlDoc2.NameTable);
ns2.AddNamespace("smns", "http://www.siemens.com/automation/Openness/SW/NetworkSource/FlgNet/v3");
ns2.AddNamespace("smns2", "http://www.siemens.com/automation/Openness/SW/Interface/v3");
try
{
xmlDoc2.LoadXml(xml);
xmlValid2 = true;
}
catch
{
xmlValid2 = false;
}
if (xmlValid2)
{
if (!removeNoBlanks)
{
try
{
XmlNodeList nodes = xmlDoc2.GetElementsByTagName("MultiLanguageText");
var pattern = "^( *)(.*)";
foreach (var n in nodes.Cast <XmlNode>())
{
if (removeOnlyOneBlank)
{
n.InnerText = Regex.Replace(n.InnerText, pattern, m => m.Groups[1].Value.Substring(0, m.Groups[1].Value.Length - 1) + m.Groups[2].Value);
}
else if (removeAllBlanks)
{
n.InnerXml = Regex.Replace(n.InnerXml, pattern, m => "" + m.Groups[2].Value);
}
}
}
catch
{ }
}
try
{
var nodes = xmlDoc2.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{ }
try
{
var nodes = xmlDoc2.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{ }
try
{
var nodes = xmlDoc2.SelectNodes("//CodeModifiedDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//CompileDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//CreationDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//InterfaceModifiedDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//ModifiedDate");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//ParameterModified");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//StructureModified");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
if (removeCodeFromXml && !xml.Contains("$$GITHANDLER-KEEPCODE$$"))
{
try
{
var nodes = xmlDoc2.SelectNodes("//SW.Blocks.CompileUnit");
var node = nodes[0];
node.InnerXml = "";
var parent = node.ParentNode;
foreach (var nd in nodes.Cast <XmlNode>().Skip(1).ToList())
{
parent.RemoveChild(nd);
}
}
catch
{ }
}
try
{
var nodes = xmlDoc2.SelectNodes("//smns:DateAttribute[@Name='ParameterModifiedTS']", ns2);
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//*[@Informative='true']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//*[local-name()='LibraryConformanceStatus']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
if (projectBlockInfo.BlockLanguage == PLCLanguage.DB && projectBlockInfo.BlockType == PLCBlockType.DB && projectBlockInfo.IsInstance)
{
try
{
var nodes = xmlDoc2.SelectNodes("//*[local-name()='Interface']/*[local-name()='Sections']/*[local-name()='Section']/*[local-name()='Member']");
foreach (var node in nodes.Cast <XmlNode>())
{
if (!node.OuterXml.Contains("Remanence=\"Retain\"") && !node.OuterXml.Contains("StartValue"))
{
node.ParentNode.RemoveChild(node);
}
}
}
catch
{
}
try
{
var nodes = xmlDoc2.SelectNodes("//*[local-name()='InstanceOfNumber']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
}
if (resetSetpoints)
{
try
{
var nodes = xmlDoc2.SelectNodes("//smns2:BooleanAttribute[@Name='SetPoint']", ns2);
foreach (var node in nodes.Cast <XmlNode>())
{
node.InnerText = "false";
}
}
catch
{
}
}
if (projectBlockInfo.BlockTypeString == "Userdatatype" || projectBlockInfo.BlockTypeString == "Functionblock")
{
try
{
var nodes = xmlDoc2.SelectNodes("//*[local-name()='Member'][contains(@Datatype,'\"')]//*[local-name()='Sections']");
foreach (var node in nodes.Cast <XmlNode>())
{
if (!node.OuterXml.Contains("Remanence=\"Retain\"") && !node.OuterXml.Contains("StartValue"))
{
node.ParentNode.RemoveChild(node);
}
}
}
catch
{
}
}
try
{
var nodes = xmlDoc2.SelectNodes("//*[@ReadOnly='true']");
foreach (var node in nodes.Cast <XmlNode>())
{
node.ParentNode.RemoveChild(node);
}
}
catch
{
}
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc2.Save(writer);
}
xml = sb.ToString();
if (_projectType == ProjectType.Tia14SP1)
{
xml = xml.Replace("<ProgrammingLanguage>SCL</ProgrammingLanguage>", "<ProgrammingLanguage>STL</ProgrammingLanguage>");
}
}
Directory.CreateDirectory(path);
File.WriteAllText(xmlfile, xml, new UTF8Encoding(true));
}
}
else
{
Console.WriteLine("Skipping Block (null)" + projectBlockInfo.Name);
}
}
catch (Exception ex)
{
Console.WriteLine("Skipping Block: \"" + projectBlockInfo.Name + "\" Exception: " + ex.Message);
skippedBlocksList.Add(projectBlockInfo.Name);
}
}
}
else if (folder is ITIAVarTabFolder varTabfld)
{
foreach (var varTab in varTabfld.TagTables)
{
var xmlValid = false;
string xml = null;
XmlDocument xmlDoc = new XmlDocument();
var file = Path.Combine(path, varTab.Name.Replace("\\", "_").Replace("/", "_") + ".xml");
try
{
var vt = varTab.Export();
try
{
xmlDoc.LoadXml(vt);
xmlValid = true;
}
catch
{
xmlValid = false;
}
if (xmlValid)
{
try
{
var nodes = xmlDoc.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
}
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc.Save(writer);
}
xml = sb.ToString();
Directory.CreateDirectory(path);
File.WriteAllText(file, xml, new UTF8Encoding(true));
}
catch
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(file + " could not be exported");
Console.ForegroundColor = ConsoleColor.White;
}
}
}
else if (folder is ITIAWatchAndForceTablesFolder wtfFld)
{
foreach (var varTab in wtfFld.WatchTables)
{
var xmlValid = false;
string xml = null;
XmlDocument xmlDoc = new XmlDocument();
var file = Path.Combine(path, varTab.Name.Replace("\\", "_").Replace("/", "_") + ".watch");
try
{
var vt = varTab.Export();
try
{
xmlDoc.LoadXml(vt);
xmlValid = true;
}
catch
{
xmlValid = false;
}
if (xmlValid)
{
try
{
var nodes = xmlDoc.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
}
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc.Save(writer);
}
xml = sb.ToString();
Directory.CreateDirectory(path);
File.WriteAllText(file, xml, new UTF8Encoding(true));
}
catch
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(file + " could not be exported");
Console.ForegroundColor = ConsoleColor.White;
}
}
foreach (var varTab in wtfFld.ForceTables)
{
var xmlValid = false;
string xml = null;
XmlDocument xmlDoc = new XmlDocument();
var file = Path.Combine(path, varTab.Name.Replace("\\", "_").Replace("/", "_") + ".force");
try
{
var vt = varTab.Export();
try
{
xmlDoc.LoadXml(vt);
xmlValid = true;
}
catch
{
xmlValid = false;
}
if (xmlValid)
{
try
{
var nodes = xmlDoc.SelectNodes("//Created");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
try
{
var nodes = xmlDoc.SelectNodes("//DocumentInfo");
var node = nodes[0];
node.ParentNode.RemoveChild(node);
}
catch
{
}
}
StringBuilder sb = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
using (TextWriter writer = new EncodingStringWriter(sb, Encoding.UTF8))
{
xmlDoc.Save(writer);
}
xml = sb.ToString();
Directory.CreateDirectory(path);
File.WriteAllText(file, xml, new UTF8Encoding(true));
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(file + " could not be exported");
Console.ForegroundColor = ConsoleColor.White;
}
}
}
}
public ProjectTreeModel(ProjectFolder rootFolder)
{
_rootFolder = rootFolder;
}
