public ModelChangedEventArgs( ITreeItem item )
{
ItemsAffected = new[ ]
{
item
} ;
}
//-------------------------------------------------------------------------------------
void treeView_SelectedNodeChanged(object sender, ITreeItem item)
{
if(isOkEnabled == null)
ButtonOkEnabled = item != null;
else
ButtonOkEnabled = item == null ? false : isOkEnabled(item);
}
//-------------------------------------------------------------------------------------
/// <summary>
/// Инициализирующий конструктор.
/// </summary>
/// <param name="hasChildren">Определяет, имеются ли дочерние элементы.</param>
/// <param name="item">Элемент дерева, для которого определяется наличие дочерних элементов.</param>
/// <param name="tree">Дерево</param>
public SimTreeGridItemEventArgs(ITree tree, ITreeItem item, bool hasChildren)
: this()
{
Item = item;
HasChildren = hasChildren;
Tree = tree;
}
public ItemSelectorControl( ITreeItem itemEditor )
{
ItemEditor = itemEditor ;
InitializeComponent( ) ;
_levelExplorer = new LevelExplorerControl
{
Dock = DockStyle.Fill,
Parent = this,
CheckBoxes= false,
Visible = true,
ShowToolStrip = false,
HideContextMenus=true,
InteractsWithModel=false
} ;
_levelExplorer.ItemSelected += ( s, e ) =>
{
if( e.Item is ItemEditor )
{
ItemEditor = e.Item as ItemEditor ;
}
} ;
Controls.Add( _levelExplorer );
_levelExplorer.Refresh( );
}
public void Select(ModifierKeys modifierKey, ICollection<ITreeItem> rootTreeItems, ITreeItem newSelectedItem, ITreeItem oldSelectedItem)
{
switch (modifierKey)
{
case ModifierKeys.Shift:
if(_previousSelectionWasShift)
{
_rangeSelector.Select(rootTreeItems, newSelectedItem, _previousShiftSelection);
}
else
{
_rangeSelector.Select(rootTreeItems, newSelectedItem, oldSelectedItem);
_previousShiftSelection = oldSelectedItem;
}
_previousSelectionWasShift = true;
break;
case ModifierKeys.Control:
_previousSelectionWasShift = false;
_inverseSelector.Select(rootTreeItems, newSelectedItem);
break;
default:
_previousSelectionWasShift = false;
_nullSelector.Select(rootTreeItems, newSelectedItem);
break;
}
}
public void Select(ICollection<ITreeItem> items, ITreeItem item)
{
var flattenedItems = _hierarchyFlattener.Flatten(items);
foreach (var treeItem in flattenedItems)
{
treeItem.IsSelected2 = treeItem == item;
}
}
public void SelectItem(ITreeItem item)
{
if (_oldSelectedItem == null)
{
_oldSelectedItem = item;
}
_multiSelector.Select(Keyboard.Modifiers, _treeItems, item, _oldSelectedItem);
_oldSelectedItem = item;
SelectedItems = GetSelectedItems();
}
//-------------------------------------------------------------------------------------
#region << Controls Handlers>>
private void ftvTree_SelectedNodeChanged(object sender, ITreeItem item)
{
if(item == null)
{
propertyGrid.SelectedObject = null;
lblEditSortOrder.Value = string.Empty;
return;
}
propertyGrid.SelectedObject = item;
lblEditSortOrder.Value = item.SortOrder == null ? string.Empty : item.SortOrder.ToString();
}
public void FindCommonAncestor_TwoSiblings_ReturnsParent()
{
var parentFolder = new Folder("Parent Folder Name");
var sibling1 = new Folder("Sibling 1", parentFolder);
var sibling2 = new Folder("Sibling 2", parentFolder);
ITreeItem commonAncestor = sibling1.FindCommonAncestor(sibling2);
commonAncestor.ShouldEqual(parentFolder);
}
private void AddChildren(ITreeItem rootTreeItem)
{
if (rootTreeItem.Children != null && rootTreeItem.IsExpanded)
{
foreach (var child in rootTreeItem.Children)
{
_denormalizedItems.Add(child);
AddChildren(child);
}
}
}
public void AddTo(ITreeItem dest, ITreeItem item)
{
var treeNode = GetTreeNode(item);
var destNode = GetTreeNode(dest);
if (treeNode != null && destNode != null)
{
treeNode.Nodes.Add(destNode);
}
}
private void AddChildren(ITreeItem rootTreeItem)
{
if (rootTreeItem.Children != null)
{
foreach (var child in rootTreeItem.Children)
{
_denormalizedItems.Add(child);
AddChildren(child);
}
}
}
public void WhenDroppedOntoEditor(ICanvas canvas, DraggingContext context)
{
ITreeItem itemEditor = canvas.ItemUnderMouse;
if (itemEditor == null)
{
return;
}
IoC.Model.AttachBehaviour(itemEditor, _buildBehaviour(itemEditor));
}
public void WhenBeingDraggedOverEditor(ICanvas canvas, DraggingContext draggingContext)
{
ITreeItem itemEditor = canvas.ItemUnderMouse;
if (itemEditor == null)
{
draggingContext.DragEventArgs.Effect = DragDropEffects.None;
}
draggingContext.DragEventArgs.Effect = DragDropEffects.Link;
}
protected List <ITreeItem> GetDescendants(ITreeItem parent)
{
List <ITreeItem> list = new List <ITreeItem>();
foreach (ITreeItem child in parent.Children)
{
list.Add(child);
list.AddRange(GetDescendants(child));
}
return(list);
}
public static void SelectNextParentItem(ITreeItem parent)
{
var parentParent = parent.GetParent() as ITreeItem;
int parentIndex = parentParent.GetItemIndex(parent);
int parentCount = parentParent.GetItemsCount();
if (parentCount > 0 && parentIndex < parentCount - 1)
{
SelectFirstItemInNextProject(parentParent, parentIndex);
}
}
public static void SelectFirstItemInNextProject(ITreeItem parentParent, int parentIndex)
{
var parentProject = parentParent.GetItem(parentIndex + 1);
if (parentProject.GetItemsCount() > 0)
{
var item = parentProject.GetItem(0);
item.SetSelected(true);
item.PushIntoView();
}
}
public static void SelectPreviousParentItem(ITreeItem parent)
{
var parentParent = parent.GetParent() as ITreeItem;
int parentIndex = parentParent.GetItemIndex(parent);
int parentCount = parentParent.GetItemsCount();
if (parentCount > 0 && parentIndex > 0)
{
SelectLastItemInPreviousProject(parentParent, parentIndex);
}
}
static IEnumerable <ITreeItem> GetParents(ITreeItem item)
{
var parent = item.Parent;
while (parent != null)
{
yield return(parent);
parent = parent.Parent;
}
}
public TestDocument(
string path = "", string name = "",
IProject project = null, ITreeItem treeItem = null)
{
this.path = path;
this.name = name;
this.project = project;
this.treeItem = treeItem;
ResetCaption();
}
private static void SetHiddenItems(ITreeItem item, int[] hashs)
{
item.Visible = !hashs.Contains(item.GetHashCode());
if (item.Children == null)
{
return;
}
foreach (ITreeItem child in item.Children)
{
SetHiddenItems(child, hashs);
}
}
swf.TreeNode GetTreeNode(ITreeItem item)
{
if (item.Key == null)
{
return(EnumerateNodes(Control.Nodes).FirstOrDefault(r => object.ReferenceEquals(r.Tag, item)));
}
else
{
var nodes = Control.Nodes.Find(item.Key, true);
return(nodes.FirstOrDefault(r => object.ReferenceEquals(item, r.Tag)));
}
}
public void Select(ICollection <ITreeItem> items, ITreeItem item)
{
var flattenedItems = _hierarchyFlattener.Flatten(items);
foreach (var treeItem in flattenedItems)
{
if (item == treeItem)
{
item.IsSelected2 = item.IsSelected2 ? false : true;
}
}
}
private void MotionListView_ItemMoved(ITreeItem item, ITreeFolder oldParent, ITreeFolder newParent, int index)
{
MotionItemBase itemData = ((MotionItemBaseView)item).Data;
MotionFolderItemView newParentFolderView = (MotionFolderItemView)newParent;
if (oldParent != null)
{
MotionFolderItemView oldParentFolderView = (MotionFolderItemView)oldParent;
oldParentFolderView.Data.RemoveChild(itemData);
}
newParentFolderView.Data.InsertChild(index, itemData);
}
public void FindCommonAncestor_ItsOwnGrandParent_ReturnsGrandParent()
{
var grandParentFolder = new Folder("Grand Parent Folder Name");
var parentFolder = new Folder("Parent Folder Name", grandParentFolder);
var folder = new Folder("Folder Name", parentFolder);
ITreeItem commonAncestor = folder.FindCommonAncestor(grandParentFolder);
commonAncestor.ShouldEqual(grandParentFolder);
}
public void RefreshItem(ITreeItem item)
{
Control.FindTreeViewItem(item).ContinueWith(r =>
{
if (r.IsCompleted)
{
var sel = SelectedItem;
RefreshItem(r.Result);
SelectedItem = sel;
}
}, TaskScheduler.FromCurrentSynchronizationContext());
}
void RemoveSection(Server server, ITreeItem item)
{
var generator = item as ISectionGenerator;
if (generator != null)
{
var key = new Tuple <Server, string>(server, item.Key);
if (sectionCache.ContainsKey(key))
{
sectionCache.Remove(key);
}
}
}
private static void AddSubitem(ITreeItem item, bool isFile, string[] segments)
{
ITreeItem subRoot = item.Items.FirstOrDefault(i => segments[0] == i.Name);
if (subRoot == null)
{
item.Items.Add(new Item(item, segments, isFile));
}
else
{
AddSubitem(subRoot, isFile, segments.Skip(1).ToArray());
}
}
public void Remove(ITreeItem item)
{
if (item is TreeFolderBase)
{
Folders.Remove(item as TreeFolderBase);
Children.Remove(item);
}
else if (item is ITreeItem)
{
Items.Remove(item);
Children.Remove(item);
}
}
public static void SelectLastItemInPreviousProject(ITreeItem parentParent, int parentIndex)
{
var parentProject = parentParent.GetItem(parentIndex - 1);
int count = parentProject.GetItemsCount();
if (count > 0)
{
var item = parentProject.GetItem(count - 1);
item.SetSelected(true);
item.PushIntoView();
}
}
public bool IsDescendantOf(ITreeItem node)
{
if (parent == null)
{
return(false);
}
if (Parent == node)
{
return(true);
}
return(Parent.IsDescendantOf(node));
}
void showGrid(ITreeItem treeItem)
{
_currentItem = treeItem;
_grid.Visible = true;
_label.Visible = false;
var disposable = _grid.SelectedObject as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
_grid.SelectedObject = treeItem.ObjectForPropertyGrid;
}
public void MoveNodeToUnderParent(ITreeItem newParent, ITreeItem nodeToMove)
{
if (newParent == null)
{
throw new ArgumentNullException(nameof(newParent));
}
if (newParent.IsDescendantOf(nodeToMove))
{
return;
}
nodeToMove.Parent.RemoveChild(nodeToMove);
newParent.AddChild(nodeToMove);
}
IEnumerable <ITreeItem> ITreeItemDataSource.GetChildren(ITreeItem treeItem)
{
if (treeItem == null)
{
return(_rootItem.Children);
}
if (!(treeItem is SimpleTreeItem simpleTreeItem))
{
return(Enumerable.Empty <ITreeItem>());
}
return(simpleTreeItem.Children);
}
internal static List<ITreeItem> CreateHierarchy(ITreeItem treeItem)
{
var hierarchy = new List<ITreeItem>();
ITreeItem temp = treeItem;
while (temp != null)
{
hierarchy.Add(temp);
temp = temp.Parent;
}
return hierarchy;
}
/// <summary>
/// Removes node and all descendants from tree
/// </summary>
/// <param name="node">Node to remove</param>
protected void RemoveFromTree(ITreeItem node)
{
if (!allNodes.Contains(node))
{
return;
}
foreach (ITreeItem descendant in GetDescendants(node))
{
allNodes.Remove(descendant);
}
node.Selected -= OnTreeItemSelected;
allNodes.Remove(node);
}
public Item(ITreeItem parent, string[] segments, bool isFile)
{
Parent = parent;
Items = new List <ITreeItem>();
this.name = segments[0];
if (segments.Length > 1)
{
this.Items.Add(new Item(this, segments.Skip(1).ToArray(), isFile));
}
else
{
this.IsFolder = !isFile;
}
}
private void itemSelectorLoad(object sender, EventArgs e)
{
if (ItemEditor != null)
{
if (IoC.Model.Level.ContainsAnythingNamed(ItemEditor.Name))
{
_levelExplorer.SelectItemByName(ItemEditor.Name);
}
else
{
ItemEditor = null;
}
}
}
public static void AddDiagram(ITreeItem project,
bool select,
Func<ITreeItem> createDiagram,
IdCounter counter)
{
var diagram = CreateDiagramItem(null, createDiagram, counter);
project.Add(diagram);
ModelEditor.Store(null, diagram);
if (select == true)
diagram.SetSelected(true);
}
protected virtual Node OverflowTreatment(Node n, ITreeItem newItem)
{
SplitCount++;
var groups = Split(((IEnumerable <ITreeItem>)n).Concat(new[] { newItem }), n.Bounds.Union(newItem.Bounds));
n.Clear();
n.AddRange(groups.Item1.Item1, groups.Item1.Item2);
Node newNode = GetNewNode(n.Level);
newNode.AddRange(groups.Item2.Item1, groups.Item2.Item2);
return(newNode);
}
private void itemSelectorLoad( object sender, EventArgs e )
{
if( ItemEditor != null )
{
if (IoC.Model.Level.ContainsAnythingNamed(ItemEditor.Name))
{
_levelExplorer.SelectItemByName( ItemEditor.Name ) ;
}
else
{
ItemEditor = null;
}
}
}
private void OnSelectionChanged(ITreeItem item)
{
if (item != null)
{
if (item.IsSelected && !SelectedNodes.Contains(item))
{
SelectedNodes.Insert(0, item);
}
else
{
SelectedNodes.Remove(item);
}
}
}
private static void AddSelectedItemsFromChildren(ITreeItem treeItem, ICollection<object> selectedItems)
{
if(treeItem.Children != null)
{
foreach (var child in treeItem.Children)
{
if (child.IsSelected2)
{
var dataContext = ((TreeViewItem) treeItem).DataContext;
selectedItems.Add(dataContext);
}
AddSelectedItemsFromChildren(child, selectedItems);
}
}
}
public void Expand(ITreeItem treeItem)
{
var root = treeItem;
var catchTreeItem = new List<ITreeItem>();
while (true)
{
if (root == null)
break;
catchTreeItem.Insert(0, root);
root = root.Parent;
}
foreach (var item in catchTreeItem)
{
(item as TreeItem).Expanded = true;
}
}
public ITreeItem FindCommonAncestor(ITreeItem other)
{
if (other == null) throw new ArgumentNullException("other");
if (Parent == other)
{
return Parent;
}
else
{
List<ITreeItem> myHierarchy = TreeItemHelper.CreateHierarchy(this);
List<ITreeItem> othersHierarchy = TreeItemHelper.CreateHierarchy(other);
IEnumerable<ITreeItem> intersection = myHierarchy.Intersect(othersHierarchy);
return intersection.FirstOrDefault();
}
}
IBehaviour buildBehaviour( ITreeItem forItem )
{
ItemProperties itemProperties = forItem.ItemProperties;
var interpolationBehaviour = new PositionAnimationBehaviour(
itemProperties,
new PositionAnimationBehaviourProperties
{
DurationInSeconds = .75f,
Easing = Easing.EaseInOut,
From = itemProperties.Position,
To = Vector2.Zero,
Name = @"movement_animation_{0}".FormatWith(IoC.Model.NextItemNumber),
NameOfPropertyToModify = @"Position",
ClrTypeOfInterpolator = typeof(Quartic).AssemblyQualifiedName,
});
return interpolationBehaviour ;
}
IBehaviour buildBehaviour(ITreeItem forEditor)
{
ItemProperties itemProperties = forEditor.ItemProperties ;
var behaviour = new ScaleAnimationBehaviour(
itemProperties,
new FloatAnimationBehaviourProperties
{
DurationInSeconds = .75f,
Easing = Easing.EaseInOut,
From = 1,
To = 2,
Name = @"scale_animation_{0}".FormatWith( IoC.Model.NextItemNumber ),
NameOfPropertyToModify = @"Scale",
ClrTypeOfInterpolator = typeof( Quartic ).AssemblyQualifiedName
} ) ;
return behaviour ;
}
public void Select(ICollection<ITreeItem> rootItems, ITreeItem item1, ITreeItem item2)
{
var flatItemsList = _hierarchyFlattener.Flatten(rootItems).ToList();
var indexOfItem1 = flatItemsList.IndexOf(item1);
var indexOfItem2 = flatItemsList.IndexOf(item2);
ITreeItem firstItem;
ITreeItem secondItem;
if(indexOfItem1 < indexOfItem2)
{
firstItem = item1;
secondItem = item2;
}
else
{
firstItem = item2;
secondItem = item1;
}
var firstItemFound = false;
var secondItemFound = false;
foreach (var treeItem in flatItemsList)
{
if (treeItem == firstItem)
{
firstItemFound = true;
}
if (firstItemFound && !secondItemFound)
{
treeItem.IsSelected2 = true;
}
else
{
treeItem.IsSelected2 = false;
}
if (treeItem == secondItem)
{
secondItemFound = true;
}
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//-------------------------------------------------------------------------------------
#region << Constructors >>
/// <summary>
/// Инициализирующий конструктор.
/// </summary>
/// <param name="item">Объект данных, для элемента которого определяется индекс изображения.</param>
/// <param name="imageIndex">Индекс изображения.</param>
public NeedImageIndexEventArgs(ITreeItem item, int imageIndex) : base ()
{
this.item = item;
this.imageIndex = imageIndex;
}
/// <summary>
/// Метод, вызывающий событие SelectedNodeChanged.
/// </summary>
/// <param name="item">Элемент дерева.</param>
protected void OnSelectedNodeChanged(ITreeItem item)
{
if(SelectedNodeChanged != null)
SelectedNodeChanged(this, item);
}
/// <summary>
/// Метод, вызывающий событие SelectedNodeChanging.
/// </summary>
/// <param name="item">Элемент дерева.</param>
protected bool OnSelectedNodeChanging(ITreeItem item)
{
if(SelectedNodeChanging != null)
{
CancelEventArgs<object> args = new CancelEventArgs<object>(item);
SelectedNodeChanging(this, args);
return args.Cancel;
}
else
return false;
}
//-------------------------------------------------------------------------------------
/// <summary>
/// Возвращает узел с заданным элементом дерева.
/// </summary>
public SimTreeNode FindNode(ITreeItem item)
{
if(tree.Contains(item) == false)
return null;
return treeView.Nodes.Find(item);
}
/// <summary>
/// Сворачивает узел указанного элемента.
/// </summary>
/// <param name="item">Элемент сворачиваемого узла.</param>
public void CollapseAll(ITreeItem item)
{
try
{
treeView.BeginUpdate();
SelectNodeWithItem(item);
treeView.SelectedNode.Collapse();
treeView.EndUpdate();
}
catch(Exception Err)
{
ErrorBox.Show(Err);
}
}
//-------------------------------------------------------------------------------------
/// <summary>
/// Разворачивает узел указанного элемента.
/// </summary>
/// <param name="item">Элемент разворачиваемого узла.</param>
public void Expand(ITreeItem item)
{
try
{
treeView.BeginUpdate();
SimTreeNodeCollection nodes = treeView.Nodes;
foreach(ITreeItem pid in tree.GetParentsItemsList(item))
{
nodes[pid].Expand();
nodes = nodes[pid].Nodes;
}
nodes[item].Expand();
nodes[item].EnsureVisible();
treeView.EndUpdate();
}
catch(Exception Err)
{
ErrorBox.Show(Err);
}
}
/// <summary>
/// Вызывает событие CanDropItem.
/// </summary>
protected virtual bool OnCanDropItem(ITreeItem droppedItem, ITreeItem destItem)
{
if(_CanDropItem != null)
{
DragDropItemEventArgs arg = new DragDropItemEventArgs(droppedItem, destItem);
_CanDropItem.Raise(this, arg);
return !arg.Cancel;
}
return true;
}
/// <summary>
/// Метод, вызывающий событие NodeDoubleClick.
/// </summary>
/// <param name="item">Элемент дерева.</param>
protected void OnNodeDoubleClick(ITreeItem item)
{
if(NodeDoubleClick != null)
NodeDoubleClick(this, item);
}
/// <summary>
/// Инициализирующий конструктор.
/// </summary>
/// <param name="droppedItem">Перетаскиваемый элемент</param>
/// <param name="destItem">Элемент назначения</param>
public DragDropItemEventArgs(ITreeItem droppedItem, ITreeItem destItem)
: base(false)
{
DroppedItem = droppedItem;
DestItem = destItem;
}
//-------------------------------------------------------------------------------------
/// <summary>
/// Активирует узел с заданным элементом дерева.
/// </summary>
/// <param name="item">Элемент дерева активируемого узла.</param>
public void SelectNodeWithItem(ITreeItem item)
{
SelectNodeWithItem(item, false);
}
/// <summary>
/// Вызывает событие ItemDropped.
/// </summary>
protected virtual void OnItemDropped(ITreeItem droppedItem, ITreeItem destItem)
{
if(_ItemDropped != null)
_ItemDropped.Raise(this, new DragDropItemEventArgs(droppedItem, destItem));
}
/// <summary>
/// Активирует узел с заданным элементом дерева.
/// </summary>
/// <param name="item">Элемент дерева активируемого узла.</param>
/// <param name="expand">Определяет, будет ли активируемый узел развернут.</param>
public void SelectNodeWithItem(ITreeItem item, bool expand)
{
try
{
if(tree == null)
return;
if(item == null)
{
treeView.SelectedNode = null;
OnSelectedNodeChanged(null);
return;
}
if(!tree.Contains(item))
throw new ArgumentException(String.Format("Позиция № {0} не найдена!", item));
IList pids = tree.GetParentsItemsList(item);
SimTreeNodeCollection nodes = treeView.Nodes;
foreach(ITreeItem pos in pids)
{
if(!nodes.ContainsItem(pos))
throw new ArgumentException(String.Format("Позиция № {0} отсутствует в текущем дереве!", item));
nodes[pos].Expand();
nodes = nodes[pos].Nodes;
}
if(!nodes.ContainsItem(item))
throw new ArgumentException(String.Format("Позиция № {0} отсутствует в текущем дереве!", item));
treeView.SelectedNode = nodes[item];
if(expand)
treeView.SelectedNode.Expand();
nodes[item].EnsureVisible();
treeView.Select();
treeView.Focus();
}
catch(Exception Err)
{
ErrorBox.Show(Err);
}
}