/// <inheritdoc/>
public virtual void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is VisualizationObject visualizationObject)
{
// If the visualization object is bound and allows snapping to its stream, add the snap to stream menuitem.
if (visualizationObject is IStreamVisualizationObject streamVisualizationObject && streamVisualizationObject.IsBound)
{
if (visualizationObject.CanSnapToStream)
{
menuItems.Add(MenuItemHelper.CreateMenuItem(
IconSourcePath.SnapToStream,
visualizationObject.IsSnappedToStream ? $"Unsnap from Stream" : $"Snap to Stream",
new VisualizationCommand(() => visualizationObject.ToggleSnapToStream())));
}
}
// Add the show/hide menuitem.
menuItems.Add(MenuItemHelper.CreateMenuItem(
IconSourcePath.ToggleVisibility,
visualizationObject.Visible ? "Hide Visualizer" : "Show Visualizers",
visualizationObject.ToggleVisibilityCommand,
null,
true,
null));
// Add the remove from panel menuitem.
menuItems.Add(MenuItemHelper.CreateMenuItem(
IconSourcePath.RemovePanel,
$"Remove Visualizer",
visualizationObject.Panel.DeleteVisualizationCommand,
null,
true,
visualizationObject));
}
}
/// <inheritdoc/>
public override void AppendContextMenuItems(List <MenuItem> menuItems)
{
base.AppendContextMenuItems(menuItems);
// Add Set Cursor Epsilon menu with sub-menu items
var rangeModeMenuItem = MenuItemHelper.CreateMenuItem(
string.Empty,
"Set Range Mode",
null,
true);
rangeModeMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
string.Empty,
DepthImageRangeMode.Auto.ToString(),
new RelayCommand(
() => this.DepthImageVisualizationObject.RangeMode = DepthImageRangeMode.Auto),
true));
rangeModeMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
string.Empty,
DepthImageRangeMode.Maximum.ToString(),
new RelayCommand(
() => this.DepthImageVisualizationObject.RangeMode = DepthImageRangeMode.Maximum),
true));
menuItems.Add(rangeModeMenuItem);
}
/// <inheritdoc/>
public virtual void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is VisualizationPanel visualizationPanel)
{
if (visualizationPanel.VisualizationObjects.Count > 0)
{
var visible = visualizationPanel.VisualizationObjects.Any(vo => vo.Visible);
menuItems.Add(
MenuItemHelper.CreateMenuItem(
IconSourcePath.ToggleVisibility,
visible ? "Hide All Visualizers" : "Show All Visualizers",
visualizationPanel.ToggleAllVisualizersVisibilityCommand,
null,
true));
}
menuItems.Add(
MenuItemHelper.CreateMenuItem(
IconSourcePath.ClearPanel,
$"Remove All Visualizers",
visualizationPanel.ClearPanelCommand,
null,
visualizationPanel.VisualizationObjects.Count > 0));
// Add copy to clipboard menu with sub-menu items
var copyToClipboardMenuItem = MenuItemHelper.CreateMenuItem(
string.Empty,
"Copy to Clipboard",
null);
copyToClipboardMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
null,
"Cursor Time",
visualizationPanel.Navigator.CopyToClipboardCommand,
null,
true,
visualizationPanel.Navigator.Cursor.ToString("M/d/yyyy HH:mm:ss.ffff")));
copyToClipboardMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
null,
"Session Name & Cursor Time",
visualizationPanel.Navigator.CopyToClipboardCommand,
null,
VisualizationContext.Instance.DatasetViewModel?.CurrentSessionViewModel != null,
VisualizationContext.Instance.DatasetViewModel.CurrentSessionViewModel.Name.ToString() + "@" + visualizationPanel.Navigator.Cursor.ToString("M/d/yyyy HH:mm:ss.ffff")));
menuItems.Add(copyToClipboardMenuItem);
menuItems.Add(
MenuItemHelper.CreateMenuItem(
null,
$"Go To Time ...",
visualizationPanel.Container.GoToTimeCommand,
null,
true));
}
}
/// <inheritdoc/>
public void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is VisualizationContainer visualizationContainer)
{
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.ZoomToSelection, "Zoom to Selection", visualizationContainer.ZoomToSelectionCommand));
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.ClearSelection, "Clear Selection", visualizationContainer.ClearSelectionCommand));
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.ZoomToSession, "Zoom to Session Extents", visualizationContainer.ZoomToSessionExtentsCommand));
}
}
/// <inheritdoc/>
public override void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is AudioVisualizationObject audioVisualizationObject && audioVisualizationObject.IsBound)
{
menuItems.Add(MenuItemHelper.CreateMenuItem(audioVisualizationObject.ContextMenuIconSource, audioVisualizationObject.EnableAudioCommandText, audioVisualizationObject.EnableAudioCommand));
}
base.AppendContextMenuItems(menuItems);
}
/// <inheritdoc/>
public override void AppendContextMenuItems(List <MenuItem> menuItems)
{
menuItems.Add(MenuItemHelper.CreateMenuItem(
null,
"Auto-Fit Axes",
this.VisualizationPanel.SetAutoAxisComputeModeCommand,
null,
this.VisualizationPanel.AxisComputeMode == AxisComputeMode.Manual));
base.AppendContextMenuItems(menuItems);
}
private void AddAnnotationEditMenuItems(List <MenuItem> menuItems)
{
// All of the following must be true to edit an annotation:
//
// 1) We must be bound to a source
// 2) Edit annotations values must be enabled.
// 3) The cursor must be over an annotation.
if (this.IsBound && this.EnableAnnotationValueEdit)
{
int index = this.GetAnnotationIndexByTime(this.Container.Navigator.Cursor);
if (index >= 0)
{
// Get the annotation to be edited
Message <TimeIntervalAnnotation> annotation = this.Data[index];
// Get the collection of schema definitions in the annotation
foreach (AnnotationSchemaDefinition schemaDefinition in this.Definition.SchemaDefinitions)
{
// Create a menuitem for the value
var valueMenuItem = MenuItemHelper.CreateMenuItem(IconSourcePath.Annotation, schemaDefinition.Name, null);
// If this is a finite schema, then get the list of possible values
if (schemaDefinition.Schema.IsFiniteAnnotationSchema)
{
// Get the collection of possible values
Type schemaType = schemaDefinition.Schema.GetType();
MethodInfo valuesProperty = schemaType.GetProperty("Values").GetGetMethod();
IEnumerable values = (IEnumerable)valuesProperty.Invoke(schemaDefinition.Schema, new object[] { });
// Create a menuitem for each value, with a command to update the value on the annotation.
foreach (object value in values)
{
var metadata = this.GetAnnotationValueMetadata(value, schemaDefinition.Schema);
valueMenuItem.Items.Add(MenuItemHelper.CreateAnnotationMenuItem(
value.ToString(),
metadata.BorderColor,
metadata.FillColor,
new PsiCommand(() => this.SetAnnotationValue(annotation, schemaDefinition.Name, value))));
}
}
else
{
valueMenuItem.Items.Add(MenuItemHelper.CreateMenuItem(
null,
annotation.Data.Values[schemaDefinition.Name].ToString(),
null));
}
menuItems.Add(valueMenuItem);
}
}
}
}
/// <inheritdoc/>
public override IEnumerable <MenuItem> GetAdditionalContextMenuItems()
{
List <MenuItem> menuItems = new List <MenuItem>();
// Add annotation edit menu items if we're above an annotation
this.AddAnnotationEditMenuItems(menuItems);
// Add the add annotation and delete annotation context menu items.
menuItems.Add(MenuItemHelper.CreateMenuItem(null, "Add Annotation", this.GetAddAnnotationCommand()));
menuItems.Add(MenuItemHelper.CreateMenuItem(null, "Delete Annotation", this.GetDeleteAnnotationCommand()));
return(menuItems);
}
/// <inheritdoc/>
public override void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is TimeIntervalAnnotationVisualizationObject annotationVisualizationObject && annotationVisualizationObject.IsBound)
{
// Add the add annotation context menu item
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.Annotation, "Add Annotation", annotationVisualizationObject.GetAddAnnotationCommand()));
// Add the delete annotation context menu item
ICommand deleteCommand = annotationVisualizationObject.GetDeleteAnnotationCommand();
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.Annotation, "Delete Annotation", deleteCommand, null, deleteCommand != null));
}
base.AppendContextMenuItems(menuItems);
}
/// <inheritdoc/>
public override void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is TimelineVisualizationPanel timelineVisualizationPanel)
{
// The show/hide legend menu
menuItems.Add(
MenuItemHelper.CreateMenuItem(
IconSourcePath.Legend,
timelineVisualizationPanel.ShowLegend ? $"Hide Legend" : $"Show Legend",
timelineVisualizationPanel.ShowHideLegendCommand));
}
base.AppendContextMenuItems(menuItems);
}
private void InsertPanelContextMenuItems(ContextMenu contextMenu)
{
contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.Legend, this.ShowLegend ? "Hide Legend" : "Show Legend", this.ShowHideLegendCommand));
contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.RemovePanel, "Remove Panel", this.RemovePanelCommand));
contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.ClearPanel, "Clear", this.ClearPanelCommand));
// Get the visualization object currently being snapped to (if any)
VisualizationObject snappedVisualizationObject = this.Container.SnapToVisualizationObject;
// Work out how many visualization objects we could potentially snap to. If one of
// this panel's visualization objects is currently being snapped to, then this total
// is actually one fewer, and we'll also need to add an "unsnap" menu item.
int snappableVisualizationObjectsCount = this.VisualizationObjects.Count;
if ((snappedVisualizationObject != null) && this.VisualizationObjects.Contains(snappedVisualizationObject))
{
snappableVisualizationObjectsCount--;
contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.Stream, string.Format("Unsnap from {0}", this.Container.SnapToVisualizationObject.Name), new VisualizationCommand <VisualizerMetadata>((v) => this.Container.SnapToVisualizationObject.ToggleSnapToStream())));
}
// If there's only 1 snappable visualization object in this panel, then create a
// direct menu, if there's more than 1 then create a cascading menu.
if (snappableVisualizationObjectsCount == 1)
{
VisualizationObject snappableVisualizationObject = this.VisualizationObjects.First(vo => vo != this.Container.SnapToVisualizationObject);
contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.SnapToStream, string.Format("Snap to {0}", snappableVisualizationObject.Name), new VisualizationCommand <VisualizerMetadata>((v) => snappableVisualizationObject.ToggleSnapToStream())));
}
else if (snappableVisualizationObjectsCount > 1)
{
// Create the top-level menu item
var snapMenuItem = MenuItemHelper.CreateMenuItem(IconSourcePath.SnapToStream, "Snap To", null);
// create the child menu items for each visualization object.
foreach (VisualizationObject visualizationObject in this.VisualizationObjects)
{
if (visualizationObject != this.Container.SnapToVisualizationObject)
{
snapMenuItem.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.SnapToStream, visualizationObject.Name, new VisualizationCommand <VisualizerMetadata>((v) => visualizationObject.ToggleSnapToStream())));
}
}
contextMenu.Items.Add(snapMenuItem);
}
contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.ZoomToSelection, "Zoom to Selection", this.ZoomToSelectionCommand));
contextMenu.Items.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.ZoomToSession, "Zoom to Session Extents", this.ZoomToSessionExtentsCommand));
}
/// <inheritdoc/>
public override IEnumerable <MenuItem> GetAdditionalContextMenuItems()
{
List <MenuItem> menuItems = new List <MenuItem>();
// Add the add annotation context menu item
menuItems.Add(MenuItemHelper.CreateMenuItem(null, "Add Annotation", this.GetAddAnnotationCommand()));
// If the mouse is above an existing annotation, add the delete annotation context menu item.
ICommand deleteCommand = this.GetDeleteAnnotationCommand();
if (deleteCommand != null)
{
menuItems.Add(MenuItemHelper.CreateMenuItem(null, "Delete Annotation", deleteCommand));
}
return(menuItems);
}
private void AddContextMenuItems(IContextMenuItemsSource menuItemSource, bool addAsCascadingMenu)
{
// Assume the menu root is the main context menu.
ItemsControl root = this.ContextMenu;
// If we're adding a cascading menu, add the top level of the cascading
// menu to the main context menu and set the root to it instead.
if (addAsCascadingMenu)
{
if (root.Items.Count > 0)
{
root.Items.Add(new Separator());
}
ItemsControl newRoot = MenuItemHelper.CreateMenuItem(IconSourcePath.Stream, menuItemSource.ContextMenuObjectName, null);
root.Items.Add(newRoot);
root = newRoot;
}
// Get the list of context menu items from the context menu items source
var menuItems = new List <MenuItem>();
menuItemSource.AppendContextMenuItems(menuItems);
// Add the context menu items to the context menu root.
if (menuItems != null && menuItems.Any())
{
if (root.Items.Count > 0)
{
root.Items.Add(new Separator());
}
foreach (var menuItem in menuItems)
{
if (menuItem != null)
{
root.Items.Add(menuItem);
}
else
{
root.Items.Add(new Separator());
}
}
}
}
/// <inheritdoc/>
public void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is InstantVisualizationContainer instantVisualizationContainer)
{
// Find the child panel that the mouse is over
// Run a hit test at the mouse cursor
this.mouseOverVisualizationPanel = null;
VisualTreeHelper.HitTest(
this,
null,
new HitTestResultCallback(this.ContextMenuHitTestResult),
new PointHitTestParameters(Mouse.GetPosition(this)));
if (this.mouseOverVisualizationPanel != null)
{
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.InstantContainerAddCellLeft, $"Insert Cell to the Left", instantVisualizationContainer.CreateIncreaseCellCountCommand(this.mouseOverVisualizationPanel, true)));
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.InstantContainerAddCellRight, $"Insert Cell to the Right", instantVisualizationContainer.CreateIncreaseCellCountCommand(this.mouseOverVisualizationPanel, false)));
menuItems.Add(MenuItemHelper.CreateMenuItem(null, $"Remove Cell", instantVisualizationContainer.CreateRemoveCellCommand(this.mouseOverVisualizationPanel)));
menuItems.Add(MenuItemHelper.CreateMenuItem(IconSourcePath.InstantContainerRemoveCell, $"Remove {instantVisualizationContainer.Name}", instantVisualizationContainer.RemovePanelCommand));
}
}
}
/// <inheritdoc/>
public override void AppendContextMenuItems(List <MenuItem> menuItems)
{
base.AppendContextMenuItems(menuItems);
if (this.DataContext is PlotVisualizationObject <TData> plotVisualizationObject)
{
if (plotVisualizationObject.MarkerStyle == MarkerStyle.None)
{
menuItems.Add(MenuItemHelper.CreateMenuItem(
null,
"Show Markers",
new VisualizationCommand(() => plotVisualizationObject.MarkerStyle = MarkerStyle.Circle)));
}
else
{
menuItems.Add(MenuItemHelper.CreateMenuItem(
null,
"Hide Markers",
new VisualizationCommand(() => plotVisualizationObject.MarkerStyle = MarkerStyle.None)));
}
}
}
/// <inheritdoc/>
public virtual void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is VisualizationPanel visualizationPanel)
{
if (visualizationPanel.VisualizationObjects.Count > 0)
{
var visible = visualizationPanel.VisualizationObjects.Any(vo => vo.Visible);
menuItems.Add(MenuItemHelper.CreateMenuItem(
IconSourcePath.ToggleVisibility,
visible ? "Hide All Visualizers" : "Show All Visualizers",
visualizationPanel.ToggleAllVisualizersVisibilityCommand,
null,
true));
}
menuItems.Add(MenuItemHelper.CreateMenuItem(
IconSourcePath.ClearPanel,
$"Remove All Visualizers",
visualizationPanel.ClearPanelCommand,
null,
visualizationPanel.VisualizationObjects.Count > 0));
}
}
/// <inheritdoc/>
public override void AppendContextMenuItems(List <MenuItem> menuItems)
{
if (this.DataContext is InstantVisualizationPanel visualizationPanel)
{
// Add Set Cursor Epsilon menu with sub-menu items
var setCursorEpsilonMenuItem = MenuItemHelper.CreateMenuItem(
string.Empty,
"Set Default Cursor Epsilon",
null);
_ = setCursorEpsilonMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
null,
"Infinite Past",
new RelayCommand(() => this.UpdateDefaultCursorEpsilon(visualizationPanel, "Infinite Past", int.MaxValue, 0), true)));
setCursorEpsilonMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
null,
"Last 5 seconds",
new RelayCommand(() => this.UpdateDefaultCursorEpsilon(visualizationPanel, "Last 5 seconds", 5000, 0), true)));
setCursorEpsilonMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
null,
"Last 1 second",
new RelayCommand(() => this.UpdateDefaultCursorEpsilon(visualizationPanel, "Last 1 second", 1000, 0), true)));
setCursorEpsilonMenuItem.Items.Add(
MenuItemHelper.CreateMenuItem(
null,
"Last 50 milliseconds",
new RelayCommand(() => this.UpdateDefaultCursorEpsilon(visualizationPanel, "Last 50 milliseconds", 50, 0), true)));
menuItems.Add(setCursorEpsilonMenuItem);
}
base.AppendContextMenuItems(menuItems);
}