//-----------------------------------------------------------------------
protected override void AddContextMenuItems(ContextMenu menu)
{
base.AddContextMenuItems(menu);
MenuItem pasteItem = new MenuItem();
pasteItem.Header = "Paste new";
pasteItem.Command = PasteNewCMD;
menu.Items.Add(pasteItem);
if (Children.Count > 1)
{
menu.AddSeperator();
menu.AddItem("Multiedit Children", () =>
{
DataModel.Selected = new List <DataItem>(Children);
});
}
}
//-----------------------------------------------------------------------
public ContextMenu CreateContextMenu()
{
ContextMenu menu = new ContextMenu();
AddContextMenuItems(menu);
menu.AddSeperator();
if (this is ComplexDataItem)
{
menu.AddItem("Add Comment", () =>
{
var comment = new CommentItem(new CommentDefinition(), UndoRedo);
UndoRedo.ApplyDoUndo(delegate
{
Children.Add(comment);
}, delegate
{
Children.Remove(comment);
}, "Add Comment");
});
}
menu.AddItem("Add Comment Above", () =>
{
var parent = FirstComplexParent(this);
var index = GetIndexInParent();
var comment = new CommentItem(new CommentDefinition(), UndoRedo);
UndoRedo.ApplyDoUndo(delegate
{
parent.Children.Insert(index, comment);
}, delegate
{
parent.Children.Remove(comment);
}, "Add Comment");
});
menu.AddItem("Add Comment Below", () =>
{
var parent = FirstComplexParent(this);
var index = GetIndexInParent();
var comment = new CommentItem(new CommentDefinition(), UndoRedo);
UndoRedo.ApplyDoUndo(delegate
{
parent.Children.Insert(index + 1, comment);
}, delegate
{
parent.Children.Remove(comment);
}, "Add Comment");
});
menu.AddSeperator();
MenuItem focusItem = new MenuItem();
focusItem.Header = "Focus";
focusItem.Click += delegate
{
DataModel.FocusItem(this);
};
menu.Items.Add(focusItem);
menu.Items.Add(new Separator());
MenuItem resetItem = new MenuItem();
resetItem.Header = "Reset To Default";
resetItem.Click += delegate
{
ResetToDefault();
};
menu.Items.Add(resetItem);
menu.Items.Add(new Separator());
MenuItem collapseAllItem = new MenuItem();
collapseAllItem.Header = "Collapse All";
collapseAllItem.Click += delegate
{
foreach (var item in Root.Descendants)
{
item.IsExpanded = false;
}
};
menu.Items.Add(collapseAllItem);
MenuItem expandAllItem = new MenuItem();
expandAllItem.Header = "Expand All";
expandAllItem.Click += delegate
{
foreach (var item in Root.Descendants)
{
item.IsExpanded = true;
}
};
menu.Items.Add(expandAllItem);
MenuItem collapseLevelItem = new MenuItem();
collapseLevelItem.Header = "Collapse Level";
collapseLevelItem.Click += delegate
{
foreach (var item in Parent.Children)
{
item.IsExpanded = false;
}
};
menu.Items.Add(collapseLevelItem);
MenuItem expandLevelItem = new MenuItem();
expandLevelItem.Header = "Expand Level";
expandLevelItem.Click += delegate
{
foreach (var item in Parent.Children)
{
item.IsExpanded = true;
}
};
menu.Items.Add(expandLevelItem);
MenuItem collapseChildrenItem = new MenuItem();
collapseChildrenItem.Header = "Collapse Children";
collapseChildrenItem.Click += delegate
{
foreach (var item in Descendants)
{
item.IsExpanded = false;
}
};
menu.Items.Add(collapseChildrenItem);
MenuItem expandChildrenItem = new MenuItem();
expandChildrenItem.Header = "Expand Children";
expandChildrenItem.Click += delegate
{
foreach (var item in Descendants)
{
item.IsExpanded = true;
}
};
menu.Items.Add(expandChildrenItem);
return(menu);
}
//-----------------------------------------------------------------------
protected override void AddContextMenuItems(ContextMenu menu)
{
MenuItem addNewItem = new MenuItem();
addNewItem.Header = "Add New";
addNewItem.Click += delegate
{
AddNew();
};
menu.Items.Add(addNewItem);
MenuItem DuplicateItem = new MenuItem();
DuplicateItem.Header = "Duplicate";
DuplicateItem.Click += delegate
{
Duplicate();
};
menu.Items.Add(DuplicateItem);
MenuItem CopyItem = new MenuItem();
CopyItem.Header = "Copy";
CopyItem.Click += delegate
{
Copy();
};
menu.Items.Add(CopyItem);
if (WrappedItem is ReferenceItem)
{
var ri = WrappedItem as ReferenceItem;
MenuItem pasteItem = new MenuItem();
pasteItem.Header = "Paste";
pasteItem.Click += (e, args) => { Paste(); };
pasteItem.IsEnabled = ri.ReferenceDef.Definitions.Any(e => Clipboard.ContainsData(e.Value.CopyKey));
menu.Items.Add(pasteItem);
if ((ri.Definition as ReferenceDefinition).Definitions.Count > 1)
{
menu.Items.Add(new Separator());
MenuItem swapItem = new MenuItem();
swapItem.Header = "Swap";
menu.Items.Add(swapItem);
foreach (var def in (ri.Definition as ReferenceDefinition).Definitions.Values)
{
if (def != ri.ChosenDefinition)
{
MenuItem doSwapItem = new MenuItem();
doSwapItem.Header = def.Name;
doSwapItem.Command = ri.SwapCMD;
doSwapItem.CommandParameter = def;
swapItem.Items.Add(doSwapItem);
}
}
}
}
else if (WrappedItem is GraphReferenceItem)
{
var ri = WrappedItem as GraphReferenceItem;
MenuItem pasteItem = new MenuItem();
pasteItem.Header = "Paste";
pasteItem.Click += (e, args) => { Paste(); };
pasteItem.IsEnabled = ri.ReferenceDef.Definitions.Any(e => Clipboard.ContainsData(e.Value.CopyKey));
menu.Items.Add(pasteItem);
}
else
{
MenuItem pasteItem = new MenuItem();
pasteItem.Header = "Paste";
pasteItem.Command = PasteCMD;
menu.Items.Add(pasteItem);
}
if (WrappedItem is CollectionItem)
{
var ci = WrappedItem as CollectionItem;
if (ci.Children.Count > 1)
{
menu.AddSeperator();
menu.AddItem("Multiedit Children", () =>
{
var otherChildren = new List <DataItem>();
for (int i = 1; i < Children.Count; i++)
{
otherChildren.Add(Children[i]);
}
Children[0].MultiEdit(otherChildren, otherChildren.Count);
DataModel.Selected = new List <DataItem>()
{
Children[0]
};
});
}
}
}
//-----------------------------------------------------------------------
protected override void OnPreviewMouseUp(MouseButtonEventArgs args)
{
if (Animation == null)
{
return;
}
var pos = args.GetPosition(this);
var clickPos = pos.X - Animation.LeftPad;
double pixelsASecond = ActualWidth / Animation.TimelineRange;
if (!isDragging)
{
if (args.ChangedButton == MouseButton.Right)
{
ContextMenu menu = new ContextMenu();
var selected = Animation.Keyframes.FirstOrDefault((e) => e.IsSelected);
if (selected != null)
{
MenuItem delete = new MenuItem();
delete.Header = "Delete";
delete.Click += delegate { Animation.Keyframes.Remove(selected); dirty = true; };
menu.Items.Add(delete);
}
else
{
MenuItem add = new MenuItem();
add.Header = "Add Keyframe";
add.Click += delegate
{
var newTime = clickPos / pixelsASecond;
var roundedTime = Snap(newTime);
var keyframe = new Keyframe(Animation);
keyframe.Time = roundedTime;
Animation.Keyframes.Add(keyframe);
dirty = true;
};
menu.Items.Add(add);
}
menu.AddSeperator();
menu.AddItem("Auto Position Keyframes", delegate
{
var firstTime = Animation.Keyframes.Select(e => (e as Keyframe).Time).Min();
var lastTime = Animation.Keyframes.Select(e => (e as Keyframe).Time).Max();
var count = Animation.Keyframes.Count;
var step = (lastTime - firstTime) / (count - 1);
var current = firstTime;
foreach (var keyframe in Animation.Keyframes.Select(e => e as Keyframe).OrderBy(e => e.Time).ToList())
{
keyframe.Time = current;
current += step;
}
});
menu.AddSeperator();
MenuItem zoom = new MenuItem();
zoom.Header = "Zoom To Best Fit";
zoom.Click += delegate { ZoomToBestFit(); };
menu.Items.Add(zoom);
this.ContextMenu = menu;
menu.IsOpen = true;
args.Handled = true;
}
}
EndDrag();
}
//-----------------------------------------------------------------------
protected override void OnPreviewMouseUp(MouseButtonEventArgs args)
{
if (TimelineItem == null)
{
return;
}
var pos = args.GetPosition(this);
var clickPos = pos.X - TimelineItem.LeftPad;
double pixelsASecond = ActualWidth / TimelineItem.TimelineRange;
if (isMarqueeSelecting)
{
if (Math.Abs(marqueeCurrentPos - marqueeStartPos) > 5)
{
var timelineIndex = TimelineItem.TimelineGroup.ToList().IndexOf(TimelineItem);
var marqueeMinTimeline = (int)Math.Min(marqueeStartTimeline, marqueeCurrentTimeline);
var marqueeMaxTimeline = (int)Math.Max(marqueeStartTimeline, marqueeCurrentTimeline);
if (timelineIndex >= marqueeMinTimeline && timelineIndex <= marqueeMaxTimeline)
{
// deselect all
if (TimelineItem.DataModel.SelectedItems != null)
{
foreach (var selected in TimelineItem.DataModel.SelectedItems.ToList())
{
selected.IsSelected = false;
}
}
foreach (var timeline in TimelineItem.TimelineGroup)
{
foreach (var keyframe in timeline.Children)
{
keyframe.IsSelected = false;
}
}
// do selection
var minPos = Math.Min(marqueeStartPos, marqueeCurrentPos);
var maxPos = Math.Max(marqueeStartPos, marqueeCurrentPos);
var timelineGroup = TimelineItem.TimelineGroup.ToList();
for (int i = marqueeMinTimeline; i <= marqueeMaxTimeline; i++)
{
var timeline = timelineGroup[i];
foreach (KeyframeItem keyframe in timeline.Children)
{
var leftPos = keyframe.GetKeyframeTime() * pixelsASecond;
var rightPos = leftPos + GetKeyframeWidth(keyframe);
if (minPos < rightPos && maxPos > leftPos)
{
keyframe.IsSelected = true;
}
}
}
}
}
foreach (var timeline in TimelineItem.TimelineGroup)
{
timeline.Timeline.dirty = true;
}
}
else if (!isResizeDragging && !isDraggingItems && !isMarqueeSelecting)
{
if (args.ChangedButton == MouseButton.Right)
{
ContextMenu menu = new ContextMenu();
var selected = TimelineItem.Children.FirstOrDefault((e) => e.IsSelected);
if (selected != null)
{
MenuItem delete = new MenuItem();
delete.Header = "Delete";
delete.Click += delegate { TimelineItem.Remove(selected); dirty = true; };
delete.IsEnabled = !TimelineItem.IsAtMin;
menu.Items.Add(delete);
}
else
{
if (TimelineItem.TimelineDef.KeyframeDefinitions.Count == 1)
{
MenuItem add = new MenuItem();
add.Header = "Add " + TimelineItem.TimelineDef.KeyframeDefinitions[0].Name;
add.Click += delegate
{
var newTime = clickPos / pixelsASecond;
var roundedTime = Snap(newTime);
TimelineItem.Add(TimelineItem.TimelineDef.KeyframeDefinitions[0], (float)roundedTime);
dirty = true;
};
add.IsEnabled = !TimelineItem.IsAtMax;
menu.Items.Add(add);
var keyDef = TimelineItem.TimelineDef.KeyframeDefinitions[0];
var nonBaseDefs = keyDef.Children.Where(e => e != keyDef.TimeDefinition && e != keyDef.DurationDefinition).ToList();
var firstChild = nonBaseDefs.FirstOrDefault();
if (nonBaseDefs.Count == 1 && firstChild is FileDefinition)
{
menu.AddItem("Add Multiple", () =>
{
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
var fdef = firstChild as FileDefinition;
if (fdef.AllowedFileTypes != null)
{
var filter = "Resource files (" +
string.Join(", ", fdef.AllowedFileTypes.Select((e) => "*." + e)) +
") | " +
string.Join("; ", fdef.AllowedFileTypes.Select((e) => "*." + e));
dlg.Filter = filter;
}
dlg.Multiselect = true;
bool?result = dlg.ShowDialog();
if (result == true)
{
var newTime = clickPos / pixelsASecond;
var roundedTime = Snap(newTime);
var filenames = dlg.FileNames;
foreach (var file in filenames)
{
var chosen = file;
if (fdef.StripExtension)
{
chosen = Path.ChangeExtension(chosen, null);
}
// make relative
var relativeTo = Path.Combine(Path.GetDirectoryName(Workspace.Instance.ProjectRoot), fdef.BasePath, "fakefile.fake");
Uri path1 = new Uri(chosen);
Uri path2 = new Uri(relativeTo);
Uri diff = path2.MakeRelativeUri(path1);
string relPath = Uri.UnescapeDataString(diff.OriginalString);
var created = TimelineItem.Add(keyDef, (float)roundedTime);
var fitem = (FileItem)created.Children.FirstOrDefault(e => e.Definition == firstChild);
fitem.Value = relPath;
roundedTime += 0.1;
}
dirty = true;
}
});
}
}
else
{
var add = menu.AddItem("Add");
add.IsEnabled = !TimelineItem.IsAtMax;
if (!TimelineItem.IsAtMax)
{
var currentGroup = "";
foreach (var def in TimelineItem.TimelineDef.Keys)
{
if (def.Item2 != currentGroup)
{
currentGroup = def.Item2;
add.AddGroupHeader(currentGroup);
}
add.AddItem(def.Item1.Name, () =>
{
var newTime = clickPos / pixelsASecond;
var roundedTime = Snap(newTime);
TimelineItem.Add(def.Item1, (float)roundedTime);
dirty = true;
});
}
}
}
}
menu.AddSeperator();
menu.AddItem("Auto Position Keyframes", delegate
{
var firstTime = TimelineItem.Children.Select(e => (e as KeyframeItem).Time).Min();
var lastTime = TimelineItem.Children.Select(e => (e as KeyframeItem).Time).Max();
var count = TimelineItem.Children.Count;
var step = (lastTime - firstTime) / (count - 1);
var current = firstTime;
foreach (var keyframe in TimelineItem.Children.Select(e => e as KeyframeItem).OrderBy(e => e.Time).ToList())
{
keyframe.Time = current;
current += step;
}
});
menu.AddSeperator();
MenuItem zoom = new MenuItem();
zoom.Header = "Zoom To Best Fit";
zoom.Click += delegate { ZoomToBestFit(); };
menu.Items.Add(zoom);
this.ContextMenu = menu;
menu.IsOpen = true;
args.Handled = true;
}
}
EndDrag();
}
//--------------------------------------------------------------------------
protected override void OnMouseRightButtonDown(MouseButtonEventArgs args)
{
var pos = args.GetPosition(this);
var scaled = new Point((pos.X - Offset.X) / Scale, (pos.Y - Offset.Y) / Scale);
ContextMenu menu = new ContextMenu();
var create = menu.AddItem("Create");
foreach (var def in ValidNodeTypes)
{
create.AddItem(def.Name, () =>
{
var dataModel = Nodes.First().GraphNodeItem.DataModel;
var undo = dataModel.RootItems[0].UndoRedo;
GraphNodeItem item = null;
using (undo.DisableUndoScope())
{
item = def.CreateData(undo) as GraphNodeItem;
item.DataModel = Nodes.First().GraphNodeItem.DataModel;
item.X = scaled.X;
item.Y = scaled.Y;
}
undo.ApplyDoUndo(
delegate
{
dataModel.GraphNodeItems.Add(item);
},
delegate
{
dataModel.GraphNodeItems.Remove(item);
},
"Create " + item.Name);
});
}
if (Clipboard.ContainsData("NodeCopy"))
{
menu.AddItem("Paste", () => { Paste(scaled); });
}
GraphNode clickedNode = Nodes.FirstOrDefault(e => GetRectOfObject(e).Contains(pos));
if (clickedNode == null)
{
clickedNode = Selected.FirstOrDefault();
}
if (clickedNode != null)
{
if (!clickedNode.IsSelected)
{
clickedNode.IsSelected = true;
}
menu.AddSeperator();
menu.AddItem("Delete", () =>
{
DeleteNodes(Selected.ToList());
});
menu.AddItem("Copy", () =>
{
Copy();
});
menu.AddSeperator();
var dataModel = clickedNode.GraphNodeItem.DataModel;
var undo = dataModel.RootItems[0].UndoRedo;
var commentMenu = menu.AddItem("Set Comment");
commentMenu.AddItem("New Comment", () =>
{
var comment = new GraphCommentItem(dataModel, undo, "", Colors.White);
comment.GUID = Guid.NewGuid().ToString();
undo.ApplyDoUndo(
delegate
{
clickedNode.GraphNodeItem.DataModel.GraphCommentItems.Add(comment);
},
delegate
{
clickedNode.GraphNodeItem.DataModel.GraphCommentItems.Remove(comment);
},
"Create Graph Comment");
foreach (var node in Selected)
{
var previous = node.GraphNodeItem.Comment;
var previousComment = Comments.FirstOrDefault(e => e.Comment.GUID == previous);
undo.ApplyDoUndo(
delegate
{
node.GraphNodeItem.Comment = comment.GUID;
comment.Nodes.Add(node.GraphNodeItem);
if (previousComment != null)
{
previousComment.Comment.Nodes.Remove(node.GraphNodeItem);
}
},
delegate
{
node.GraphNodeItem.Comment = previous;
comment.Nodes.Remove(node.GraphNodeItem);
if (previousComment != null)
{
previousComment.Comment.Nodes.Add(node.GraphNodeItem);
}
},
"Set Graph Comment");
}
clickedNode.GraphNodeItem.DataModel.RaisePropertyChangedEvent("GraphComments");
});
bool first = true;
foreach (var comment in Comments)
{
if (first)
{
commentMenu.AddSeperator();
first = false;
}
commentMenu.AddItem(comment.Comment.Title, () =>
{
foreach (var node in Selected)
{
var previous = node.GraphNodeItem.Comment;
var previousComment = Comments.FirstOrDefault(e => e.Comment.GUID == previous);
undo.ApplyDoUndo(
delegate
{
node.GraphNodeItem.Comment = comment.Comment.GUID;
comment.Comment.Nodes.Add(node.GraphNodeItem);
if (previousComment != null)
{
previousComment.Comment.Nodes.Remove(node.GraphNodeItem);
}
},
delegate
{
node.GraphNodeItem.Comment = previous;
comment.Comment.Nodes.Remove(node.GraphNodeItem);
if (previousComment != null)
{
previousComment.Comment.Nodes.Add(node.GraphNodeItem);
}
},
"Set Graph Comment");
}
});
}
if (clickedNode.GraphNodeItem.Comment != null)
{
menu.AddItem("Clear Comment", () =>
{
foreach (var node in Selected)
{
if (node.GraphNodeItem.Comment == null)
{
continue;
}
var previous = node.GraphNodeItem.Comment;
var previousComment = Comments.FirstOrDefault(e => e.Comment.GUID == previous);
undo.ApplyDoUndo(
delegate
{
node.GraphNodeItem.Comment = null;
if (previousComment != null)
{
previousComment.Comment.Nodes.Remove(node.GraphNodeItem);
if (previousComment.Comment.Nodes.Count == 0)
{
dataModel.GraphCommentItems.Remove(previousComment.Comment);
}
}
},
delegate
{
if (previousComment != null)
{
if (!dataModel.GraphCommentItems.Contains(previousComment.Comment))
{
dataModel.GraphCommentItems.Add(previousComment.Comment);
}
}
node.GraphNodeItem.Comment = previous;
if (previousComment != null)
{
previousComment.Comment.Nodes.Add(node.GraphNodeItem);
}
},
"Clear Graph Comment");
}
});
}
}
if (mouseOverLink != null)
{
menu.AddSeperator();
var link = mouseOverLink;
var mousePos = MousePosition;
menu.AddItem("Create Control Point", () =>
{
link.Link.AddControlPoint(mousePos);
});
}
if (mouseOverControlPoint != null)
{
menu.AddSeperator();
var controlPoint = mouseOverControlPoint;
menu.AddItem("Delete Control Point", () =>
{
controlPoint.LinkParent.RemoveControlPoint(controlPoint);
});
menu.AddCheckable("Flip Control Point", (state) =>
{
controlPoint.Flip = !controlPoint.Flip;
}, controlPoint.Flip);
}
menu.IsOpen = true;
base.OnMouseRightButtonDown(args);
}