private Guid FindBoundLayer(GuidStructureItem parentFolder, Guid layerGuid, bool above)
{
int parentFolderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentFolder.EndLayerGuid));
int parentFolderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentFolder.StartLayerGuid));
return(FindBoundLayer(layerGuid, parentFolderTopIndex, parentFolderBottomIndex, above));
}
private void Assign(GuidStructureItem parentGroup, GuidStructureItem group)
{
if (parentGroup != null)
{
Guid oldStart = parentGroup.StartLayerGuid;
Guid oldEnd = parentGroup.EndLayerGuid;
int folderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == group.EndLayerGuid));
int folderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == group.StartLayerGuid));
int parentFolderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.EndLayerGuid));
int parentFolderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.StartLayerGuid));
int finalTopIndex = Math.Max(folderTopIndex, parentFolderTopIndex);
int finalBottomIndex = Math.Min(folderBottomIndex, parentFolderBottomIndex);
Guid topBoundLayer = FindBoundLayer(group.StartLayerGuid, finalTopIndex, finalBottomIndex, false);
Guid bottomBoundLayer = FindBoundLayer(group.EndLayerGuid, finalTopIndex, finalBottomIndex, true);
if (topBoundLayer == parentGroup.EndLayerGuid)
{
parentGroup.EndLayerGuid = group.EndLayerGuid;
}
if (bottomBoundLayer == parentGroup.StartLayerGuid)
{
parentGroup.StartLayerGuid = group.StartLayerGuid;
}
if (parentGroup.Parent != null)
{
ApplyBoundsToParents(parentGroup.Parent, parentGroup, oldStart, oldEnd);
}
}
}
private void ApplyBoundsToParents(GuidStructureItem parent, GuidStructureItem group, Guid?oldStart, Guid?oldEnd)
{
Guid parentOldStart = parent.StartLayerGuid;
Guid parentOldEnd = parent.EndLayerGuid;
if (parent.Subgroups.Count == 0)
{
RemoveGroup(parent);
}
if (parent.StartLayerGuid == oldStart)
{
parent.StartLayerGuid = group.StartLayerGuid;
}
if (parent.EndLayerGuid == oldEnd)
{
parent.EndLayerGuid = group.EndLayerGuid;
}
if (parent.Parent != null)
{
ApplyBoundsToParents(parent.Parent, parent, parentOldStart, parentOldEnd);
}
}
private void Unassign(GuidStructureItem parentGroup, GuidStructureItem group)
{
if (parentGroup != null)
{
Guid oldStart = parentGroup.StartLayerGuid;
Guid oldEnd = parentGroup.EndLayerGuid;
if (parentGroup.Subgroups.Count == 1 && parentGroup.StartLayerGuid == group.StartLayerGuid && parentGroup.EndLayerGuid == group.EndLayerGuid)
{
RemoveGroup(parentGroup);
}
else
{
if (group.EndLayerGuid == parentGroup.EndLayerGuid)
{
parentGroup.EndLayerGuid = FindBoundLayer(parentGroup, group.StartLayerGuid, false);
}
if (group.StartLayerGuid == parentGroup.StartLayerGuid)
{
parentGroup.StartLayerGuid = FindBoundLayer(parentGroup, group.EndLayerGuid, true);
}
}
if (parentGroup.Parent != null)
{
ApplyBoundsToParents(parentGroup.Parent, parentGroup, oldStart, oldEnd);
}
}
}
/// <summary>
/// Checks if group is nested inside parent group.
/// </summary>
/// <param name="group">Group to check.</param>
/// <param name="parent">Parent of that group.</param>
/// <returns>True if group is nested inside parent, false if not.</returns>
public bool IsChildOf(GuidStructureItem group, GuidStructureItem parent)
{
if (group == null)
{
return(false);
}
foreach (var subgroup in parent.Subgroups)
{
if (subgroup == group)
{
return(true);
}
if (subgroup.Subgroups.Count > 0)
{
if (IsChildOf(group, subgroup))
{
return(true);
}
}
}
return(false);
}
private void PreMoveReassignBounds(GuidStructureItem parentGroup, Guid layer)
{
if (parentGroup != null)
{
Guid oldStart = parentGroup.StartLayerGuid;
Guid oldEnd = parentGroup.EndLayerGuid;
GuidStructureItem parentOfParent = parentGroup.Parent;
if (parentGroup.Subgroups.Count == 0 && parentGroup.StartLayerGuid == layer && parentGroup.EndLayerGuid == layer)
{
RemoveGroup(parentGroup);
}
else
{
if (parentGroup.EndLayerGuid == layer)
{
parentGroup.EndLayerGuid = FindBoundLayer(parentGroup, layer, false);
}
if (parentGroup.StartLayerGuid == layer)
{
parentGroup.StartLayerGuid = FindBoundLayer(parentGroup, layer, true);
}
}
if (parentOfParent != null)
{
ApplyBoundsToParents(parentOfParent, parentGroup, oldStart, oldEnd);
}
LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layer));
}
}
public GuidStructureItem AddNewGroup(string groupName, GuidStructureItem childGroup)
{
if (childGroup == null)
{
throw new ArgumentException("Child group can't be null.");
}
GuidStructureItem group = new(groupName, childGroup.StartLayerGuid, childGroup.EndLayerGuid, new[] { childGroup }, childGroup.Parent) { IsExpanded = true };
if (childGroup.Parent == null)
{
Groups.Add(group);
Groups.Remove(childGroup);
}
else
{
childGroup.Parent.Subgroups.Add(group);
childGroup.Parent.Subgroups.Remove(childGroup);
}
childGroup.Parent = group;
group.GroupsChanged += Group_GroupsChanged;
LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(GetGroupLayerGuids(group)));
return(group);
}
/// <summary>
/// Sets parent groups IsExpanded to true.
/// </summary>
/// <param name="group">Group which parents will be affected.</param>
public void ExpandParentGroups(GuidStructureItem group)
{
GuidStructureItem currentGroup = group;
while (currentGroup != null)
{
currentGroup.IsExpanded = true;
currentGroup = currentGroup.Parent;
}
}
/// <summary>
/// Gets all layers inside group, including nested groups.
/// </summary>
/// <param name="group">Group to get layers from.</param>
/// <returns>List of layers.</returns>
public List <Layer> GetGroupLayers(GuidStructureItem group)
{
List <Layer> layers = new();
var layerGuids = GetGroupLayerGuids(group);
foreach (var layerGuid in layerGuids)
{
layers.Add(Owner.Layers.First(x => x.GuidValue == layerGuid));
}
return(layers);
}
private void AssignParent(Guid layer, GuidStructureItem parent)
{
var currentParent = GetGroupByLayer(layer);
if (currentParent != null)
{
PreMoveReassignBounds(currentParent, layer);
}
Assign(parent, layer);
LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layer));
}
/// <summary>
/// Gets all layers inside group, including nested groups.
/// </summary>
/// <param name="group">Group to get layers from.</param>
/// <returns>List of layer guids.</returns>
private List <Guid> GetGroupLayerGuids(GuidStructureItem group)
{
Layer layerTop = Owner.Layers.FirstOrDefault(x => x.GuidValue == group.EndLayerGuid);
Layer layerBottom = Owner.Layers.FirstOrDefault(x => x.GuidValue == group.StartLayerGuid);
if (layerTop == null || layerBottom == null)
{
return(new List <Guid>());
}
int indexTop = Owner.Layers.IndexOf(layerTop);
int indexBottom = Owner.Layers.IndexOf(layerBottom);
return(GetLayersInOrder(new GroupData(indexTop, indexBottom)));
}
private void Assign(GuidStructureItem parentGroup, Guid layerGuid)
{
if (parentGroup != null)
{
Guid?oldStart = parentGroup.StartLayerGuid;
Guid?oldEnd = parentGroup.EndLayerGuid;
int layerIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == layerGuid));
int folderTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.EndLayerGuid));
int folderBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.GuidValue == parentGroup.StartLayerGuid));
int finalTopIndex = Math.Max(folderTopIndex, layerIndex);
int finalBottomIndex = Math.Min(folderBottomIndex, layerIndex);
Guid?topBoundLayer = FindBoundLayer(layerGuid, finalTopIndex, finalBottomIndex, false);
Guid?bottomBoundLayer = FindBoundLayer(layerGuid, finalTopIndex, finalBottomIndex, true);
if (topBoundLayer == parentGroup.EndLayerGuid)
{
parentGroup.EndLayerGuid = layerGuid;
}
if (bottomBoundLayer == parentGroup.StartLayerGuid)
{
parentGroup.StartLayerGuid = layerGuid;
}
if (parentGroup.Parent != null)
{
ApplyBoundsToParents(parentGroup.Parent, parentGroup, oldStart, oldEnd);
}
var args = new LayerStructureChangedEventArgs(layerGuid);
if (topBoundLayer.HasValue)
{
args.AffectedLayerGuids.Add(topBoundLayer.Value);
}
if (bottomBoundLayer.HasValue)
{
args.AffectedLayerGuids.Add(bottomBoundLayer.Value);
}
LayerStructureChanged?.Invoke(this, args);
}
}
private void RemoveGroup(GuidStructureItem parentFolder)
{
parentFolder.GroupsChanged -= Group_GroupsChanged;
var layerGuids = GetGroupLayerGuids(parentFolder);
if (parentFolder.Parent == null)
{
Groups.Remove(parentFolder);
}
else
{
parentFolder.Parent.Subgroups.Remove(parentFolder);
}
LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layerGuids));
}
/// <summary>
/// Assigns group new parent.
/// </summary>
/// <param name="group">Group to assign parent</param>
/// <param name="referenceLayerGroup">Parent of group.</param>
public void ReassignParent(GuidStructureItem group, GuidStructureItem referenceLayerGroup)
{
group.Parent?.Subgroups.Remove(group);
if (Groups.Contains(group))
{
Groups.Remove(group);
}
if (referenceLayerGroup == null)
{
if (!Groups.Contains(group))
{
Groups.Add(group);
group.Parent = null;
}
}
else
{
referenceLayerGroup.Subgroups.Add(group);
group.Parent = referenceLayerGroup;
}
LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(GetGroupLayerGuids(group)));
}
/// <summary>
/// Checks whenever group contains only single layer and none subgroups.
/// </summary>
/// <param name="layerGuid">Guid of layer to check.</param>
/// <param name="layerGroup">Group to check.</param>
/// <returns>True if group contains single layer (EndLayerGuid and StartLayerGuid == layerGuid) and none subgroups.</returns>
public static bool GroupContainsOnlyLayer(Guid layerGuid, GuidStructureItem layerGroup)
{
return(layerGroup != null && layerGroup.Subgroups.Count == 0 && layerGroup.StartLayerGuid == layerGuid && layerGroup.EndLayerGuid == layerGuid);
}
/// <summary>
/// Checks if layer is nested inside parent group.
/// </summary>
/// <param name="layerGuid">Layer GUID to check.</param>
/// <param name="parent">Parent of that group.</param>
/// <returns>True if layer is nested inside parent, false if not.</returns>
public bool IsChildOf(Guid layerGuid, GuidStructureItem parent)
{
var layerParent = GetGroupByLayer(layerGuid);
return(layerParent == parent ? true : IsChildOf(layerParent, parent));
}
