private void HandleGroupOpacityChange(GuidStructureItem group, float value)
{
if (LayerCommandsViewModel.Owner?.BitmapManager?.ActiveDocument != null)
{
var doc = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument;
if (group.Opacity == value)
{
return;
}
var processArgs = new object[] { group.GroupGuid, value };
var reverseProcessArgs = new object[] { group.GroupGuid, group.Opacity };
ChangeGroupOpacityProcess(processArgs);
LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument.LayerStructure.ExpandParentGroups(group);
doc.UndoManager.AddUndoChange(
new Change(
ChangeGroupOpacityProcess,
reverseProcessArgs,
ChangeGroupOpacityProcess,
processArgs,
$"Change {group.Name} opacity"), false);
}
}
public static SerializableGuidStructureItem ToSerializable(this GuidStructureItem group, SerializableGuidStructureItem parent = null)
{
var serializedGroup = new SerializableGuidStructureItem(
group.GroupGuid,
group.Name,
group.StartLayerGuid,
group.EndLayerGuid,
null, group.IsVisible, group.Opacity);
serializedGroup.Subgroups = group.Subgroups.Select(x => x.ToSerializable(serializedGroup)).ToArray();
return(serializedGroup);
}
private bool StructureMismatch(GuidStructureItem first, GuidStructureItem second)
{
bool rootMismatch = first.EndLayerGuid != second.EndLayerGuid || first.StartLayerGuid != second.StartLayerGuid || first.IsVisible != second.IsVisible || first.IsExpanded != second.IsExpanded || first.Opacity != second.Opacity || first.Subgroups.Count != second.Subgroups.Count || second.Name != first.Name;
if (!rootMismatch && first.Subgroups.Count > 0)
{
for (int i = 0; i < first.Subgroups.Count; i++)
{
if (StructureMismatch(first.Subgroups[i], second.Subgroups[i]))
{
return(true);
}
}
}
return(rootMismatch);
}
private IEnumerable <GuidStructureItem> GetSubGroups(GuidStructureItem group)
{
List <GuidStructureItem> groups = new List <GuidStructureItem>()
{
group
};
foreach (var subGroup in group.Subgroups)
{
groups.Add(subGroup);
if (subGroup.Subgroups.Count > 0)
{
groups.AddRange(GetSubGroups(subGroup));
}
}
return(groups.Distinct());
}
/// <summary>
/// Gets final layer opacity taking into consideration parent groups.
/// </summary>
/// <param name="layer">Layer to check.</param>
/// <returns>Float from range 0-1.</returns>
public static float GetFinalLayerOpacity(Layer layer, LayerStructure structure)
{
if (layer.Opacity == 0)
{
return(0f);
}
var group = structure.GetGroupByLayer(layer.LayerGuid);
GuidStructureItem groupToCheck = group;
float finalOpacity = layer.Opacity;
while (groupToCheck != null)
{
finalOpacity *= groupToCheck.Opacity;
groupToCheck = groupToCheck.Parent;
}
return(Math.Clamp(finalOpacity, 0f, 1f));
}
private static GuidStructureItem ToGroup(SerializableGuidStructureItem group, GuidStructureItem parent = null)
{
if (group == null)
{
return(null);
}
var parsedGroup = new GuidStructureItem(
group.Name,
group.StartLayerGuid,
group.EndLayerGuid,
new ObservableCollection <GuidStructureItem>(),
parent)
{
Opacity = group.Opacity, IsVisible = group.IsVisible, GroupGuid = group.GroupGuid, IsExpanded = true
};
parsedGroup.Subgroups = ToGroups(group.Subgroups, parsedGroup);
return(parsedGroup);
}
public void NewGroup(object parameter)
{
GuidStructureItem control = GetGroupFromParameter(parameter);
var doc = Owner.BitmapManager.ActiveDocument;
if (doc != null)
{
var lastGroups = doc.LayerStructure.CloneGroups();
if (parameter is Layer or LayerStructureItemContainer)
{
GuidStructureItem group = doc.LayerStructure.AddNewGroup($"{doc.ActiveLayer.Name} Group", doc.ActiveLayer.LayerGuid);
Owner.BitmapManager.ActiveDocument.LayerStructure.ExpandParentGroups(group);
}
else if (control != null)
{
doc.LayerStructure.AddNewGroup($"{control.Name} Group", control);
}
doc.AddLayerStructureToUndo(lastGroups);
doc.RaisePropertyChange(nameof(doc.LayerStructure));
}
/// <summary>
/// Gets final layer IsVisible taking into consideration group visibility.
/// </summary>
/// <param name="layer">Layer to check.</param>
/// <returns>True if is visible, false if at least parent is not visible or layer itself is invisible.</returns>
public static bool GetFinalLayerIsVisible(Layer layer, LayerStructure structure)
{
if (!layer.IsVisible)
{
return(false);
}
var group = structure.GetGroupByLayer(layer.GuidValue);
bool atLeastOneParentIsInvisible = false;
GuidStructureItem groupToCheck = group;
while (groupToCheck != null)
{
if (!groupToCheck.IsVisible)
{
atLeastOneParentIsInvisible = true;
break;
}
groupToCheck = groupToCheck.Parent;
}
return(!atLeastOneParentIsInvisible);
}
private static ObservableCollection <GuidStructureItem> ToGroups(SerializableGuidStructureItem[] serializableGroups, GuidStructureItem parent = null)
{
ObservableCollection <GuidStructureItem> groups = new ObservableCollection <GuidStructureItem>();
if (serializableGroups == null)
{
return(groups);
}
foreach (var serializableGroup in serializableGroups)
{
groups.Add(ToGroup(serializableGroup, parent));
}
return(groups);
}
