private void LoadNonCachedDependencies(DirectoryTreeNode directoryNode, string url, Dictionary <string, string> urls)
{
foreach (string name in urls.Keys)
{
string curUrl = string.Format("{0}/{1}", url, name);
if (!Application.ReferencesCache.ContainsKey(urls[name]))
{
Application.ReferencesCache.Append(urls[name], false, false);
}
Info info = SVNManager.Instance.Info(curUrl);
CacheInfo cacheInfo = Application.ReferencesCache[curUrl];
string lastRevision = SVNManager.Instance.LastRevision(curUrl);
if (!lastRevision.Equals(cacheInfo.LastRevision))
{
Application.ReferencesCache[curUrl].LastRevision = info.Entry.Revision;
Application.ReferencesCache.Save();
}
this.LoadNonCachedDependency(directoryNode, info, name, curUrl);
}
}
private void InitGGPK()
{
if (content != null)
{
return;
}
string ggpkPath = textBoxContentGGPK.Text;
if (!File.Exists(ggpkPath))
{
OutputLine(string.Format("GGPK {0} not exists.", ggpkPath));
return;
}
OutputLine(string.Format("Parsing {0}", ggpkPath));
content = new GGPK();
content.Read(ggpkPath, Output);
RecordsByPath = new Dictionary <string, FileRecord>(content.RecordOffsets.Count);
DirectoryTreeNode.TraverseTreePostorder(content.DirectoryRoot, null, n => RecordsByPath.Add(n.GetDirectoryPath() + n.Name, n as FileRecord));
textBoxContentGGPK.Enabled = false;
buttonSelectPOE.Enabled = false;
CreateExampleRegistryFile(ggpkPath);
}
private void treeView1_BeforeExpand(object sender, RoutedEventArgs e)
{
if (_suppressEventHandling)
{
return;
}
DirectoryTreeNode node = sender as DirectoryTreeNode;
if (node == null)
{
return;
}
_suppressEventHandling = true;
try
{
UpdateNodeChildren(node);
node.IsSelected = true;
}
finally
{
_suppressEventHandling = false;
}
e.Handled = true;
}
private TreeViewItem FindNode(TreeViewItem parentNode, ItemCollection nodes, string directory, int attemptNumber = 1)
{
if (attemptNumber < 1)
{
throw new ArgumentOutOfRangeException("attemptNumber", attemptNumber, "attemptNumber must be >= 1");
}
if (attemptNumber > 2)
{
return(parentNode);
}
List <TreeViewItem> childNodes = new List <TreeViewItem>();
foreach (TreeViewItem childNode in nodes)
{
childNodes.Add(childNode);
DirectoryTreeNode dirNode = childNode as DirectoryTreeNode;
if (dirNode == null)
{
continue;
}
if (string.Compare(dirNode.Directory, directory, true) == 0)
{
return(dirNode);
}
}
UpdateNodeChildren((DirectoryTreeNode)parentNode);
TreeViewItem node = FindNode(parentNode, parentNode.Items, directory, attemptNumber + 1);
return(node);
}
private void treeView1_BeforeCollapse(object sender, RoutedEventArgs e)
{
if (_suppressEventHandling)
{
return;
}
DirectoryTreeNode node = sender as DirectoryTreeNode;
if (node == null)
{
return;
}
_suppressEventHandling = true;
try
{
_viewModel.CurrentDirectory = node.Directory;
node.IsSelected = true;
node.IsExpanded = false;
}
finally
{
_suppressEventHandling = false;
}
}
private void LoadDirectories()
{
this.Cursor = Cursors.WaitCursor;
string url = string.Format("{0}/References", SVNManager.DEV_URL);
Dictionary <string, string> directories = SVNManager.Instance.List(url, false);
foreach (string name in directories.Keys)
{
Directory directory = new Directory(name);
directory.Url = string.Format("{0}/{1}/Current", url, name);
if (!Application.ReferencesCache.ContainsKey(directory.Url))
{
Info info = SVNManager.Instance.Info(directory.Url);
if (info != null)
{
Application.ReferencesCache.Append(directory.Url, false, false);
}
else
{
continue;
}
}
DirectoryTreeNode node = new DirectoryTreeNode(directory);
node.ImageIndex = 0;
node.SelectedImageIndex = 0;
this.tvDependencies.Nodes.Add(node);
}
this.Cursor = Cursors.Default;
}
/// <summary>
/// Creates a new content node.
/// </summary>
/// <param name="name">Name of the node.</param>
/// <param name="parent">Parent of the node.</param>
/// <param name="content">Content stored in the node.</param>
/// <param name="mutable">If <c>true</c>, node can be modified after creation.</param>
public ContentTreeNode(string name, DirectoryTreeNode <T> parent, T content, bool mutable = true)
: base(mutable)
{
Name = name;
Parent = parent;
Content = content;
}
/// <summary>
/// Recursivly adds the specified GGPK DirectoryTree to the TreeListView
/// </summary>
/// <param name="directoryTreeNode">Node to add to tree</param>
/// <param name="parentControl">TreeViewItem to add children to</param>
private void AddDirectoryTreeToControl(DirectoryTreeNode directoryTreeNode, ItemsControl parentControl)
{
TreeViewItem rootItem = new TreeViewItem {
Header = directoryTreeNode
};
if ((directoryTreeNode.ToString() == "ROOT") || (directoryTreeNode.ToString() == ""))
{
rootItem.IsExpanded = true;
}
if (parentControl == null)
{
treeView.Items.Add(rootItem);
}
else
{
parentControl.Items.Add(rootItem);
}
directoryTreeNode.Children.Sort();
foreach (var item in directoryTreeNode.Children)
{
AddDirectoryTreeToControl(item, rootItem);
}
directoryTreeNode.Files.Sort();
foreach (var item in directoryTreeNode.Files)
{
rootItem.Items.Add(item);
}
}
/// <summary>
/// Exports entire DirectoryTreeNode to disk, preserving directory structure
/// </summary>
/// <param name="selectedDirectoryNode">Node to export to disk</param>
private void ExportAllItemsInDirectory(DirectoryTreeNode selectedDirectoryNode)
{
List <FileRecord> recordsToExport = new List <FileRecord>();
Action <FileRecord> fileAction = recordsToExport.Add;
DirectoryTreeNode.TraverseTreePreorder(selectedDirectoryNode, null, fileAction);
try
{
SaveFileDialog saveFileDialog = new SaveFileDialog
{
FileName = Settings.Strings["ExportAllItemsInDirectory_Default_FileName"]
};
if (saveFileDialog.ShowDialog() != true)
{
return;
}
string exportDirectory = Path.GetDirectoryName(saveFileDialog.FileName) + Path.DirectorySeparatorChar;
foreach (var item in recordsToExport)
{
item.ExtractFileWithDirectoryStructure(ggpkPath, exportDirectory);
}
MessageBox.Show(string.Format(Settings.Strings["ExportAllItemsInDirectory_Successful"], recordsToExport.Count),
Settings.Strings["ExportAllItemsInDirectory_Successful_Caption"], MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception ex)
{
MessageBox.Show(string.Format(Settings.Strings["ExportAllItemsInDirectory_Failed"], ex.Message),
Settings.Strings["Error_Caption"], MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private static void ExportLanguageDataFile(string contentFilePath, DirectoryTreeNode dataDir, JsonWriter jsonWriter, string datFileName, Action <int, RecordData, JsonWriter> writeRecordData)
{
foreach (var language in Language.All)
{
// Determine the directory to search for the given datFile. English is the base/main language and isn't located in a sub-folder.
var searchDir = language == Language.English ? dataDir : dataDir.Children.FirstOrDefault(x => x.Name == language);
if (searchDir == null)
{
Logger.WriteLine($"\t{language} Language folder not found.");
continue;
}
// Find the given datFile.
var datContainer = GetDatContainer(searchDir, contentFilePath, datFileName);
if (datContainer == null)
{
// An error was already logged.
continue;
}
Logger.WriteLine($"\tExporting {datFileName} in {language}.");
// Create a node and write the data of each record in this node.
jsonWriter.WritePropertyName(language);
jsonWriter.WriteStartObject();
for (int j = 0, recordsLength = datContainer.Records.Count; j < recordsLength; j++)
{
writeRecordData(j, datContainer.Records[j], jsonWriter);
}
jsonWriter.WriteEndObject();
}
}
private DirectoryTreeNode RecursiveFind(TreeNodeCollection root, string path)
{
DirectoryTreeNode result = null;
foreach (TreeNode node in root)
{
if (node is DirectoryTreeNode)
{
DirectoryTreeNode dnode = node as DirectoryTreeNode;
if (string.Compare(dnode.LinuxPath, path, false) == 0)
{
return(dnode);
}
if (dnode.Nodes.Count > 0)
{
result = RecursiveFind(dnode.Nodes, path);
if (result != null)
{
return(result);
}
}
}
}
return(null);
}
public DirectoryTreeNode PopulateDirectoryTreeView(FileDirectory rd)
{
DirectoryTreeNode directoryTreeNode = new DirectoryTreeNode(rd);
directoryTreeNode.Name = rd.getPath();
directoryTreeNode.Text = rd.getPath();
foreach (FileDirectory current in rd.getChildren()){
this.PopulateDirectoryTreeViewForChildren(current, directoryTreeNode);
}
return directoryTreeNode;
}
/// <summary>
/// Reloads the entire content.ggpk, rebuilds the tree
/// </summary>
private void ReloadGGPK()
{
treeView1.Items.Clear();
ResetViewer();
textBoxOutput.Visibility = System.Windows.Visibility.Visible;
textBoxOutput.Text = string.Empty;
content = null;
workerThread = new Thread(new ThreadStart(() =>
{
content = new GGPK();
try
{
content.Read(ggpkPath, Output);
}
catch (Exception ex)
{
Output(string.Format(Settings.Strings["ReloadGGPK_Failed"], ex.Message));
return;
}
if (content.IsReadOnly)
{
Output(Settings.Strings["ReloadGGPK_ReadOnly"] + Environment.NewLine);
UpdateTitle(Settings.Strings["MainWindow_Title_Readonly"]);
}
OutputLine(Settings.Strings["ReloadGGPK_Traversing_Tree"]);
// Collect all FileRecordPath -> FileRecord pairs for easier replacing
RecordsByPath = new Dictionary <string, FileRecord>(content.RecordOffsets.Count);
DirectoryTreeNode.TraverseTreePostorder(content.DirectoryRoot, null, n => RecordsByPath.Add(n.GetDirectoryPath() + n.Name, n as FileRecord));
treeView1.Dispatcher.BeginInvoke(new Action(() =>
{
try
{
AddDirectoryTreeToControl(content.DirectoryRoot, null);
}
catch (Exception ex)
{
Output(string.Format(Settings.Strings["Error_Read_Directory_Tree"], ex.Message));
return;
}
workerThread = null;
}), null);
OutputLine(Settings.Strings["ReloadGGPK_Successful"]);
}));
workerThread.Start();
}
public void PopulateDirectoryTreeViewForChildren(FileDirectory rd, TreeNode root)
{
DirectoryTreeNode directoryTreeNode = new DirectoryTreeNode(rd);
directoryTreeNode.Text = rd.getPath();
directoryTreeNode.Name = rd.getPath();
root.Nodes.Add(directoryTreeNode);
foreach (FileDirectory current in rd.getChildren()) {
this.PopulateDirectoryTreeViewForChildren(current, directoryTreeNode);
}
}
public async void LoadFileTreeView()
{
btnSearch.Text = "Processing...";
btnSearch.Enabled = false;
pbxLoading.Visible = true;
tvFileSystem.Nodes.Clear();
cbxSortBy.Enabled = false;
lblSortArrow.Visible = false;
ShowHideDetailLabels(false);
if (dgvFiles.Rows.Count != 0)
{
dgvFiles.Rows.Clear();
}
string selectedDrive = cbxPartitionLetters.SelectedItem?.ToString();
// Creating root node object and getting his child nodes
DirectoryTreeNode rootNode = new DirectoryTreeNode(selectedDrive)
{
Tag = new DirectoryInfo(selectedDrive),
ImageKey = "harddisk.png",
SelectedImageKey = "harddisk.png"
};
var childs = await Task.Run(() => filesManipulation.GetDirectoryChildren(selectedDrive));
// Showing results and configurating some controls
if (childs.Error == null)
{
cbxSortBy.Enabled = true;
lblSortArrow.Visible = true;
tvFileSystem.BeginUpdate();
rootNode.Nodes.AddRange(childs.ChildNodes.ToArray());
tvFileSystem.Nodes.Add(rootNode);
tvFileSystem.Nodes[0].Expand();
tvFileSystem.EndUpdate();
if (!CheckIfIsCached(selectedDrive))
{
CacheData(selectedDrive);
}
}
else
{
MessageBox.Show("Error occured while trying to get files.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
pbxLoading.Visible = false;
btnSearch.Text = "Process";
btnSearch.Enabled = true;
}
private void LoadDirectories()
{
this.Cursor = Cursors.WaitCursor;
Dictionary <string, string> directories = SVNManager.Instance.List(SVNManager.DEV_URL, false);
foreach (string name in directories.Keys)
{
if (name.Equals("Sources") ||
name.Equals("Version") ||
name.Equals("Plugins"))
{
continue;
}
string url = string.Format("{0}/{1}/{2}/{3}", SVNManager.DEV_URL, name, this.PluginData.Parent.Product.Name, this.PluginData.Parent.VersionNumber);
Info info = SVNManager.Instance.Info(url);
if (info == null)
{
continue;
}
Directory directory = this.PluginData.Content[name] as Directory;
if (directory == null)
{
directory = new Directory(name, string.Empty, url);
}
directory.Url = url;
DirectoryTreeNode node = new DirectoryTreeNode(directory);
node.SelectedImageIndex = 0;
node.ImageIndex = 0;
if (name.Equals("References"))
{
node.Text = "Bin";
node.Name = "Bin";
}
this.tvContent.Nodes.Add(node);
}
foreach (DirectoryTreeNode node in this.tvContent.Nodes)
{
LoadContent(node);
}
this.Cursor = Cursors.Default;
}
private void LoadCachedDependencies(DirectoryTreeNode directoryNode, string url, Dictionary <string, string> urls)
{
foreach (string name in urls.Keys)
{
string curUrl = string.Format("{0}/{1}", url, name);
if (!Application.ReferencesCache.ContainsKey(urls[name]))
{
this.LoadNonCachedDependencies(directoryNode, url, urls);
return;
}
CacheInfo cacheInfo = Application.ReferencesCache[urls[name]];
if (cacheInfo == null)
{
Info info = SVNManager.Instance.Info(curUrl);
this.LoadNonCachedDependency(directoryNode, info, name, curUrl);
}
else if (cacheInfo.IsDirectory)
{
Directory directory = new Directory(name);
directory.Url = curUrl;
DirectoryTreeNode node = new DirectoryTreeNode(directory);
node.ImageIndex = 0;
node.SelectedImageIndex = 0;
directoryNode.Nodes.Add(node);
}
else
{
DependencyAssembly dependencyAssembly = this.PluginData.DependencyAssemblies[name] as DependencyAssembly;
bool contains = dependencyAssembly != null;
if (!contains)
{
dependencyAssembly = new DependencyAssembly(name, @"Program\Bin");
}
DependencyAssemblyTreeNode node = new DependencyAssemblyTreeNode(dependencyAssembly);
node.Checked = contains;
node.ImageIndex = 1;
node.SelectedImageIndex = 1;
directoryNode.Nodes.Add(node);
}
}
}
private void UpdateNodeChildren(DirectoryTreeNode node)
{
if (!node.IsAccessDenied)
{
if (node.IsDrive)
{
DriveInfo driveInfo = new DriveInfo(node.Directory);
if (!driveInfo.IsReady)
{
node.Items.Clear();
MessageBox.Show(string.Format(DriveNotReadyMessage, node.Directory), DriveNotReadyDialogTitle, MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
}
DirectoryInfo info = new DirectoryInfo(node.Directory);
DirectoryInfo[] dirs = info.GetDirectories();
TreeViewBeginUpdate();
try
{
node.Items.Clear();
foreach (DirectoryInfo dir in dirs.OrderBy(p => p.FullName))
{
if ((dir.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
{
DirectoryTreeNode childNode = new DirectoryTreeNode(node.Depth + 1);
childNode.Expanding += treeView1_BeforeExpand;
childNode.Collapsing += treeView1_BeforeCollapse;
node.Items.Add(childNode);
childNode.Directory = dir.FullName;
}
}
_viewModel.CurrentDirectory = node.Directory;
if (!_suppressEventHandling)
{
node.IsSelected = true;
}
}
finally
{
TreeViewEndUpdate();
}
}
else
{
MessageBox.Show(node.AccessDeniedMessage, AccessDeniedDialogTitle, MessageBoxButton.OK, MessageBoxImage.Information);
}
}
private static List <FileRecord> RecursiveFindByType(DirectoryTreeNode currentNode, List <FileRecord> roller = null)
{
if (roller == null)
{
roller = new List <FileRecord>();
}
roller.AddRange(currentNode.Files);
foreach (var subDir in currentNode.Children)
{
RecursiveFindByType(subDir, roller);
}
return(roller);
}
/// <summary>
/// Updates the FileViewers to display the currently selected item in the TreeView
/// </summary>
private void UpdateDisplayPanel()
{
ResetViewer();
if (treeView.SelectedItem == null)
{
return;
}
var item = treeView.SelectedItem as TreeViewItem;
if (item?.Header is DirectoryTreeNode)
{
DirectoryTreeNode selectedDirectory = (DirectoryTreeNode)item.Header;
if (selectedDirectory.Record == null)
{
return;
}
}
FileRecord selectedRecord = treeView.SelectedItem as FileRecord;
if (selectedRecord == null)
{
return;
}
try
{
switch (selectedRecord.FileFormat)
{
case FileRecord.DataFormat.Ascii: DisplayAscii(selectedRecord); break;
case FileRecord.DataFormat.Unicode: DisplayUnicode(selectedRecord); break;
case FileRecord.DataFormat.RichText: DisplayRichText(selectedRecord); break;
}
}
catch (Exception ex)
{
ResetViewer();
textBoxOutput.Visibility = Visibility.Visible;
StringBuilder sb = new StringBuilder();
while (ex != null)
{
sb.AppendLine(ex.Message);
ex = ex.InnerException;
}
textBoxOutput.Text = string.Format(Settings.Strings["UpdateDisplayPanel_Failed"], sb);
}
}
/// <summary>
/// Returns list of TreeNode that represents children of directory.
/// </summary>
/// <param name="directoryPath">Directory for which children is collected.</param>
/// <returns>List of directory children.</returns>
public ChildNodesResult GetDirectoryChildren(string directoryPath)
{
var directoryInfo = new DirectoryInfo(directoryPath);
var result = new ChildNodesResult();
try
{
var directoryChilds = directoryInfo.EnumerateDirectories();
var filesChilds = directoryInfo.EnumerateFiles();
foreach (var directory in directoryChilds)
{
var directoryNode = new DirectoryTreeNode(directory.Name)
{
Tag = directory,
ImageKey = "folder.png",
SelectedImageKey = "folder.png",
};
directoryNode.Nodes.Add("dummy");
result.ChildNodes.Add(directoryNode);
}
foreach (var file in filesChilds)
{
var icon = GetFileIcon(file.Extension);
result.ChildNodes.Add(new TreeNode(file.Name)
{
Tag = file,
ImageKey = icon,
SelectedImageKey = icon,
});
}
}
catch (UnauthorizedAccessException ex)
{
ErrorLogger.LogError("Unauthorized access to file: " + ex.Message);
result.Error = ex;
}
catch (Exception ex)
{
ErrorLogger.LogError("Exception thrown: " + ex.Message);
result.Error = ex;
}
return(result);
}
private static void InitGGPK()
{
if (content != null)
{
return;
}
searchContentGGPK();
if (ggpkPaths.Count == 1)
{
ggpkPath = ggpkPaths[0];
}
else if (ggpkPaths.Count > 1)
{
int pos = 0;
foreach (string ggpkPath2 in ggpkPaths)
{
OutputLine(string.Format("[{0}] {1}", pos++, ggpkPath2));
}
OutputLine(string.Format("Choose [0-{0}]: ", pos - 1));
ConsoleKeyInfo cki = Console.ReadKey();
OutputLine("");
Int32 number;
if (Int32.TryParse(cki.KeyChar.ToString(), out number))
{
if (number >= 0 && number <= pos - 1)
{
ggpkPath = ggpkPaths[number];
}
}
}
if (!File.Exists(ggpkPath))
{
OutputLine(string.Format("GGPK {0} not exists.", ggpkPath));
return;
}
OutputLine(string.Format("Parsing {0}", ggpkPath));
content = new GrindingGearsPackageContainer();
content.Read(ggpkPath, Output);
RecordsByPath = new Dictionary <string, FileRecord>(content.RecordOffsets.Count);
DirectoryTreeNode.TraverseTreePostorder(content.DirectoryRoot, null, n => RecordsByPath.Add(n.GetDirectoryPath() + n.Name, n as FileRecord));
}
private void LoadNonCachedDependency(DirectoryTreeNode directoryNode, Info info, string name, string url)
{
if (info == null)
{
return;
}
if (info.Entry.IsDirectory)
{
Directory directory = this.PluginData.Content[name] as Directory;
bool contains = directory != null;
if (!contains)
{
directory = new Directory(name, directoryNode.FullPath, url);
}
directory.Url = url;
DirectoryTreeNode node = new DirectoryTreeNode(directory);
node.Checked = contains;
node.ImageIndex = 0;
node.SelectedImageIndex = 0;
directoryNode.Nodes.Add(node);
}
else
{
DependencyAssembly dependencyAssembly = this.PluginData.DependencyAssemblies[name] as DependencyAssembly;
bool contains = dependencyAssembly != null;
if (!contains)
{
dependencyAssembly = new DependencyAssembly(name, @"Program\Bin");
}
DependencyAssemblyTreeNode node = new DependencyAssemblyTreeNode(dependencyAssembly);
node.Checked = contains;
node.ImageIndex = 1;
node.SelectedImageIndex = 1;
directoryNode.Nodes.Add(node);
}
}
private void menuItemExport_Click(object sender, RoutedEventArgs e)
{
var item = treeView.SelectedItem as TreeViewItem;
if (item != null)
{
TreeViewItem selectedTreeViewItem = item;
DirectoryTreeNode selectedDirectoryNode = selectedTreeViewItem.Header as DirectoryTreeNode;
if (selectedDirectoryNode != null)
{
ExportAllItemsInDirectory(selectedDirectoryNode);
}
}
else if (treeView.SelectedItem is FileRecord)
{
ExportFileRecord((FileRecord)treeView.SelectedItem);
}
}
private static DatContainer GetDatContainer(DirectoryTreeNode dataDir, string contentFilePath, string datFileName)
{
var dataFile = dataDir.Files.FirstOrDefault(x => x.Name == datFileName);
if (dataFile == null)
{
Logger.WriteLine($"\t{datFileName} not found in '{dataDir.Name}'.");
return(null);
}
#warning TODO: Optimize ReadFileContent by using a BinaryReader instead.
var data = dataFile.ReadFileContent(contentFilePath);
using (var dataStream = new MemoryStream(data))
{
// Read the MemoryStream and create a DatContainer
return(new DatContainer(dataStream, dataFile.Name));
}
}
/// <summary>
/// 返回这个工程子项的生成的节点
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private ExtTreeNode BuildNode(ATNET.Project.ProjectItem item)
{
ExtTreeNode node = new CustomTreeNode(null, item);
DirectoryProjectItem directoryItem = item as DirectoryProjectItem;
if (directoryItem != null)
{
node = new DirectoryTreeNode(null, item);
if (directoryItem.Items.Count > 0)
{
foreach (ATNET.Project.ProjectItem pitem in directoryItem.Items)
{
ExtTreeNode node1 = BuildNode(pitem);
node.Items.Add(node1);
}
}
return(node as DirectoryTreeNode);
}
return(node as CustomTreeNode);
}
private IEnumerable <Tuple <DirectoryTreeNode, string[]> > GetParentOptions(DirectoryTreeNode node, string[] path)
{
// A node is a valid parent option if the node is either already the parent of child, or if the node is
// a web page that the user has change permission for.
if (node.EntityReference.LogicalName != "adx_webpage")
{
yield break;
}
if (node.write)
{
yield return(new Tuple <DirectoryTreeNode, string[]>(node, path));
}
foreach (var option in node.dirs.SelectMany(dir => GetParentOptions(dir, path.Concat(new[] { node.name }).ToArray())))
{
yield return(option);
}
}
public int CompareDirectories(DirectoryTreeNode x, DirectoryTreeNode y)
{
int result = 0;
switch (SortByMethod)
{
case SortBy.Name:
result = String.Compare(x.Name, y.Name);
break;
case SortBy.Size:
result = x.Size >= y.Size ? 1 : -1;
break;
case SortBy.NumberOfFiles:
result = x.NumberOfFiles >= y.NumberOfFiles ? 1 : -1;
break;
case SortBy.TimeLastAccessed:
result = DateTime.Compare((x.Tag as DirectoryInfo).LastAccessTime, (y.Tag as DirectoryInfo).LastAccessTime);
break;
case SortBy.TimeLastModified:
result = DateTime.Compare((x.Tag as DirectoryInfo).LastWriteTime, (y.Tag as DirectoryInfo).LastWriteTime);
break;
case SortBy.TimeCreated:
result = DateTime.Compare((x.Tag as DirectoryInfo).CreationTime, (y.Tag as DirectoryInfo).CreationTime);
break;
default:
break;
}
if (Descending && result != 0)
{
result *= -1;
}
return(result);
}
public ActionResult Index_Tree()
{
DirectoryTreeNode root = new DirectoryTreeNode
{
Id = "root",
Text = Environment.MachineName
};
// Laufwerke auslesen
DriveInfo[] allDrives = DriveInfo.GetDrives();
foreach (var driveInfo in allDrives)
{
DirectoryTreeNode childNode = new DirectoryTreeNode();
childNode.Text = driveInfo.Name;
childNode.Path = driveInfo.Name.Replace("\\", "\\\\");
childNode.IsReady = driveInfo.IsReady;
if (childNode.IsReady)
{
childNode.Id = driveInfo.VolumeLabel;
}
else
{
childNode.Id = driveInfo.Name;
}
root.ChildNodes.Add(childNode);
}
// 1. Verzeichnissebene auslesen
foreach (var child in root.ChildNodes)
{
if (child.IsReady)
{
child.ChildNodes.AddRange(this.InitDirectoryChildNodes(child.Path));
}
}
return(View(root));
}
private static void InitGGPK()
{
if (content != null)
{
return;
}
ggpkPath = searchContentGGPK();
if (!File.Exists(ggpkPath))
{
OutputLine(string.Format("GGPK {0} not exists.", ggpkPath));
return;
}
OutputLine(string.Format("Parsing {0}", ggpkPath));
content = new GGPK();
content.Read(ggpkPath, Output);
RecordsByPath = new Dictionary <string, FileRecord>(content.RecordOffsets.Count);
DirectoryTreeNode.TraverseTreePostorder(content.DirectoryRoot, null, n => RecordsByPath.Add(n.GetDirectoryPath() + n.Name, n as FileRecord));
}
private void treeView1_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (_suppressEventHandling)
{
return;
}
DirectoryTreeNode node = e.NewValue as DirectoryTreeNode;
if (node == null)
{
return;
}
string currentDirectory = _viewModel.CurrentDirectory;
if (currentDirectory != node.Directory)
{
if (!node.IsExpanded)
{
_suppressEventHandling = true;
try
{
UpdateNodeChildren(node);
node.IsExpanded = true;
}
finally
{
_suppressEventHandling = false;
}
}
else
{
_viewModel.CurrentDirectory = node.Directory;
}
}
e.Handled = true;
}
private void LoadDependencies(DirectoryTreeNode directoryNode)
{
string url = directoryNode.Directory.Url;
Info info = SVNManager.Instance.Info(url);
List <string> dependencies = new List <string>();
Dictionary <string, string> urls = SVNManager.Instance.List(url);
if (urls == null)
{
return;
}
if (Application.ReferencesCache.ContainsKey(url) &&
Application.ReferencesCache[url].LastRevision.Equals(info.Entry.Revision))
{
this.LoadCachedDependencies(directoryNode, url, urls);
}
else
{
if (!Application.ReferencesCache.ContainsKey(url))
{
Application.ReferencesCache.Append(url, false, true);
}
if (Application.ReferencesCache.ContainsKey(url))
{
Application.ReferencesCache[url].LastRevision = info.Entry.Revision;
Application.ReferencesCache.Save();
}
this.LoadNonCachedDependencies(directoryNode, url, urls);
}
directoryNode.Expand();
}
/// <summary>Navigates to a specified directory.</summary>
/// <param name="directory">The directory.</param>
private void NavigateTo(string directory)
{
if (string.IsNullOrEmpty(directory))
throw new ArgumentNullException("directory");
FileView fileView = new FileView(directory);
string currentDirectory = _oldDirectory;
_oldDirectory = fileView.FullName;
if (!_drivesAdded)
{
_drivesAdded = true;
foreach (DriveInfo drive in DriveInfo.GetDrives())
{
DirectoryTreeNode node = new DirectoryTreeNode(0);
node.Expanding += treeView1_BeforeExpand;
node.Collapsing += treeView1_BeforeCollapse;
treeView1.Items.Add(node);
node.Directory = drive.RootDirectory.FullName;
}
}
if (!fileView.IsDirectory)
return;
if (string.Compare(currentDirectory, fileView.FullName, true) == 0)
return;
List<string> nodeNames = new List<string>();
nodeNames.Add(fileView.FullName);
string upLevel = Path.GetDirectoryName(fileView.FullName);
while (!string.IsNullOrEmpty(upLevel))
{
nodeNames.Add(upLevel);
upLevel = Path.GetDirectoryName(upLevel);
}
ItemCollection nodes = treeView1.Items;
TreeViewItem parentNode = null;
TreeViewBeginUpdate();
_suppressEventHandling = true;
try
{
for (int i = nodeNames.Count - 1; i >= 0; i--)
{
parentNode = FindNode(parentNode, nodes, nodeNames[i]);
nodes = parentNode.Items;
}
if (parentNode != null)
{
UpdateNodeChildren((DirectoryTreeNode)parentNode);
parentNode.IsSelected = true;
parentNode.IsExpanded = true;
parentNode.BringIntoView();
}
}
finally
{
_suppressEventHandling = false;
TreeViewEndUpdate();
}
}
private void UpdateNodeChildren(DirectoryTreeNode node)
{
if (!node.IsAccessDenied)
{
if (node.IsDrive)
{
DriveInfo driveInfo = new DriveInfo(node.Directory);
if (!driveInfo.IsReady)
{
node.Items.Clear();
MessageBox.Show(string.Format(DriveNotReadyMessage, node.Directory), DriveNotReadyDialogTitle, MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
}
DirectoryInfo info = new DirectoryInfo(node.Directory);
DirectoryInfo[] dirs = info.GetDirectories();
TreeViewBeginUpdate();
try
{
node.Items.Clear();
foreach (DirectoryInfo dir in dirs.OrderBy(p => p.FullName))
{
if ((dir.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden)
{
DirectoryTreeNode childNode = new DirectoryTreeNode(node.Depth + 1);
childNode.Expanding += treeView1_BeforeExpand;
childNode.Collapsing += treeView1_BeforeCollapse;
node.Items.Add(childNode);
childNode.Directory = dir.FullName;
}
}
_viewModel.CurrentDirectory = node.Directory;
if (!_suppressEventHandling)
node.IsSelected = true;
}
finally
{
TreeViewEndUpdate();
}
}
else
{
MessageBox.Show(node.AccessDeniedMessage, AccessDeniedDialogTitle, MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public void HandleDirectoryTree()
{
this.root = TreeViewHandler.getInstance().PopulateDirectoryTreeView(this.fd);
}
