private void DeleteTreeViewEntryItemModel(TreeViewEntryItemModel item, bool first = true)
{
if (item == this.RootTreeViewEntryItem || item == null)
{
return;
}
var lockObject = item.Parent == null ? TreeViewEntryItemModel.RootLockObject : item.Parent;
IList <TreeViewEntryItemModel> children;
lock (lockObject)
{
this.ItemsMap.Remove(item.Path);
if (item.NodeType == NodeType.File)
{
lock (TreeViewEntryItemModel.RootLockObject)
{
this.NumberOfFiles--;
}
}
children = new List <TreeViewEntryItemModel>(item.Children);
}
foreach (var child in children)
{
this.DeleteTreeViewEntryItemModel(child, false);
}
if (first)
{
item.Delete();
}
}
// running in Indexing or UI thread
public void RefreshFromNode(INode node, string path, bool expandAllNodes)
{
// node == null -> search returned no results at all
if (node == null)
{
this.HandleNoResultsFound(path);
return;
}
TreeViewEntryItemModel treeViewEntryItem = this.FindTreeViewEntryItemByPath(node.Path);
if (treeViewEntryItem == null)
{
bool isSelected = node.Path == this.PathOfItemToSelectOnRefresh;
treeViewEntryItem = this.CreateTreeViewEntryItemModelWithNodeParents(node, isSelected, expandAllNodes);
}
else
{
this.UpdateNode(treeViewEntryItem, node);
// also refresh parents (icons can change)
var parent = treeViewEntryItem.Parent;
while (parent != null)
{
parent.RefreshNode();
parent = parent.Parent;
}
}
if (expandAllNodes)
{
treeViewEntryItem.IsExpanded = true;
}
this.RefreshFromIntermediateNode(node, treeViewEntryItem, expandAllNodes);
this.OnPropertyChanged("TreeViewItems");
}
public void StartEditingTreeItem(TreeViewEntryItemModel item)
{
if (!this.HandleUnsavedFileManipulation(item))
{
return;
}
item.IsBeingEdited = true;
}
private bool HandleUnsavedFileManipulation(TreeViewEntryItemModel selectedItem)
{
if (selectedItem != null && selectedItem.NodeType == NodeType.File && this.IseIntegrator.OpenFiles.Contains(selectedItem.Path) && !this.IseIntegrator.IsFileSaved(selectedItem.Path))
{
this.IseIntegrator.GoToFile(selectedItem.Path);
MessageBoxHelper.ShowInfo("Please save your changes or close the file first.");
return(false);
}
return(true);
}
public void MoveTreeItem(TreeViewEntryItemModel movedItem, TreeViewEntryItemModel destinationItem, string rootDirectory)
{
if (movedItem == destinationItem || movedItem == null)
{
return;
}
if (!this.HandleUnsavedFileManipulation(movedItem))
{
return;
}
string destPath = destinationItem != null ? destinationItem.Path : rootDirectory;
if (!MessageBoxHelper.ShowConfirmMessage(String.Format("Please confirm you want to move '{0}' to '{1}'.", movedItem.Path, destPath)))
{
return;
}
try
{
string newPath;
// moved to the empty place, i.e. to the workspace directory
if (destinationItem == null)
{
newPath = this.GenerateNewPathForDir(rootDirectory, movedItem.Name);
}
else if (destinationItem.NodeType == NodeType.File)
{
newPath = this.GenerateNewPath(destinationItem.Path, movedItem.Name);
}
else if (destinationItem.NodeType == NodeType.Directory)
{
newPath = this.GenerateNewPathForDir(destinationItem.Path, movedItem.Name);
}
else
{
return;
}
this.FilesPatternProvider.RemoveAdditionalPath(movedItem.Path);
this.FilesPatternProvider.AddAdditionalPath(newPath);
bool closed = this.IseIntegrator.CloseFile(movedItem.Path);
FileSystemOperationsService.RenameFileOrDirectory(movedItem.Path, newPath);
if (closed)
{
this.IseIntegrator.GoToFile(newPath);
}
if (destinationItem != null)
{
destinationItem.IsExpanded = true;
}
}
catch (Exception e)
{
this.PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to move: " + e.Message);
}
}
public void OpenItem(TreeViewEntryItemModel item, string searchText)
{
if (this.IseIntegrator == null)
{
throw new InvalidOperationException("IseIntegrator has not ben set yet.");
}
if (item == null)
{
return;
}
if (item.Node.NodeType == NodeType.File)
{
bool wasOpen = (this.IseIntegrator.SelectedFilePath == item.Node.Path);
if (!wasOpen)
{
this.IseIntegrator.GoToFile(item.Node.Path);
}
else
{
this.IseIntegrator.SetFocusOnCurrentTab();
}
if (searchText != null && searchText.Length > 2)
{
EditorInfo editorInfo = (wasOpen ? this.IseIntegrator.GetCurrentLineWithColumnIndex() : null);
TokenPosition tokenPos = TokenLocator.LocateNextToken(item.Node.Path, searchText, editorInfo);
if (tokenPos.MatchLength > 2)
{
this.IseIntegrator.SelectText(tokenPos.Line, tokenPos.Column, tokenPos.MatchLength);
}
else if (string.IsNullOrEmpty(this.IseIntegrator.SelectedText))
{
tokenPos = TokenLocator.LocateSubtoken(item.Node.Path, searchText);
if (tokenPos.MatchLength > 2)
{
this.IseIntegrator.SelectText(tokenPos.Line, tokenPos.Column, tokenPos.MatchLength);
}
}
}
}
else if (item.Node.NodeType == NodeType.Function)
{
var node = ((PowershellItemNode)item.Node);
this.IseIntegrator.GoToFile(node.FilePath);
this.IseIntegrator.SelectText(node.PowershellItem.StartLine, node.PowershellItem.StartColumn, node.Name.Length);
}
else if (item.Node.NodeType == NodeType.Directory)
{
item.IsExpanded = !item.IsExpanded;
}
}
public TreeViewEntryItemModel(INode node, TreeViewEntryItemModel parent, bool isSelected)
{
var lockObject = this.Parent == null ? RootLockObject : this.Parent;
lock (lockObject)
{
this.State = new TreeViewEntryItemModelState(false, isSelected);
this.DocumentHierarchyNode = node;
this.Parent = parent;
this.Children = new TreeViewEntryItemObservableSet();
if (this.Parent != null)
{
this.Parent.Children.Add(this);
}
}
}
public TreeViewEntryItemModel(INode node, TreeViewEntryItemModel parent, bool isSelected)
{
var lockObject = this.Parent == null ? RootLockObject : this.Parent;
lock (lockObject)
{
this.State = new TreeViewEntryItemModelState(false, isSelected);
this.DocumentHierarchyNode = node;
this.Parent = parent;
this.Children = new TreeViewEntryItemObservableSet();
if (this.Parent != null)
{
this.Parent.Children.Add(this);
}
}
}
// TODO: this seems to suffer from race conditions
private void RefreshFromIntermediateNode(INode node, TreeViewEntryItemModel treeViewEntryItem, bool expandAllNodes)
{
if (node == null || treeViewEntryItem == null)
{
return;
}
IList <INode> nodeChildren;
lock (node)
{
nodeChildren = new List <INode>(node.Children);
}
// delete old items
IList <TreeViewEntryItemModel> itemsToDelete = treeViewEntryItem.Children.Where(item => !nodeChildren.Contains(item.Node)).ToList();
foreach (TreeViewEntryItemModel item in itemsToDelete)
{
this.DeleteTreeViewEntryItemModel(item);
}
// add new items
foreach (INode docHierarchyChild in nodeChildren)
{
TreeViewEntryItemModel newTreeViewItem;
lock (treeViewEntryItem)
{
newTreeViewItem = treeViewEntryItem.Children
.FirstOrDefault(treeViewChild => docHierarchyChild.Equals(treeViewChild.Node));
if (newTreeViewItem == null)
{
bool isSelected = docHierarchyChild.Path == this.PathOfItemToSelectOnRefresh;
newTreeViewItem = this.CreateTreeViewEntryItemModel(docHierarchyChild, treeViewEntryItem, isSelected);
}
else
{
this.UpdateNode(newTreeViewItem, docHierarchyChild);
}
if (expandAllNodes)
{
newTreeViewItem.IsExpanded = true;
}
}
this.RefreshFromIntermediateNode(docHierarchyChild, newTreeViewItem, expandAllNodes);
}
}
private TreeViewEntryItemModel CreateTreeViewEntryItemModelWithNodeParents(INode node, bool isSelected, bool expandAllNodes)
{
if (node == null)
{
return(null);
}
var itemParent = node.Parent == null ? null : this.CreateTreeViewEntryItemModelWithNodeParents(node.Parent, false, expandAllNodes);
TreeViewEntryItemModel item = this.FindTreeViewEntryItemByPath(node.Path);
if (item == null)
{
item = this.CreateTreeViewEntryItemModel(node, itemParent, isSelected);
}
if (expandAllNodes)
{
item.IsExpanded = true;
}
return(item);
}
public TreeViewEntryItemModel(INode node, TreeViewEntryItemModel parent, bool isSelected)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
var lockObject = Parent == null ? RootLockObject : Parent;
lock (lockObject)
{
State = new TreeViewEntryItemModelState(false, isSelected);
DocumentHierarchyNode = node;
Parent = parent;
Children = new TreeViewEntryItemObservableSet();
if (Parent != null)
{
Parent.Children.Add(this);
}
}
}
public void AddNewTreeItem(TreeViewEntryItemModel parent, NodeType nodeType)
{
if (this.DocumentHierarchyFactory == null)
{
return;
}
if (parent == null)
{
parent = this.RootTreeViewEntryItem;
}
parent.IsExpanded = true;
INode newNode = this.DocumentHierarchyFactory.CreateTemporaryNode(parent.Node, nodeType);
if (newNode == null)
{
return;
}
var newItem = this.CreateTreeViewEntryItemModel(newNode, parent, true);
newItem.IsBeingEdited = true;
newItem.IsBeingAdded = true;
}
private TreeViewEntryItemModel CreateTreeViewEntryItemModel(INode node, TreeViewEntryItemModel parent, bool isSelected)
{
if (node == null)
{
return(null);
}
var lockObject = parent == null ? TreeViewEntryItemModel.RootLockObject : parent;
lock (lockObject)
{
var item = new TreeViewEntryItemModel(node, parent, isSelected);
this.ItemsMap[node.Path] = item;
if (node.NodeType == NodeType.File)
{
lock (TreeViewEntryItemModel.RootLockObject)
{
this.NumberOfFiles++;
}
}
return(item);
}
}
public void EndTreeEdit(string newValue, bool save, TreeViewEntryItemModel selectedItem, bool addFileExtension)
{
if (selectedItem == null)
{
return;
}
selectedItem.IsBeingEdited = false;
if (selectedItem.NodeType == NodeType.File && addFileExtension && !String.IsNullOrEmpty(newValue) && !this.FilesPatternProvider.DoesFileMatch(newValue))
{
newValue += ".ps1";
}
if (selectedItem.IsBeingAdded)
{
selectedItem.IsBeingAdded = false;
this.EndAddingTreeItem(newValue, save, selectedItem);
}
else
{
this.EndRenamingTreeItem(newValue, save, selectedItem);
}
}
public void DeleteTreeItem(TreeViewEntryItemModel selectedItem)
{
if (selectedItem == null)
{
return;
}
if (!this.HandleUnsavedFileManipulation(selectedItem))
{
return;
}
int numFilesInside = 0;
try
{
numFilesInside = Directory.GetFileSystemEntries(selectedItem.Path).Count();
}
catch (Exception)
{
// ignore - this only has impact on message
}
string message = numFilesInside == 0 ?
String.Format("'{0}' will be deleted permanently.", selectedItem.Path) :
String.Format("'{0}' will be deleted permanently (together with {1} items inside).", selectedItem.Path, numFilesInside);
if (MessageBoxHelper.ShowConfirmMessage(message))
{
try
{
this.IseIntegrator.CloseFile(selectedItem.Path);
this.FilesPatternProvider.RemoveAdditionalPath(selectedItem.Path);
FileSystemOperationsService.DeleteFileOrDirectory(selectedItem.Path);
}
catch (Exception e)
{
MessageBoxHelper.ShowError("Failed to delete: " + e.Message);
}
}
}
private void EndRenamingTreeItem(string newValue, bool save, TreeViewEntryItemModel selectedItem)
{
if (!save || String.IsNullOrEmpty(newValue) || selectedItem == null)
{
return;
}
try
{
string oldPath = selectedItem.Path;
string newPath = this.GenerateNewPath(selectedItem.Path, newValue);
bool closed = this.IseIntegrator.CloseFile(oldPath);
FileSystemOperationsService.RenameFileOrDirectory(oldPath, newPath);
if (closed)
{
this.IseIntegrator.GoToFile(newPath);
}
}
catch (Exception e)
{
this.PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to rename: " + e.Message);
}
}
// TODO: this seems to suffer from race conditions
private void RefreshFromIntermediateNode(INode node, TreeViewEntryItemModel treeViewEntryItem, bool expandAllNodes)
{
if (node == null || treeViewEntryItem == null)
{
return;
}
IList<INode> nodeChildren;
lock (node)
{
nodeChildren = new List<INode>(node.Children);
}
// delete old items
IList<TreeViewEntryItemModel> itemsToDelete = treeViewEntryItem.Children.Where(item => !nodeChildren.Contains(item.Node)).ToList();
foreach (TreeViewEntryItemModel item in itemsToDelete) {
this.DeleteTreeViewEntryItemModel(item);
}
// add new items
foreach (INode docHierarchyChild in nodeChildren)
{
TreeViewEntryItemModel newTreeViewItem;
lock (treeViewEntryItem)
{
newTreeViewItem = treeViewEntryItem.Children
.FirstOrDefault(treeViewChild => docHierarchyChild.Equals(treeViewChild.Node));
if (newTreeViewItem == null)
{
bool isSelected = docHierarchyChild.Path == this.PathOfItemToSelectOnRefresh;
newTreeViewItem = this.CreateTreeViewEntryItemModel(docHierarchyChild, treeViewEntryItem, isSelected);
}
else
{
this.UpdateNode(newTreeViewItem, docHierarchyChild);
}
if (expandAllNodes)
{
newTreeViewItem.IsExpanded = true;
}
}
this.RefreshFromIntermediateNode(docHierarchyChild, newTreeViewItem, expandAllNodes);
}
}
/// <summary>
/// Finds the provided object in an ItemsControl's children and selects it
/// </summary>
/// <param name="parentContainer">The parent container whose children will be searched for the selected item</param>
/// <param name="itemToSelect">The item to select</param>
/// <returns>True if the item is found and selected, false otherwise</returns>
private static bool ExpandAndSelectItemContainer(ItemsControl parentContainer, TreeViewEntryItemModel itemToSelect)
{
IList<TreeViewItem> applicableParents = new List<TreeViewItem>();
//check all items at the current level
foreach (TreeViewEntryItemModel item in parentContainer.Items)
{
if (itemToSelect.Path.StartsWith(item.Path))
{
var currentContainer = parentContainer.ItemContainerGenerator.ContainerFromItem(item) as TreeViewItem;
//if the data item matches the item we want to select, set the corresponding
//TreeViewItem IsSelected to true
if (item == itemToSelect && currentContainer != null)
{
currentContainer.IsSelected = true;
currentContainer.BringIntoView();
//the item was found
return true;
}
else
{
applicableParents.Add(currentContainer);
}
}
}
//if we get to this point, the selected item was not found at the current level, so we must check the children
foreach (TreeViewItem currentContainer in applicableParents)
{
//if children exist
if (currentContainer != null && currentContainer.Items.Count > 0)
{
//keep track of if the TreeViewItem was expanded or not
bool wasExpanded = currentContainer.IsExpanded;
//expand the current TreeViewItem so we can check its child TreeViewItems
currentContainer.IsExpanded = true;
//if the TreeViewItem child containers have not been generated, we must listen to
//the StatusChanged event until they are
if (currentContainer.ItemContainerGenerator.Status != GeneratorStatus.ContainersGenerated)
{
//store the event handler in a variable so we can remove it (in the handler itself)
EventHandler eh = null;
eh = delegate
{
if (currentContainer.ItemContainerGenerator.Status == GeneratorStatus.ContainersGenerated)
{
if (ExpandAndSelectItemContainer(currentContainer, itemToSelect) == false)
{
//The assumption is that code executing in this EventHandler is the result of the parent not
//being expanded since the containers were not generated.
//since the itemToSelect was not found in the children, collapse the parent since it was previously collapsed
currentContainer.IsExpanded = false;
}
//remove the StatusChanged event handler since we just handled it (we only needed it once)
currentContainer.ItemContainerGenerator.StatusChanged -= eh;
}
};
currentContainer.ItemContainerGenerator.StatusChanged += eh;
}
else //otherwise the containers have been generated, so look for item to select in the children
{
if (ExpandAndSelectItemContainer(currentContainer, itemToSelect) == false)
{
//restore the current TreeViewItem's expanded state
currentContainer.IsExpanded = wasExpanded;
}
else //otherwise the node was found and selected, so return true
{
return true;
}
}
}
}
//no item was found
return false;
}
private void UpdateNode(TreeViewEntryItemModel treeViewEntryItem, INode node)
{
treeViewEntryItem.UpdateNode(node);
}
private void EndRenamingTreeItem(string newValue, bool save, TreeViewEntryItemModel selectedItem)
{
if (!save || String.IsNullOrEmpty(newValue))
{
return;
}
try
{
string oldPath = selectedItem.Path;
string newPath = GenerateNewPath(selectedItem.Path, newValue);
bool closed = IseIntegrator.CloseFile(oldPath);
FileSystemOperationsService.RenameFileOrDirectory(oldPath, newPath);
if (closed)
{
IseIntegrator.GoToFile(newPath);
}
}
catch (Exception e)
{
PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to rename: " + e.Message);
}
}
/// <summary>
/// Searches a TreeView for the provided object and selects it if found
/// </summary>
/// <param name="treeView">The TreeView containing the item</param>
/// <param name="item">The item to search and select</param>
public static void ExpandAndSelectItem(this TreeView treeView, TreeViewEntryItemModel item)
{
ExpandAndSelectItemContainer(treeView, item);
}
public void DeleteTreeItem(TreeViewEntryItemModel selectedItem)
{
if (selectedItem == null)
{
return;
}
if (!HandleUnsavedFileManipulation(selectedItem))
{
return;
}
int numFilesInside = 0;
try
{
numFilesInside = Directory.GetFileSystemEntries(selectedItem.Path).Count();
}
catch (Exception)
{
// ignore - this only has impact on message
}
string message = numFilesInside == 0 ?
String.Format("'{0}' will be deleted permanently.", selectedItem.Path) :
String.Format("'{0}' will be deleted permanently (together with {1} items inside).", selectedItem.Path, numFilesInside);
if (MessageBoxHelper.ShowConfirmMessage(message))
{
try
{
IseIntegrator.CloseFile(selectedItem.Path);
FilesPatternProvider.RemoveAdditionalPath(selectedItem.Path);
FileSystemOperationsService.DeleteFileOrDirectory(selectedItem.Path);
}
catch (Exception e)
{
MessageBoxHelper.ShowError("Failed to delete: " + e.Message);
}
}
}
private bool HandleUnsavedFileManipulation(TreeViewEntryItemModel selectedItem)
{
if (selectedItem.NodeType == NodeType.File && IseIntegrator.OpenFiles.Contains(selectedItem.Path) && !IseIntegrator.IsFileSaved(selectedItem.Path))
{
IseIntegrator.GoToFile(selectedItem.Path);
MessageBoxHelper.ShowInfo("Please save your changes or close the file first.");
return false;
}
return true;
}
private void UpdateNode(TreeViewEntryItemModel treeViewEntryItem, INode node)
{
treeViewEntryItem.UpdateNode(node);
}
public void StartEditingTreeItem(TreeViewEntryItemModel item)
{
if (!HandleUnsavedFileManipulation(item))
{
return;
}
item.IsBeingEdited = true;
}
private void EndAddingTreeItem(string newValue, bool save, TreeViewEntryItemModel selectedItem)
{
if (selectedItem == null)
{
return;
}
if (!save || String.IsNullOrEmpty(newValue))
{
this.DocumentHierarchyFactory.RemoveTemporaryNode(selectedItem.Node);
this.DeleteTreeViewEntryItemModel(selectedItem);
return;
}
var newPath = this.GenerateNewPath(selectedItem.Path, newValue);
INode newNode = null;
if (this.FindTreeViewEntryItemByPath(newPath) != null)
{
this.DocumentHierarchyFactory.RemoveTemporaryNode(selectedItem.Node);
this.DeleteTreeViewEntryItemModel(selectedItem);
MessageBoxHelper.ShowError("Item '" + newPath + "' already exists.");
return;
}
if (selectedItem.NodeType == NodeType.Directory)
{
try
{
newNode = this.DocumentHierarchyFactory.UpdateTemporaryNode(selectedItem.Node, newPath);
var parent = selectedItem.Parent;
this.DeleteTreeViewEntryItemModel(selectedItem);
selectedItem = this.CreateTreeViewEntryItemModel(newNode, parent, true);
this.FilesPatternProvider.AddAdditionalPath(newPath);
FileSystemOperationsService.CreateDirectory(newPath);
}
catch (Exception e)
{
if (newNode != null)
{
newNode.Remove();
}
if (selectedItem != null)
{
this.DeleteTreeViewEntryItemModel(selectedItem);
}
this.PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to create directory '" + newPath + "': " + e.Message);
}
}
else if (selectedItem.NodeType == NodeType.File)
{
try
{
newNode = this.DocumentHierarchyFactory.UpdateTemporaryNode(selectedItem.Node, newPath);
var parent = selectedItem.Parent;
this.DeleteTreeViewEntryItemModel(selectedItem);
selectedItem = this.CreateTreeViewEntryItemModel(newNode, parent, true);
this.FilesPatternProvider.AddAdditionalPath(newPath);
FileSystemOperationsService.CreateFile(newPath);
this.IseIntegrator.GoToFile(newPath);
}
catch (Exception e)
{
if (newNode != null)
{
newNode.Remove();
}
if (selectedItem != null)
{
this.DeleteTreeViewEntryItemModel(selectedItem);
}
this.PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to create file '" + newPath + "': " + e.Message);
}
}
}
public void EndTreeEdit(string newValue, bool save, TreeViewEntryItemModel selectedItem, bool addFileExtension)
{
if (selectedItem == null)
{
return;
}
selectedItem.IsBeingEdited = false;
if (selectedItem.NodeType == NodeType.File && addFileExtension && !String.IsNullOrEmpty(newValue) && !FilesPatternProvider.DoesFileMatch(newValue))
{
newValue += ".ps1";
}
if (selectedItem.IsBeingAdded)
{
selectedItem.IsBeingAdded = false;
EndAddingTreeItem(newValue, save, selectedItem);
}
else
{
EndRenamingTreeItem(newValue, save, selectedItem);
}
}
private void EndAddingTreeItem(string newValue, bool save, TreeViewEntryItemModel selectedItem)
{
if (!save || String.IsNullOrEmpty(newValue))
{
DocumentHierarchyFactory.RemoveTemporaryNode(selectedItem.Node);
DeleteTreeViewEntryItemModel(selectedItem);
return;
}
var newPath = GenerateNewPath(selectedItem.Path, newValue);
INode newNode = null;
if (FindTreeViewEntryItemByPath(newPath) != null)
{
DocumentHierarchyFactory.RemoveTemporaryNode(selectedItem.Node);
DeleteTreeViewEntryItemModel(selectedItem);
MessageBoxHelper.ShowError("Item '" + newPath + "' already exists.");
return;
}
if (selectedItem.NodeType == NodeType.Directory)
{
try
{
newNode = DocumentHierarchyFactory.UpdateTemporaryNode(selectedItem.Node, newPath);
var parent = selectedItem.Parent;
DeleteTreeViewEntryItemModel(selectedItem);
selectedItem = CreateTreeViewEntryItemModel(newNode, parent, true);
FilesPatternProvider.AddAdditionalPath(newPath);
FileSystemOperationsService.CreateDirectory(newPath);
}
catch (Exception e)
{
if (newNode != null)
{
newNode.Remove();
}
if (selectedItem != null)
{
DeleteTreeViewEntryItemModel(selectedItem);
}
PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to create directory '" + newPath + "': " + e.Message);
}
}
else if (selectedItem.NodeType == NodeType.File)
{
try
{
newNode = DocumentHierarchyFactory.UpdateTemporaryNode(selectedItem.Node, newPath);
var parent = selectedItem.Parent;
DeleteTreeViewEntryItemModel(selectedItem);
selectedItem = CreateTreeViewEntryItemModel(newNode, parent, true);
FilesPatternProvider.AddAdditionalPath(newPath);
FileSystemOperationsService.CreateFile(newPath);
IseIntegrator.GoToFile(newPath);
}
catch (Exception e)
{
if (newNode != null)
{
newNode.Remove();
}
if (selectedItem != null)
{
DeleteTreeViewEntryItemModel(selectedItem);
}
PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to create file '" + newPath + "': " + e.Message);
}
}
}
public TreeViewEntryItemModel CreateTreeViewEntryItemModel(INode node, TreeViewEntryItemModel parent, bool isSelected)
{
if (node == null)
{
return null;
}
var lockObject = parent == null ? TreeViewEntryItemModel.RootLockObject : parent;
lock (lockObject)
{
var item = new TreeViewEntryItemModel(node, parent, isSelected, this.iconProvider);
this.itemsMap[node.Path] = item;
if (node.NodeType == NodeType.File)
{
lock (TreeViewEntryItemModel.RootLockObject)
{
this.NumberOfFiles++;
}
}
return item;
}
}
public void MoveTreeItem(TreeViewEntryItemModel movedItem, TreeViewEntryItemModel destinationItem, string rootDirectory)
{
if (movedItem == destinationItem)
{
return;
}
if (!HandleUnsavedFileManipulation(movedItem))
{
return;
}
string destPath = destinationItem != null ? destinationItem.Path : rootDirectory;
if (!MessageBoxHelper.ShowConfirmMessage(String.Format("Please confirm you want to move '{0}' to '{1}'.", movedItem.Path, destPath)))
{
return;
}
try
{
string newPath;
// moved to the empty place, i.e. to the workspace directory
if (destinationItem == null)
{
newPath = GenerateNewPathForDir(rootDirectory, movedItem.Name);
}
else if (destinationItem.NodeType == NodeType.File)
{
newPath = GenerateNewPath(destinationItem.Path, movedItem.Name);
}
else if (destinationItem.NodeType == NodeType.Directory)
{
newPath = GenerateNewPathForDir(destinationItem.Path, movedItem.Name);
}
else
{
return;
}
FilesPatternProvider.RemoveAdditionalPath(movedItem.Path);
FilesPatternProvider.AddAdditionalPath(newPath);
bool closed = IseIntegrator.CloseFile(movedItem.Path);
FileSystemOperationsService.RenameFileOrDirectory(movedItem.Path, newPath);
if (closed)
{
IseIntegrator.GoToFile(newPath);
}
if (destinationItem != null)
{
destinationItem.IsExpanded = true;
}
}
catch (Exception e)
{
PathOfItemToSelectOnRefresh = null;
MessageBoxHelper.ShowError("Failed to move: " + e.Message);
}
}
public void AddNewTreeItem(TreeViewEntryItemModel parent, NodeType nodeType)
{
if (DocumentHierarchyFactory == null)
{
return;
}
if (parent == null)
{
parent = RootTreeViewEntryItem;
}
parent.IsExpanded = true;
INode newNode = DocumentHierarchyFactory.CreateTemporaryNode(parent.Node, nodeType);
if (newNode == null)
{
return;
}
var newItem = CreateTreeViewEntryItemModel(newNode, parent, true);
newItem.IsBeingEdited = true;
newItem.IsBeingAdded = true;
}
public void OpenItem(TreeViewEntryItemModel item, string searchText)
{
if (IseIntegrator == null)
{
throw new InvalidOperationException("IseIntegrator has not ben set yet.");
}
if (item == null)
{
return;
}
if (item.Node.NodeType == NodeType.File)
{
bool wasOpen = (IseIntegrator.SelectedFilePath == item.Node.Path);
if (!wasOpen)
{
IseIntegrator.GoToFile(item.Node.Path);
}
else
{
IseIntegrator.SetFocusOnCurrentTab();
}
if (searchText != null && searchText.Length > 2)
{
EditorInfo editorInfo = (wasOpen ? IseIntegrator.GetCurrentLineWithColumnIndex() : null);
TokenPosition tokenPos = TokenLocator.LocateNextToken(item.Node.Path, searchText, editorInfo);
if (tokenPos.MatchLength > 2)
{
IseIntegrator.SelectText(tokenPos.Line, tokenPos.Column, tokenPos.MatchLength);
}
else if (string.IsNullOrEmpty(IseIntegrator.SelectedText))
{
tokenPos = TokenLocator.LocateSubtoken(item.Node.Path, searchText);
if (tokenPos.MatchLength > 2)
{
IseIntegrator.SelectText(tokenPos.Line, tokenPos.Column, tokenPos.MatchLength);
}
}
}
}
else if (item.Node.NodeType == NodeType.Function)
{
var node = ((PowershellItemNode)item.Node);
IseIntegrator.GoToFile(node.FilePath);
IseIntegrator.SelectText(node.PowershellItem.StartLine, node.PowershellItem.StartColumn, node.Name.Length);
}
else if (item.Node.NodeType == NodeType.Directory)
{
item.IsExpanded = !item.IsExpanded;
}
}
public void DeleteTreeViewEntryItemModel(TreeViewEntryItemModel item, bool first = true)
{
if (item == this.RootTreeViewEntryItem || item == null)
{
return;
}
var lockObject = item.Parent == null ? TreeViewEntryItemModel.RootLockObject : item.Parent;
IList<TreeViewEntryItemModel> children;
lock (lockObject)
{
this.itemsMap.Remove(item.Path);
if (item.NodeType == NodeType.File)
{
lock (TreeViewEntryItemModel.RootLockObject)
{
this.NumberOfFiles--;
}
}
children = new List<TreeViewEntryItemModel>(item.Children);
}
foreach (var child in children)
{
this.DeleteTreeViewEntryItemModel(child, false);
}
if (first)
{
item.Delete();
}
}
private TreeViewEntryItemModel CreateTreeViewEntryItemModel(INode node, TreeViewEntryItemModel parent, bool isSelected)
{
var lockObject = parent == null ? TreeViewEntryItemModel.RootLockObject : parent;
lock (lockObject)
{
var item = new TreeViewEntryItemModel(node, parent, isSelected);
ItemsMap[node.Path] = item;
if (node.NodeType == NodeType.File)
{
lock (TreeViewEntryItemModel.RootLockObject)
{
NumberOfFiles++;
}
}
return item;
}
}
