public CommandBarItemDefinition GetNextItemInGroup(CommandBarItemDefinition definition)
{
if (definition.CommandDefinition.ControlType == CommandControlTypes.Separator)
{
return(null);
}
return(DefinitionHost.ItemDefinitions.Where(x => x.Group == definition.Group)
.OrderBy(x => x.SortOrder)
.FirstOrDefault(x => x.SortOrder > definition.SortOrder));
}
private static void AdjustItemsAfterItemInsertedInGroup(CommandBarItemDefinition item)
{
var definitionsToChange = item.Group.Items
.Where(x => x.SortOrder >= item.SortOrder)
.OrderBy(x => x.SortOrder);
foreach (var definitionToChange in definitionsToChange)
{
if (definitionToChange == item)
{
continue;
}
definitionToChange.SortOrder++;
}
}
protected void StepwiseMoveDown(CommandBarItemDefinition item, CommandBarDefinitionBase parent)
{
var veryLastGroup = GetLastGroupDefinitionInParent(parent);
var veryLastItem = veryLastGroup.LastItem;
if (veryLastItem == item)
{
return;
}
if (item.CommandDefinition.ControlType == CommandControlTypes.Separator)
{
var nextGroup = GetNextGroup(item.Group);
var nextItem = nextGroup.FirstItem;
StepwiseMoveUp(nextItem, parent);
}
else
{
var lastItemIndex = item.Group.LastItem?.SortOrder;
if (lastItemIndex == item.SortOrder)
{
//Add to a new Group
var nextGroup = GetNextGroup(item.Group);
var lastGroup = item.Group;
item.Group = nextGroup;
item.SortOrder = 0;
AdjustItemsAfterItemInsertedInGroup(item);
if (DefinitionHost.ItemDefinitions.All(x => x.Group != lastGroup))
{
DeleteGroup(lastGroup);
}
}
else
{
var nextItem = GetNextItemInGroup(item);
if (nextItem == null)
{
return;
}
nextItem.SortOrder = item.SortOrder;
item.SortOrder = item.SortOrder + 1;
}
}
}
protected void StepwiseMoveUp(CommandBarItemDefinition item, CommandBarDefinitionBase parent)
{
if (item.IsVeryFirst)
{
return;
}
if (item.CommandDefinition.ControlType == CommandControlTypes.Separator)
{
var lastItem = item.Group.LastItem;
StepwiseMoveDown(lastItem, parent);
}
else
{
if (item.SortOrder == 0)
{
var previousGroup = GetPreviousGroup(item.Group);
var lastGroup = item.Group;
item.Group = previousGroup;
item.SortOrder = previousGroup.LastItem.SortOrder + 1;
var itemsToChange = lastGroup.Items;
if (!itemsToChange.Any())
{
DeleteGroup(lastGroup);
}
else
{
foreach (var itemDefinition in itemsToChange.ToList())
{
itemDefinition.SortOrder--;
}
}
}
else
{
var previousItem = GetPreviousItemInGroup(item);
if (previousItem == null)
{
return;
}
previousItem.SortOrder = item.SortOrder;
item.SortOrder = item.SortOrder - 1;
}
}
}
public virtual void AddItemDefinition(CommandBarItemDefinition definition, CommandBarDefinitionBase parent,
bool addAboveSeparator)
{
//Apparently the current parent is empty so we need to add a group first
if (definition.Group == null)
{
var group = new CommandBarGroupDefinition(parent, uint.MinValue);
definition.Group = group;
DefinitionHost.ItemGroupDefinitions.AddSorted(group, new SortOrderComparer <CommandBarDefinitionBase>());
}
if (!addAboveSeparator)
{
AdjustItemsAfterItemInsertedInGroup(definition);
}
DefinitionHost.ItemDefinitions.AddSorted(definition, new SortOrderComparer <CommandBarDefinitionBase>());
RemoveGapsInGroupSortOrder(definition.Group.Parent);
BuildLogical(definition);
}
public void AddGroupAt(CommandBarItemDefinition startingDefinition)
{
var parent = startingDefinition.Group.Parent;
var itemsToRegroup = startingDefinition.Group.Items
.Where(x => x.SortOrder >= startingDefinition.SortOrder);
var itemsToRegroupInOldGroup = startingDefinition.Group.Items
.Where(x => x.SortOrder < startingDefinition.SortOrder);
var newGroupSortOrder = startingDefinition.Group.SortOrder + 1;
var groupsToResort = parent.ContainedGroups
.Where(x => x.SortOrder > startingDefinition.Group.SortOrder);
var i = newGroupSortOrder + 1;
foreach (var groupDefinition in groupsToResort)
{
groupDefinition.SortOrder = i++;
}
var newGroup = new CommandBarGroupDefinition(parent, newGroupSortOrder);
uint j = 0;
foreach (var itemDefinition in itemsToRegroup.ToList())
{
itemDefinition.Group = newGroup;
itemDefinition.SortOrder = j++;
}
uint k = 0;
foreach (var itemDefinition in itemsToRegroupInOldGroup)
{
itemDefinition.SortOrder = k++;
}
DefinitionHost.ItemGroupDefinitions.AddSorted(newGroup, new SortOrderComparer <CommandBarGroupDefinition>());
RemoveGapsInGroupSortOrder(parent);
BuildLogical(parent);
}
public void MoveItem(CommandBarItemDefinition item, int offset, CommandBarDefinitionBase parent)
{
var sepcounter = Math.Abs(offset);
if (offset == 0)
{
return;
}
for (var i = 0; i < sepcounter; i++)
{
if (offset < 0)
{
StepwiseMoveUp(item, parent);
}
else
{
StepwiseMoveDown(item, parent);
}
}
BuildLogical(parent);
}
public virtual void DeleteItemDefinition(CommandBarItemDefinition definition)
{
//As a Separator contains the previous group we need add all items into the next group
if (definition.CommandDefinition.ControlType == CommandControlTypes.Separator)
{
if (definition.Group == null || !DefinitionHost.ItemGroupDefinitions.Contains(definition.Group))
{
return;
}
DeleteGroup(definition.Group);
}
else
{
var definitionsInGroup = definition.Group.Items;
if (definitionsInGroup.Count <= 1)
{
DefinitionHost.ItemGroupDefinitions.Remove(definition.Group);
RemoveGapsInGroupSortOrder(definition.Group.Parent);
}
else
{
var definitionsToChange = definitionsInGroup.Where(x => x.SortOrder >= definition.SortOrder)
.OrderBy(x => x.SortOrder);
foreach (var definitionToChange in definitionsToChange)
{
if (definitionToChange == definition)
{
continue;
}
definitionToChange.SortOrder--;
}
}
DefinitionHost.ItemDefinitions.Remove(definition);
BuildLogical(definition.Group.Parent);
Build(definition.Group.Parent);
}
}
public CommandBarItemDefinition GetNextItem(CommandBarItemDefinition definition)
{
CommandBarItemDefinition nextItem;
var hightestSortOrder = definition.Group.LastItem?.SortOrder;
if (definition.CommandDefinition.ControlType == CommandControlTypes.Separator ||
definition.SortOrder == hightestSortOrder)
{
var nextGroup = GetNextGroup(definition.Group);
if (nextGroup == null)
{
return(null);
}
nextItem = nextGroup.FirstItem;
}
else
{
nextItem = GetNextItemInGroup(definition);
}
return(nextItem);
}
public CommandBarItemDefinition GetPreviousItem(CommandBarItemDefinition definition)
{
CommandBarItemDefinition previousItem;
if (definition.CommandDefinition.ControlType == CommandControlTypes.Separator || definition.SortOrder == 0)
{
if (definition.SortOrder != 0)
{
return(null);
}
var previousGroup = GetPreviousGroup(definition.Group);
if (previousGroup == null)
{
return(null);
}
previousItem = previousGroup.LastItem;
}
else
{
previousItem = GetPreviousItemInGroup(definition);
}
return(previousItem);
}
