protected override void OnBeforeExpand(TreeViewCancelEventArgs e)
{
FolderNode node = e.Node as FolderNode;
if (((!this._addingNodes && (node != null)) && (node.Nodes.Count == 1)) && (node.Nodes[0].Text == ""))
{
node.Nodes.Clear();
this.RecurseFileSystem(node.Nodes, node.Directory);
}
base.OnBeforeExpand(e);
}
private FileNode FindQueryByPath(string path)
{
Func <FileNode, bool> predicate = null;
FileNode node;
try
{
if (!path.StartsWith(Options.DefaultQueryFolder, StringComparison.OrdinalIgnoreCase))
{
return(null);
}
path = path.Substring(Options.DefaultQueryFolder.Length);
if (path.StartsWith(@"\"))
{
path = path.Substring(1);
}
TreeNodeCollection source = base.Nodes[0].Nodes;
while (path.Contains(@"\"))
{
string dir = path.Substring(0, path.IndexOf('\\'));
FolderNode node2 = source.OfType <FolderNode>().FirstOrDefault <FolderNode>(n => string.Equals(n.Text, dir, StringComparison.OrdinalIgnoreCase));
if (node2 == null)
{
goto Label_01AF;
}
if ((node2.Nodes.Count == 1) && (node2.Nodes[0].Text == ""))
{
node2.Nodes.Clear();
this.RecurseFileSystem(node2.Nodes, node2.Directory);
}
path = path.Substring(path.IndexOf('\\') + 1);
source = node2.Nodes;
}
if (path.Length == 0)
{
return(null);
}
path = Path.GetFileName(path);
if (predicate == null)
{
predicate = n => string.Equals(n.FileName, path, StringComparison.OrdinalIgnoreCase);
}
return(source.OfType <FileNode>().FirstOrDefault <FileNode>(predicate));
Label_01AF:
node = null;
}
catch (Exception exception)
{
Log.Write(exception);
node = null;
}
return(node);
}
/// <summary>
/// Adds a directory to the project hierarchy with the specified parent.
/// </summary>
protected void AddDirectory(HierarchyNode parent, bool isSearchPath, string subfolder)
{
var existing = parent.FindChild(Path.GetFileName(subfolder));
if (existing == null)
{
FolderNode folderNode = CreateFolderNode(subfolder);
parent.AddChild(folderNode);
CreateHierarchy(folderNode, subfolder, isSearchPath);
}
}
/// <exception cref="ArgumentNullException"></exception>
public bool IsNodeLockedForRenamesAndMoves(FolderNode nodeToCheck)
{
if (nodeToCheck == null)
{
throw new ArgumentNullException("nodeToCheck");
}
lock (_operationExecutionCriticalSection)
{
return(_nodeIdsToLocks.ContainsKey(nodeToCheck.Id));
}
}
public static void UpdateVisibility(this FolderNode folder)
{
foreach (var subFolder in folder.Directories)
{
subFolder.UpdateVisibility();
}
var hasVisibleFiles = folder.Files.Any(file => file.IsVisible);
var hasVisibleSubfolders = folder.Directories.Any() && folder.Directories.Any(dir => dir.IsVisible);
folder.IsVisible = hasVisibleFiles || hasVisibleSubfolders;
}
/// <summary>
/// Получить все доступные диски
/// </summary>
public void GetDrives()
{
foreach (var driveInfo in DriveInfo.GetDrives())
{
if (driveInfo.IsReady)
{
var node = new FolderNode(driveInfo.Name, driveInfo.RootDirectory.FullName);
UpdateNode(node, false);
_folderView.Nodes.Add(node);
}
}
}
private void PopulateChildDirectories(NodeBase parentNode)
{
foreach (var childDirectory in this.fileSystem.Directory.GetDirectories(parentNode.FullPath))
{
var childNode = new FolderNode(this.fileSystem.DirectoryInfo.FromDirectoryName(childDirectory).Name, childDirectory);
this.PopulateChildDirectories(childNode);
this.PopulateChildFiles(childNode);
parentNode.ChildNodes.Add(childNode);
}
this.PopulateChildFiles(parentNode);
}
public void MakeSureNodeLockableThrowsWhenBeingAcquiredIfFileLockDoesNotListItAsAssociatedNode()
{
FolderNode nodeToLock = FakeNodesFactory.CreateFakeFolderNodes(1).First();
var nodeLockable = new FolderNodeLockable(nodeToLock);
FileLockable lock1 = new FileLockable(FakeNodesFactory.CreateFakeFileNode(), FakeNodesFactory.CreateFakeFolderNodes(2));
ExceptionAssert.MakeSureExceptionIsRaisedBy <ArgumentException>(
delegate
{
nodeLockable.AddLock(lock1, lock1.LockForWriting());
});
}
private static string GetPath(FolderNode node, string name)
{
var path = node.Path;
if (path.Length > 0)
{
path += '/';
}
path += name;
return(path);
}
public override SPCoder.Utils.Nodes.BaseNode GetSPStructure(string siteUrl)
{
Folder = new DirectoryInfo(siteUrl);
BaseNode rootNode = new FolderNode(Folder);
rootNode.Title = RootNodeTitle + Folder.Name;
rootNode.NodeConnector = this;
rootNode.OMType = ObjectModelType.LOCAL;
TraverseFileSystem(Folder, rootNode, rootNode);
return(rootNode);
}
void ExpandRecursive(FolderNode treeNode, int dept)
{
if (dept == 0)
{
return;
}
treeNode.Expand();
foreach (FolderNode child in treeNode.ChildNodes)
{
ExpandRecursive(child, dept - 1);
}
}
public long GetFolderSize(FolderNode folder)
{
if (folder == null || folder.IsEmpty)
{
return(0);
}
return(folder.SubFolders.Sum(c =>
{
AttachChildren(c);
return GetFolderSize(c);
}) + folder.Files.Sum(c => c.Size));
}
private static FolderNode FindFolderNode(FolderNode parent, string path)
{
for (int i = 0; i < parent.SubNodes.Count; i++)
{
var child = parent.SubNodes[i];
if (child.Text.Equals(path))
{
return((FolderNode)child);
}
}
return(null);
}
private void FillTreeView(FolderNode tree)
{
try
{
tvwFolders.BeginUpdate();
TreeNode root = tvwFolders.Nodes.Add(tree.Name);
FillTreeViewR(root, tree);
}
finally
{
tvwFolders.EndUpdate();
}
}
public void PrintTree(FolderNode folder, string indent, bool last)
{
var isRoot = string.IsNullOrEmpty(indent);
Console.WriteLine(indent + (isRoot ? "" : "+-- ") + folder.Name);
indent += isRoot ? " " : (last ? " " : "| ");
for (int i = 0; i < folder.Children.Count; i++)
{
if (_vault.TryGetFolder(folder.Children[i], out FolderNode node))
{
PrintTree(node, indent, i == folder.Children.Count - 1);
}
}
}
static private void ScanFolder(FolderNode folder, DataTable IncludedFiles)
{
DirectoryInfo dir = new DirectoryInfo(folder.FullPath);
FileInfo[] files = dir.GetFiles("*.*", folder.IsSubSelected ? SearchOption.TopDirectoryOnly : SearchOption.AllDirectories);
foreach (FileInfo file in files)
{
DataRow r = IncludedFiles.NewRow();
r["FullPath"] = file.FullName;
r["ModifiedDate"] = file.LastWriteTimeUtc;
r["Size"] = file.Length; //megabytes
IncludedFiles.Rows.Add(r);
}
}
private FolderNode TryAdd(FolderNode node, string id, string name)
{
if (node.Children.TryGetValue(name, out var child))
{
return(child);
}
child = new FolderNode(id, GetPath(node, name));
nodes[id] = child;
node.Add(child, name);
return(child);
}
public void ShowDirectory(string path)
{
string[] Folders = path.Split('\\');
FolderNode Node = new FolderNode(Folders[0]);
folderTree.Nodes.Add(Node);
Node.Expand();
for (int i = 1; i < Folders.Length; i++)
{
ExpandQueue.Enqueue(Folders[i]);
}
}
private Unit GetNodeSpacing(FolderNode node)
{
if (node.Selected && selectedNodeStyle != null && selectedNodeStyle.NodeSpacing != Unit.Empty)
{
return(selectedNodeStyle.NodeSpacing);
}
if (nodeStyle != null)
{
return(nodeStyle.NodeSpacing);
}
else
{
return(Unit.Empty);
}
}
private async Task <FolderNode> AddFolderAsync(FolderNode current, string name)
{
var request = new CreateAssetFolderDto
{
FolderName = name,
ParentId = current.Id
};
var folder = await session.Assets.PostAssetFolderAsync(session.App, request);
current = TryAdd(current, folder.Id, name);
current.HasBeenQueried = true;
return(current);
}
static private void RefreshIsSubSelected(FileSystemNode node)
{
FolderNode folder = node as FolderNode;
if (node == null)
{
return;
}
node.IsSubSelected = folder.Children.Where(n => n.Value.IsSubSelected || n.Value.IsSelected).Count() > 0; //gotsta admit, the linq extensions sure do come in amazingly handy
node.SetIsExcluded(); //must do this after setting IsSubSelected since it depends on that property
RefreshIsSubSelected(folder.Parent);
}
public IEnumerable <FileSystemNode> FilterBy(FolderNode root, Predicate <FileSystemNode> predicate)
{
var list = new LinkedList <FileSystemNode>();
try
{
if (TryToAddChildNodes(root, predicate, list))
{
list.AddFirst(root);
}
}
catch (StopException) { }
return(list);
}
private void AddChildNodesR(TreeNode parentNode, Folder <FileInfo> fileTree)
{
foreach (var file in fileTree.Items)
{
parentNode.Nodes.Add(new FileNode(file, imlSmallIcons));
}
foreach (var child in fileTree.Folders)
{
var node = new FolderNode(child.Name);
parentNode.Nodes.Add(node);
AddChildNodesR(node, child);
node.Expand();
}
}
public NodeBase ReadRootDirectory()
{
if (this.RootDirectory == null)
{
throw new InvalidOperationException("Cannot read with no working directory set.");
}
var rootDirectory = this.fileSystem.DirectoryInfo.FromDirectoryName(this.RootDirectory);
FolderNode rootNode = new FolderNode(rootDirectory.Name, this.RootDirectory);
this.PopulateChildDirectories(rootNode);
this.RootDirectoryTree = rootNode;
return(this.RootDirectoryTree);
}
/// <summary>
///
/// </summary>
/// <param name="folderToRemoveDirectoryFrom"></param>
/// <param name="indexReferenceToRemove"></param>
/// <param name="dataStreamBeingCorrected"></param>
/// <exception cref="InconsistentDataDetectedException"></exception>
public void TakeOutABlockFromBlockReferenceList(FolderNode folderToRemoveDirectoryFrom, int indexReferenceToRemove, DataStreamDefinition dataStreamBeingCorrected)
{
var streamStructureBuilder =
new DataStreamStructureBuilder(dataStreamBeingCorrected, _virtualDisk, _freeBlockManager, _fileSystemNodeStorage, folderToRemoveDirectoryFrom, AddressingSystemParameters.Default);
var lockingManager = new NullFileSystemObjectLockingManager();
var folderReferencesStream = new DataStream(streamStructureBuilder, AddressingSystemParameters.Default.BlockSize, lockingManager, Guid.NewGuid());
var nodeUpdatingStream = new DataStreamNodeUpdating(folderReferencesStream, folderToRemoveDirectoryFrom, _fileSystemNodeStorage);
var referencesToBlocks = new byte[nodeUpdatingStream.Length];
nodeUpdatingStream.Read(referencesToBlocks, 0, nodeUpdatingStream.Length);
var correctedStream = new MemoryStream(nodeUpdatingStream.Length);
var reader = new BinaryReader(new MemoryStream(referencesToBlocks, true));
var writer = new BinaryWriter(correctedStream);
int numberOfReferencesFound = 0;
while (reader.BaseStream.Position != reader.BaseStream.Length)
{
int nodeIndex = reader.ReadInt32();
if (nodeIndex != indexReferenceToRemove)
{
writer.Write(nodeIndex);
}
else
{
numberOfReferencesFound++;
}
}
if (numberOfReferencesFound != 1)
{
throw new InconsistentDataDetectedException("Обнаружены неконсистентные данные (произошла попытка удаления несуществующей ссылки на файл или папку). Возможна потеря данных. Обратитесь к разработчикам.");
}
nodeUpdatingStream.SetLength(nodeUpdatingStream.Length - Constants.BlockReferenceSizeInBytes);
var bytes = correctedStream.ToArray();
nodeUpdatingStream.SetPosition(0);
nodeUpdatingStream.Write(bytes, 0, bytes.Length);
}
public void LoadDatapointByID(Int64 nodeID, DatabaseFacade database)
{
this.Database = database;
this.Database.OpenConnection();
DatapointNode datapoint = this.Database.GetDatapointNodeByID(nodeID);
FolderNode parent = this.Database.GetFolderNodeByID(datapoint.GetParentID());
this.Database.CloseConnection();
this.DatapointID = datapoint.GetID();
this.LabelDatapointName.Text = datapoint.GetName();
this.AnalyseDatapointName.Text = datapoint.GetName();
this.AnalyseDatapointDescription.Text = datapoint.GetDescription();
this.LabelDatapointDescription.Text = datapoint.GetDescription();
this.LabelDatapointID.Text = datapoint.GetID().ToString();
this.LabelDatapointParent.Text = parent.GetName();
if (datapoint.GetDatapointType() == DatapointNode.TYPE_BOOL)
{
this.LabelDatapointType.Text = "Bool (Wahr/Falsch)";
}
if (datapoint.GetDatapointType() == DatapointNode.TYPE_FLOATING_POINT)
{
this.LabelDatapointType.Text = "Fließkommazahl";
}
if (datapoint.GetDatapointType() == DatapointNode.TYPE_INTEGER)
{
this.LabelDatapointType.Text = "Ganzzahl";
}
if (datapoint.GetDatapointType() == DatapointNode.TYPE_TEXT)
{
this.LabelDatapointType.Text = "Text";
}
this.LabelDatapointUnit.Text = datapoint.GetUnit();
this.LabelDatapointLastValue.Text = datapoint.GetLastValue() + " (" + datapoint.GetLastValueUpdate() + ")";
this.LabelDatapointLastUpdate.Text = datapoint.GetLastUpdated().ToString();
DateTime From = DateTime.Now;
TimeSpan FromTime = new TimeSpan(0, 0, 0);
From = From.Date + FromTime;
DateTime To = DateTime.Now;
TimeSpan ToTime = new TimeSpan(23, 59, 59);
To = To.Date + ToTime;
DrawDatapointChart(ChartDatapoint, From, To);
}
private void BuildSubTree(FolderNode node, int level)
{
IEnumerable <FolderInfoDto> childCats = NodeList.Where(o => object.Equals(o.ParentId, node.Id));
if (childCats.Count <FolderInfoDto>() > 0)
{
foreach (FolderInfoDto item in childCats.OrderBy(o => o.Sort))
{
// add node
FolderNode childNode = new FolderNode(item, SelectedFolderId);
node.SubNodes.Add(childNode);
// explorer next level
BuildSubTree(childNode, level + 1);
}
}
}
private void tsbNewRoot_Click(object sender, EventArgs e)
{
var nrd = new NewRootDialog {
StartPosition = FormStartPosition.CenterParent
};
if (nrd.ShowDialog(ParentForm) == DialogResult.OK)
{
var rootNode = new FolderNode(true, nrd.RootName);
tv.Nodes.Add(rootNode);
tv.TreeViewNodeSorter = new NodeSorter();
tv.Sort();
}
}
public void RealData()
{
var originalLocation =
FileSystem.DirectoryInfo.FromDirectoryName(
@"C:\tfs\Dev.CAX\src\CAX_Main\src\net\Projects\Aim.Gain.GoldenCopy.FunctionalTesting\CAX\DistributionOfRights");
var node = new FolderNode(originalLocation, "");
var other =
new Uri(
"file:///C:/tfs/Dev.CAX/src/CAX_Main/src/net/Projects/Aim.Gain.GoldenCopy.FunctionalTesting/CAX/");
string relative = node.GetRelativeUriTo(other);
Check.That(relative).IsEqualTo("DistributionOfRights/");
}
internal void AddSingleFolder(FolderNode node, string folderName, DirectoryInfo di = null, List <string> invalidFileNames = null)
{
var folderNode = new FolderNode(false, $"{node.ResourceFullPath}/{folderName}", di?.FullName);
node.Nodes.Add(folderNode);
if (di != null && Directory.Exists(di.FullName))
{
foreach (var subdirectory in di.GetDirectories())
{
AddSingleFolder(folderNode, subdirectory.Name, subdirectory, invalidFileNames);
}
AddFilesAsNodes(folderNode, di.GetFiles().Select(f => f.FullName).ToList(), invalidFileNames);
}
}
private void ClearSubfolders(FolderNode folder)
{
Argument.IsNotNull(() => folder);
foreach (var folderNode in folder.Directories)
{
ClearSubfolders(folderNode);
}
folder.Directories.Clear();
}
private FolderNode CreateFolder(HierarchyNode parent, string name, IFolderSource folderSource, IMediaItemSource mediaSource)
{
var folder = new FolderNode(parent.Id, CreateId(), name, folderSource: folderSource,
mediaSource: mediaSource);
_nodes[CreateId()] = folder;
return folder;
}
/// <summary>
/// To support virtual folders, override this method to return your own folder nodes
/// </summary>
/// <param name="path">Path to store for this folder</param>
/// <param name="element">Element corresponding to the folder</param>
/// <returns>A FolderNode that can then be added to the hierarchy</returns>
protected internal virtual FolderNode CreateFolderNode(string path, ProjectElement element)
{
FolderNode folderNode = new FolderNode(this, path, element);
return folderNode;
}
private void PopulateTree(string dir, BaseNode root, string[] filter)
{
DirectoryInfo directory = new DirectoryInfo(dir);
foreach (DirectoryInfo d in directory.GetDirectories())
{
FolderNode node = new FolderNode(d.Name);
node.Folder = d;
PopulateTree(d.FullName, node, filter);
root.Nodes.Add(node);
}
foreach (FileInfo f in directory.GetFiles())
{
if (filter.Contains(f.Extension))
{
FileNode node = new FileNode(f.Name);
node.File = f;
root.Nodes.Add(node);
}
}
}
internal OAFolderItem(OAProject project, FolderNode node)
: base(project, node) {
}
public void SelectParentWillSelectAllChildrenExceptTheDisabledOnes()
{
// Arrange
ProjectNode[] children = new ProjectNode[3];
// make two children enabled, one disabled
for (int i = 0; i < 3; i++)
{
var project = MockProjectUtility.CreateMockProject("p" + i);
var node = new ProjectNode(project)
{
IsEnabled = i % 2 == 0
};
children[i] = node;
}
var folder = new FolderNode(null, "A", children);
// Act
folder.IsSelected = true;
// Assert
Assert.True(children[0].IsSelected == true);
Assert.True(children[1].IsSelected == false);
Assert.True(children[2].IsSelected == true);
}
private MediaItemNode CreateMediaItemNode(FolderNode parent, MediaItem item)
{
var itemNode = new MediaItemNode(item, parent.Id, CreateId());
_nodes[itemNode.Id] = itemNode;
return itemNode;
}
public void ParentNodeIsEnabledIfAtLeastOneChildrenIsEnabled()
{
// Arrange
var children = new ProjectNode[3];
// make two children enabled, one disabled
for (int i = 0; i < 3; i++)
{
var project = MockProjectUtility.CreateMockProject("p" + i);
var node = new ProjectNode(project)
{
IsEnabled = i % 2 == 0
};
children[i] = node;
}
// Act
var folder = new FolderNode(null, "A", children);
// Assert
Assert.True(folder.IsEnabled);
}
public void ParentNodeIsDisabledIfAllChildrenAreDisabled()
{
// Arrange
var children = new ProjectNode[3];
// disable all children
for (int i = 0; i < 3; i++)
{
var project = MockProjectUtility.CreateMockProject("p" + i);
var node = new ProjectNode(project)
{
IsEnabled = false
};
children[i] = node;
}
// Act
var folder = new FolderNode(null, "A", children);
// Assert
Assert.False(folder.IsEnabled);
}
public void ParentFolderDoNotPropagateStateBackToChildrenWhenTheyAreFirstAddedToFolder()
{
// Arrange
ProjectNode[] children = new ProjectNode[3];
// make two children selected, one unselected
for (int i = 0; i < 3; i++)
{
var project = MockProjectUtility.CreateMockProject("p" + i);
var node = new ProjectNode(project)
{
IsSelected = i % 2 == 0
};
children[i] = node;
}
var folder = new FolderNode(null, "A", children);
// Act
var root = new FolderNode(null, "Root", new[] { folder });
// Assert
Assert.Null(folder.IsSelected);
for (int i = 0; i < 3; i++)
{
Assert.True(children[0].IsSelected == true);
Assert.True(children[1].IsSelected == false);
Assert.True(children[2].IsSelected == true);
}
}
public void ReleaseFileSystemContent(FolderNode folder)
{
Argument.IsNotNull(() => folder);
_fileSystemWatchingService.EndDirectoryWatching(folder.FullName);
OnDeleted(folder.FullName);
}
public FolderNode LoadFileSystemContent(string path, bool isNavigationRoot = false)
{
Argument.IsNotNullOrEmpty(() => path);
Log.Debug("Loading file system content '{0}'", path);
var directoryInfo = new DirectoryInfo(path);
FolderNode folder = null;
_dispatcherService.Invoke(() => { folder = new FolderNode(directoryInfo); }, true);
var logFiles = Directory.GetFiles(path, _wildcardsFilter, SearchOption.TopDirectoryOnly).Where(x => x.IsSupportedFile(_regexFilter)).OrderBy(x => new FileInfo(x).Name).ToList();
var fileNodes = new List<FileNode>();
#if LOADFILES_PARALLEL
var fileTasks = new List<Action>();
foreach (var logFile in logFiles)
{
var file = logFile;
fileTasks.Add(() =>
{
var fileNode = LoadFileFromFileSystem(Path.Combine(path, file));
lock (fileTasks)
{
fileNodes.AddDescendingly(fileNode, CompareFileNodes);
}
});
}
// Parse all files parallel
TaskHelper.RunAndWait(fileTasks.ToArray());
#else
foreach (var logFile in logFiles)
{
var fileNode = LoadFileFromFileSystem(Path.Combine(path, logFile));
fileNodes.Add(fileNode);
}
#endif
_dispatcherService.Invoke(() => folder.Files = new ObservableCollection<FileNode>(fileNodes.OrderByDescending( x => x.FileInfo.CreationTime)), true);
var logDirectories = Directory.GetDirectories(path).Select(x => Path.Combine(path, x));
#if LOADDIRECTORIES_PARALLEL
var directoryTasks = new List<Action>();
foreach (var directory in logDirectories)
{
var dir = directory;
directoryTasks.Add(() =>
{
var folderNode = LoadFileSystemContent(Path.Combine(path, dir));
_dispatcherService.Invoke(() => folder.Directories.Add(folderNode));
});
}
// Parse all directories parallel
TaskHelper.RunAndWait(directoryTasks.ToArray());
#else
foreach (var directory in logDirectories)
{
var fileSystemContent = LoadFileSystemContent(directory);
_dispatcherService.Invoke(() => folder.Directories.Add(fileSystemContent), true);
}
#endif
if (isNavigationRoot)
{
_fileSystemWatchingService.BeginDirectoryWatching(folder.FullName, _wildcardsFilter);
}
else
{
folder.UpdateVisibility();
}
_navigationNodeCacheService.AddToCache(folder);
return folder;
}
