public void HandleDragOver(object sender, DragEventArgs e, BaseTreeViewItem treeViewItem)
{
Assert.ArgumentNotNull(sender, nameof(sender));
Assert.ArgumentNotNull(e, nameof(e));
Assert.ArgumentNotNull(treeViewItem, nameof(treeViewItem));
adorner.AllowedPositions = ControlDragAdornerPosition.None;
if (e.Data.GetDataPresent(LayoutDesigner.DragIdentifier))
{
adorner.AllowedPositions = ControlDragAdornerPosition.Top | ControlDragAdornerPosition.Bottom;
var h = adorner.GetHitTest(e);
e.Effects = (h & adorner.AllowedPositions) != ControlDragAdornerPosition.None ? DragDropEffects.Move : DragDropEffects.None;
/*
* if (e.Effects == DragDropEffects.Move && (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
* {
* e.Effects = DragDropEffects.Copy;
* }
*/
}
else if (e.Data.GetDataPresent(DragManager.DragIdentifier))
{
adorner.AllowedPositions = ControlDragAdornerPosition.Top | ControlDragAdornerPosition.Bottom;
var h = adorner.GetHitTest(e);
e.Effects = (h & adorner.AllowedPositions) != ControlDragAdornerPosition.None ? DragDropEffects.Copy : DragDropEffects.None;
}
else if (e.Data.GetDataPresent(BindingAnchor.BindingAnchorDragIdentifier))
{
var anchor = (BindingAnchor)e.Data.GetData(BindingAnchor.BindingAnchorDragIdentifier);
anchor.HandleDragOver(this, e);
}
}
private bool IsLockedItem([NotNull] BaseTreeViewItem baseTreeViewItem)
{
Debug.ArgumentNotNull(baseTreeViewItem, nameof(baseTreeViewItem));
var item = baseTreeViewItem as ItemTreeViewItem;
if (item == null)
{
return(false);
}
foreach (var gutter in item.Item.Gutters)
{
if (gutter.Icon.IconPath.EndsWith(@"Network/16x16/lock.png", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
if (gutter.Icon.IconPath.EndsWith(@"People/16x16/user1_lock.png", StringComparison.OrdinalIgnoreCase))
{
return(true);
}
}
return(false);
}
private void Opened([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
var item = Context.SelectedItems.FirstOrDefault() as ItemTreeViewItem;
if (item == null)
{
return;
}
var menuItem = e.Source as MenuItem;
if (menuItem == null)
{
return;
}
menuItem.Items.Clear();
BaseTreeViewItem siteItem = item;
while (siteItem != null && !(siteItem is SiteTreeViewItem))
{
siteItem = siteItem.Parent as BaseTreeViewItem;
}
if (siteItem == null)
{
return;
}
var databaseName = item.ItemUri.DatabaseName.ToString();
foreach (var child in siteItem.Items)
{
var databaseItem = child as DatabaseTreeViewItem;
if (databaseItem == null)
{
continue;
}
var name = databaseItem.DatabaseUri.DatabaseName.ToString();
if (name == databaseName)
{
continue;
}
var m = new MenuItem
{
Header = name,
Tag = new ItemUri(databaseItem.DatabaseUri, item.ItemUri.ItemId)
};
m.Click += NavigateItem;
menuItem.Items.Add(m);
}
}
public void HandleDrop(object sender, DragEventArgs e, BaseTreeViewItem treeViewItem)
{
Assert.ArgumentNotNull(sender, nameof(sender));
Assert.ArgumentNotNull(e, nameof(e));
Assert.ArgumentNotNull(treeViewItem, nameof(treeViewItem));
if (e.Data.GetDataPresent(LayoutDesigner.DragIdentifier))
{
/*
* if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
* {
* this.CopyRenderings(e);
* }
* else
* {
* this.DropRenderings(e);
* }
*/
DropRenderings(e);
e.Handled = true;
}
else if (e.Data.GetDataPresent(DragManager.DragIdentifier))
{
DropItems(e);
e.Handled = true;
}
else if (e.Data.GetDataPresent(BindingAnchor.BindingAnchorDragIdentifier))
{
var anchor = (BindingAnchor)e.Data.GetData(BindingAnchor.BindingAnchorDragIdentifier);
anchor.HandleDrop(this, e);
e.Handled = true;
}
}
public ScopeDescriptor([NotNull] MultiSelectTreeView treeView, [CanBeNull] BaseTreeViewItem item)
{
Assert.ArgumentNotNull(treeView, nameof(treeView));
TreeView = treeView;
Item = item;
}
private Visibility Filter([NotNull] BaseTreeViewItem item, [NotNull] string text)
{
Debug.ArgumentNotNull(item, nameof(item));
Debug.ArgumentNotNull(text, nameof(text));
var isVisible = false;
foreach (var o in item.Items)
{
var child = o as BaseTreeViewItem;
if (child == null)
{
continue;
}
var v = Filter(child, text);
if (v == Visibility.Visible)
{
isVisible = true;
}
}
item.Visibility = isVisible || item.Text.IsFilterMatch(text) ? Visibility.Visible : Visibility.Collapsed;
return(item.Visibility);
}
private void FilterChildren([NotNull] object sender, [NotNull] BaseTreeViewItem baseTreeviewItem, [NotNull] List <BaseTreeViewItem> children)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(baseTreeviewItem, nameof(baseTreeviewItem));
Debug.ArgumentNotNull(children, nameof(children));
if (DisableExclusions)
{
return;
}
for (var index = children.Count - 1; index >= 0; index--)
{
var child = children[index] as ItemTreeViewItem;
if (child == null)
{
continue;
}
if (!CanDisplay(child.Item))
{
children.Remove(child);
}
}
}
private void GetChildren([NotNull] object sender, [NotNull] BaseTreeViewItem baseTreeViewItem, [NotNull] List <BaseTreeViewItem> children)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(baseTreeViewItem, nameof(baseTreeViewItem));
Debug.ArgumentNotNull(children, nameof(children));
var siteTreeViewItem = baseTreeViewItem as SiteTreeViewItem;
if (siteTreeViewItem != null)
{
for (var index = children.Count - 1; index >= 0; index--)
{
var child = children[index];
if (!(child is DatabaseTreeViewItem))
{
children.Remove(child);
}
}
}
var databaseTreeViewItem = baseTreeViewItem as DatabaseTreeViewItem;
if (databaseTreeViewItem != null)
{
children.Clear();
}
}
private void ShiftSelect([NotNull] ItemCollection items, [NotNull] BaseTreeViewItem item0, [NotNull] BaseTreeViewItem item1, ref bool select)
{
Debug.ArgumentNotNull(items, nameof(items));
Debug.ArgumentNotNull(item0, nameof(item0));
Debug.ArgumentNotNull(item1, nameof(item1));
foreach (var i in items)
{
var item = i as BaseTreeViewItem;
if (item == null)
{
continue;
}
if (item.Equals(item0) || item.Equals(item1))
{
select = !select;
Select(item);
}
else if (select)
{
Select(item);
}
ShiftSelect(item.Items, item0, item1, ref select);
}
}
public BaseTreeViewItem GetItem([CanBeNull] BaseTreeViewItem parent)
{
var result = new SavedTreeViewItem();
result.Items.Add(DummyTreeViewItem.Instance);
return(result);
}
public BaseTreeViewItem GetItem(BaseTreeViewItem parent)
{
var result = new LibrariesRootTreeViewItem();
result.Items.Add(DummyTreeViewItem.Instance);
return(result);
}
public override IEnumerable <BaseTreeViewItem> BuildChildrenTreeViewItemsOf(BaseTreeViewItem parent)
{
switch (parent)
{
case CSharpVersionTreeViewItem csharpVersionTreeViewItem:
return(AnalysisResults
.Where(result => result.Suggestion.MinimumLanguageVersion == csharpVersionTreeViewItem.CSharpVersion)
.Select(result => result.Suggestion)
.Distinct()
.OrderBy(suggestion => suggestion.FriendlyName)
.Select(suggestion => new SuggestionTreeViewItem
(
parent,
this,
AnalysisResults.Count(result => result.Suggestion == suggestion),
suggestion
)));
case SuggestionTreeViewItem suggestionTreeViewItem:
return(AnalysisResults
.Where(result => result.Suggestion == suggestionTreeViewItem.Suggestion)
.GroupBy(suggestion => new { suggestion.AnalysisContext.ProjectName, suggestion.FilePath })
.OrderBy(group => group.Key.ProjectName)
.ThenBy(group => group.Key.FilePath)
.Select(group => new FilePathTreeViewItem
(
parent,
this,
group.Count(),
// TODO: Inneficient and ugly workaround that will work so far.
// We will soon replace all the LINQ code in this method with an access to an optimized indexing structure.
AnalysisResults.First(result => result.AnalysisContext.ProjectName == group.Key.ProjectName && result.FilePath == group.Key.FilePath).AnalysisContext,
group.Key.FilePath
)));
case FilePathTreeViewItem filePathTreeViewItem:
var parentSuggestion = ((SuggestionTreeViewItem)filePathTreeViewItem.Parent).Suggestion;
return(AnalysisResults
.Where(result => result.Suggestion == parentSuggestion && result.AnalysisContext.ProjectName == filePathTreeViewItem.ProjectName && result.FilePath == filePathTreeViewItem.FilePath)
.OrderBy(suggestion => suggestion.Position.StartLinePosition.Line)
.ThenBy(suggestion => suggestion.Position.StartLinePosition.Character)
.Select(result => new SingleSuggestionTreeViewItem
(
parent,
this,
result
)));
default:
throw new ArgumentOutOfRangeException
(
nameof(parent),
$"The parent of the type {parent.GetType().Name} is not supported as a parent in the {nameof(CSharpVersionSuggestionFilePathTreeViewBuilder)}."
);
}
}
void ICanDrop.HandleDragOver(object sender, DragEventArgs e, BaseTreeViewItem treeViewItem)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
Debug.ArgumentNotNull(treeViewItem, nameof(treeViewItem));
if (e.Data.GetDataPresent(DragManager.DragIdentifier))
{
e.Effects = DragDropEffects.Copy;
}
}
private void Expand([NotNull] BaseTreeViewItem baseTreeViewItem)
{
Debug.ArgumentNotNull(baseTreeViewItem, nameof(baseTreeViewItem));
baseTreeViewItem.ExpandAndWait();
foreach (var item in baseTreeViewItem.Items.OfType <BaseTreeViewItem>())
{
Expand(item);
}
}
public bool CanAddItem(BaseTreeViewItem parent)
{
var item = parent as ItemTreeViewItem;
if (item == null)
{
return(false);
}
return(item.ItemUri.ItemId.ToGuid() == DatabaseTreeViewItem.RootItemGuid);
}
private void Collapse([NotNull] BaseTreeViewItem baseTreeViewItem)
{
Debug.ArgumentNotNull(baseTreeViewItem, nameof(baseTreeViewItem));
baseTreeViewItem.IsExpanded = false;
foreach (var item in baseTreeViewItem.Items.OfType <BaseTreeViewItem>())
{
Collapse(item);
}
}
private void SelectItem([NotNull] BaseTreeViewItem selected, bool acceptKeys)
{
Debug.ArgumentNotNull(selected, nameof(selected));
if (SelectionMode == SelectionMode.Single)
{
Clear();
selected.IsSelected = true;
}
else
{
var isShift = KeyboardManager.IsActive == 0 && acceptKeys && (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift));
var isCtrl = KeyboardManager.IsActive == 0 && acceptKeys && (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl));
if (!isCtrl && !isShift && SelectedItems.Count > 1 && selected.IsItemSelected)
{
selected.IsSelected = true;
}
else
{
if (!isCtrl)
{
SelectedItems.ForEach(delegate(BaseTreeViewItem f)
{
f.IsSelected = false;
f.IsItemSelected = false;
});
SelectedItems.Clear();
if (!isShift)
{
_lastSelectedItem = null;
}
}
if (isShift)
{
ShiftSelect(selected);
}
else
{
SingleSelect(selected);
}
}
}
var changed = SelectedItemsChanged;
if (changed != null)
{
changed(this, new RoutedPropertyChangedEventArgs <object>(null, null));
}
}
internal void InternalFilterChildren([NotNull] BaseTreeViewItem item, [NotNull] List <BaseTreeViewItem> children)
{
Debug.ArgumentNotNull(item, nameof(item));
Debug.ArgumentNotNull(children, nameof(children));
var getChildren = FilterChildren;
if (getChildren != null)
{
getChildren(this, item, children);
}
}
public GetChildrenPipeline WithParameters([NotNull] ICollection <BaseTreeViewItem> items, [CanBeNull] BaseTreeViewItem parentItem, [CanBeNull] string baseFolder)
{
Assert.ArgumentNotNull(items, nameof(items));
ParentItem = parentItem;
BaseFolder = baseFolder;
Items = items;
Start();
return(this);
}
private void GetChildren([NotNull] object sender, [NotNull] BaseTreeViewItem baseTreeViewItem, [NotNull] List <BaseTreeViewItem> children)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(baseTreeViewItem, nameof(baseTreeViewItem));
Debug.ArgumentNotNull(children, nameof(children));
var siteTreeViewItem = baseTreeViewItem as SiteTreeViewItem;
if (siteTreeViewItem != null)
{
children.Clear();
}
}
public int Compare(TreeViewItem x, TreeViewItem y)
{
var i = isAscending ? 1 : -1;
BaseTreeViewItem cx = (BaseTreeViewItem)x;
BaseTreeViewItem cy = (BaseTreeViewItem)y;
if (cx.info.isBatch != cy.info.isBatch)
{
return(cx.info.isBatch ? 1 : -1);
}
switch (Col)
{
case Column.Element:
if (cx.info.isBatch)
{
return(-1);
}
return(cx.displayName.CompareTo(cy.displayName) * i);
case Column.BatchCount:
if (cx.info.isBatch)
{
return(-1);
}
return(cx.info.batchCount.CompareTo(cy.info.batchCount) * i);
case Column.TotalBatchCount:
if (cx.info.isBatch)
{
return(-1);
}
return(cx.info.totalBatchCount.CompareTo(cy.info.totalBatchCount) * i);
case Column.VertexCount:
if (cx.info.isBatch)
{
return(cx.info.vertexCount.CompareTo(cy.info.vertexCount) * i);
}
// no * i, keep the canvas names ascending
return(String.CompareOrdinal(cx.displayName, cy.displayName));
case Column.TotalVertexCount:
return(cx.info.totalVertexCount.CompareTo(cy.info.totalVertexCount) * i);
case Column.GameObjectCount:
return(cx.info.instanceIDsCount.CompareTo(cy.info.instanceIDsCount) * i);
default:
throw new ArgumentOutOfRangeException();
}
}
void ICanDrop.HandleDrop(object sender, DragEventArgs e, BaseTreeViewItem treeViewItem)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
Debug.ArgumentNotNull(treeViewItem, nameof(treeViewItem));
if (e.Data.GetDataPresent(DragIdentifier))
{
var items = (List <BaseTreeViewItem>)e.Data.GetData(DragIdentifier);
DropSavedSearches(items);
}
e.Handled = true;
}
private void SingleSelect([NotNull] BaseTreeViewItem selected)
{
Debug.ArgumentNotNull(selected, nameof(selected));
if (selected.IsItemSelected)
{
selected.IsItemSelected = false;
SelectedItems.Remove(selected);
}
else
{
Select(selected);
_lastSelectedItem = selected;
}
}
private void ShiftSelect([NotNull] BaseTreeViewItem selected)
{
Debug.ArgumentNotNull(selected, nameof(selected));
var baseTreeViewItem = _lastSelectedItem;
if (baseTreeViewItem == null)
{
return;
}
var select = false;
ShiftSelect(Items, selected, baseTreeViewItem, ref select);
}
internal void Select([NotNull] BaseTreeViewItem selected)
{
Debug.ArgumentNotNull(selected, nameof(selected));
if (selected.Visibility == Visibility.Collapsed)
{
return;
}
selected.IsItemSelected = true;
if (!SelectedItems.Contains(selected))
{
SelectedItems.Add(selected);
}
}
void ICanDrop.HandleDragOver(object sender, DragEventArgs e, BaseTreeViewItem treeViewItem)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
Debug.ArgumentNotNull(treeViewItem, nameof(treeViewItem));
adorner.AllowedPositions = ControlDragAdornerPosition.None;
if (!e.Data.GetDataPresent(DragIdentifier))
{
return;
}
e.Effects = DragDropEffects.Move;
adorner.AllowedPositions = ControlDragAdornerPosition.Top | ControlDragAdornerPosition.Bottom;
}
public bool CanAddItem(BaseTreeViewItem parent)
{
var siteTreeViewItem = parent as SiteTreeViewItem;
if (siteTreeViewItem == null)
{
return(false);
}
if (siteTreeViewItem.Site.DataServiceName != HardRockWebService.Name)
{
return(false);
}
return(true);
}
public static IEnumerable <BaseTreeViewItem> GetChildren([CanBeNull] BaseTreeViewItem parent)
{
var result = new List <BaseTreeViewItem>();
foreach (var descriptor in virtualItems)
{
if (!descriptor.Instance.CanAddItem(parent))
{
continue;
}
var item = descriptor.Instance.GetItem(parent);
result.Add(item);
}
return(result);
}
public BaseTreeViewItem GetItem(BaseTreeViewItem parent)
{
var databaseItem = parent as ItemTreeViewItem;
if (databaseItem == null)
{
throw Exceptions.InvalidOperation();
}
var result = new MyItemsTreeViewItem
{
DatabaseUri = databaseItem.ItemUri.DatabaseUri
};
result.Items.Add(DummyTreeViewItem.Instance);
return(result);
}
void ICanDrop.HandleDrop(object sender, DragEventArgs e, BaseTreeViewItem treeViewItem)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
Debug.ArgumentNotNull(treeViewItem, nameof(treeViewItem));
if (!e.Data.GetDataPresent(DragManager.DragIdentifier))
{
return;
}
var baseItems = e.Data.GetData(DragManager.DragIdentifier) as IEnumerable <IItem>;
if (baseItems != null)
{
AddFavorites(baseItems, -1);
}
}
