public static void Perform(Node node)
{
foreach (var m in node.Parent.Markers)
{
SetMarker.Perform(node, m.Clone(), true);
SetKeyframe.Perform(node, nameof(Node.Trigger), null, new Keyframe <string> {
Frame = m.Frame,
Value = m.Id,
Function = KeyFunction.Linear
});
}
}
public static void Perform(object @object, string propertyPath, object value, bool createAnimatorIfNeeded = false, bool createInitialKeyframeForNewAnimator = true, int atFrame = -1)
{
IAnimator animator;
var animationHost = @object as IAnimationHost;
object owner = @object;
int index = -1;
AnimationUtils.PropertyData propertyData = AnimationUtils.PropertyData.Empty;
if (animationHost != null)
{
(propertyData, owner, index) = AnimationUtils.GetPropertyByPath(animationHost, propertyPath);
}
if (index == -1)
{
SetProperty.Perform(owner, propertyData.Info?.Name ?? propertyPath, value);
}
else
{
SetIndexedProperty.Perform(owner, propertyData.Info?.Name ?? propertyPath, index, value);
}
if (animationHost != null && (animationHost.Animators.TryFind(propertyPath, out animator, Document.Current.AnimationId) || createAnimatorIfNeeded))
{
if (animator == null && createInitialKeyframeForNewAnimator)
{
var propertyValue = propertyData.Info.GetValue(owner);
Perform(animationHost, propertyPath, propertyValue, true, false, 0);
}
int savedFrame = -1;
if (atFrame >= 0 && Document.Current.AnimationFrame != atFrame)
{
savedFrame = Document.Current.AnimationFrame;
Document.Current.AnimationFrame = atFrame;
}
try {
var type = propertyData.Info.PropertyType;
var key =
animator?.ReadonlyKeys.GetByFrame(Document.Current.AnimationFrame)?.Clone() ??
Keyframe.CreateForType(type);
key.Frame = Document.Current.AnimationFrame;
key.Function = animator?.Keys.LastOrDefault(k => k.Frame <= key.Frame)?.Function ?? KeyFunction.Linear;
key.Value = value;
SetKeyframe.Perform(animationHost, propertyPath, Document.Current.AnimationId, key);
} finally {
if (savedFrame >= 0)
{
Document.Current.AnimationFrame = savedFrame;
}
}
}
}
public static void Perform(object @object, string propertyName, object value)
{
SetProperty.Perform(@object, propertyName, value);
IAnimator animator;
var animable = @object as IAnimable;
if (animable != null && animable.Animators.TryFind(propertyName, out animator, Document.Current.AnimationId))
{
var type = animable.GetType().GetProperty(propertyName).PropertyType;
var key =
animator.ReadonlyKeys.FirstOrDefault(i => i.Frame == Document.Current.AnimationFrame)?.Clone() ??
Keyframe.CreateForType(type);
key.Frame = Document.Current.AnimationFrame;
key.Function = animator.Keys.LastOrDefault(k => k.Frame < key.Frame)?.Function ?? KeyFunction.Linear;
key.Value = value;
SetKeyframe.Perform(animable, propertyName, Document.Current.AnimationId, key);
}
}
protected override void InternalDo(TimelineHorizontalShift op)
{
var container = Document.Current.Container;
foreach (var node in container.Nodes)
{
foreach (var animator in node.Animators.Where(i => i.AnimationId == Document.Current.AnimationId))
{
var keys = op.Direction > 0 ? animator.ReadonlyKeys.Reverse() : animator.ReadonlyKeys;
foreach (var k in keys.ToList())
{
if (k.Frame >= op.Column)
{
RemoveKeyframe.Perform(animator, k.Frame);
var k1 = k.Clone();
k1.Frame += op.Direction.Sign();
if (op.Direction > 0 || k.Frame > op.Column)
{
SetKeyframe.Perform(animator, k1);
}
}
}
}
}
var markers = container.Markers.ToList();
if (op.Direction > 0)
{
markers.Reverse();
}
foreach (var m in markers)
{
if (m.Frame >= op.Column)
{
DeleteMarker.Perform(container.Markers, m);
var m1 = m.Clone();
m1.Frame += op.Direction.Sign();
if (op.Direction > 0 || m.Frame > op.Column)
{
SetMarker.Perform(container.Markers, m1);
}
}
}
}
public static void Perform <T>(object @object, string propertyPath, AnimablePropertyProcessor <T> propertyProcessor)
{
var propertyInfo = @object.GetType().GetProperty(propertyPath);
if (propertyInfo != null)
{
var value = propertyInfo.GetValue(@object);
if (value is T)
{
T processedValue;
if (propertyProcessor((T)value, out processedValue))
{
SetProperty.Perform(@object, propertyPath, processedValue);
}
}
}
IAnimator animator;
var animable = @object as IAnimationHost;
if (animable != null && animable.Animators.TryFind(propertyPath, out animator, Document.Current.AnimationId))
{
foreach (var keyframe in animator.ReadonlyKeys.ToList())
{
if (!(keyframe.Value is T))
{
continue;
}
T processedValue;
if (propertyProcessor((T)keyframe.Value, out processedValue))
{
var keyframeClone = keyframe.Clone();
keyframeClone.Value = processedValue;
SetKeyframe.Perform(animator, keyframeClone);
}
}
}
}
public static bool PasteNodes(string data, RowLocation location, Vector2?mousePosition)
{
bool CanPaste()
{
// We are support only paste into folders for now.
return(location.ParentRow.Components.Contains <FolderRow>() ||
location.ParentRow.Components.Contains <BoneRow>());
}
if (!CanPaste())
{
return(false);
}
Frame frame;
try {
var stream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(data));
frame = TangerinePersistence.Instance.ReadObject <Frame>(Document.Current.Path, stream);
} catch (System.Exception e) {
Debug.Write(e);
return(false);
}
var animators = frame.Animators;
var items = frame.RootFolder().Items.Where(item => NodeCompositionValidator.IsCopyPasteAllowed(item.GetType())).ToList();
if (items.Count == 0)
{
if (animators.Count != 0)
{
foreach (var row in Document.Current.TopLevelSelectedRows().ToList())
{
if (!(row.Components.Get <NodeRow>()?.Node is IAnimationHost animable))
{
continue;
}
Document.Current.History.DoTransaction(() => {
foreach (var animator in animators)
{
if (animable.GetType().GetProperty(animator.TargetPropertyPath) == null)
{
continue;
}
foreach (var keyframe in animator.Keys)
{
SetKeyframe.Perform(animable, animator.TargetPropertyPath, animator.AnimationId, keyframe);
}
}
});
}
}
return(true);
}
var folderLocation = location.ParentRow.Rows.Count > 0 ?
Row.GetFolderItemLocation(location.ParentRow.Rows[location.Index]) :
new FolderItemLocation {
Index = 0, Folder = location.ParentRow.Components.Get <FolderRow>().Folder
};
if (!folderLocation.Folder.Expanded)
{
SetProperty.Perform(folderLocation.Folder, nameof(Folder.Expanded), true);
}
mousePosition *= Document.Current.Container.AsWidget?.LocalToWorldTransform.CalcInversed();
var shift = mousePosition - items.OfType <Widget>().FirstOrDefault()?.Position;
foreach (var n in items.OfType <Node>())
{
Document.Current.Decorate(n);
}
if (shift.HasValue)
{
foreach (var w in items.OfType <Widget>())
{
w.Position += shift.Value;
}
}
frame.RootFolder().Items.Clear();
frame.RootFolder().SyncDescriptorsAndNodes(frame);
ClearRowSelection.Perform();
while (items.Count > 0)
{
var item = items.First();
if (item is Bone bone)
{
if (bone.BaseIndex != 0)
{
continue;
}
var newIndex = 1;
var bones = Document.Current.Container.Nodes.OfType <Bone>();
if (bones.Any())
{
newIndex = bones.Max(b => b.Index) + 1;
}
var children = BoneUtils.FindBoneDescendats(bone, items.OfType <Bone>()).ToList();
var map = new Dictionary <int, int> {
{ bone.Index, newIndex }
};
bone.BaseIndex = location.ParentRow.Components.Get <BoneRow>()?.Bone.Index ?? 0;
bone.Index = newIndex;
InsertFolderItem.Perform(
Document.Current.Container,
folderLocation, bone);
folderLocation.Index++;
foreach (var b in children)
{
b.BaseIndex = map[b.BaseIndex];
map.Add(b.Index, b.Index = ++newIndex);
InsertFolderItem.Perform(
Document.Current.Container,
folderLocation, b);
folderLocation.Index++;
items.Remove(b);
}
Document.Current.Container.RootFolder().SyncDescriptorsAndNodes(Document.Current.Container);
SortBonesInChain.Perform(bone);
SelectRow.Perform(Document.Current.GetRowForObject(item));
}
else
{
if (!location.ParentRow.Components.Contains <BoneRow>())
{
InsertFolderItem.Perform(
Document.Current.Container,
folderLocation, item);
folderLocation.Index++;
SelectRow.Perform(Document.Current.GetRowForObject(item));
}
}
items.Remove(item);
}
return(true);
}
public static void Perform(int column)
{
var container = Document.Current.Container;
foreach (var node in container.Nodes)
{
var occupied = new HashSet <int>();
if (node.Animators.Count == 0)
{
continue;
}
foreach (var animator in node.Animators.Where(i => i.AnimationId == Document.Current.AnimationId))
{
foreach (var k in animator.ReadonlyKeys)
{
occupied.Add(k.Frame);
}
}
int removeAt = occupied.Max() + 1;
for (int i = column - 1; ; ++i)
{
if (!occupied.Contains(i))
{
removeAt = i;
break;
}
}
foreach (var animator in node.Animators.Where(i => i.AnimationId == Document.Current.AnimationId).ToList())
{
var keys = animator.ReadonlyKeys.ToList();
foreach (var k in keys)
{
if (k.Frame != 0 && k.Frame >= removeAt)
{
var k1 = k.Clone();
k1.Frame -= 1;
SetKeyframe.Perform(animator, k1);
RemoveKeyframe.Perform(animator, k.Frame);
}
}
}
}
var markers = container.Markers.ToList();
if (markers.Count == 0)
{
return;
}
var markersOccupied = new HashSet <int>();
foreach (var m in markers)
{
markersOccupied.Add(m.Frame);
}
int markersRemoveAt = markersOccupied.Max() + 1;
for (int i = column - 1; ; ++i)
{
if (!markersOccupied.Contains(i))
{
markersRemoveAt = i;
break;
}
}
foreach (var m in markers)
{
if (m.Frame != 0 && m.Frame >= markersRemoveAt)
{
var m1 = m.Clone();
m1.Frame -= 1;
DeleteMarker.Perform(container, m, false);
SetMarker.Perform(container, m1, false);
}
}
}
