private void EditFiniteAnnotationValue(TimeIntervalAnnotationDisplayData displayData, int trackId)
{
// Get the schema definition
AnnotationSchemaDefinition schemaDefinition = displayData.Definition.SchemaDefinitions[trackId];
// 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 new context menu
ContextMenu contextMenu = new ContextMenu();
// 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);
contextMenu.Items.Add(MenuItemHelper.CreateAnnotationMenuItem(
value.ToString(),
metadata.BorderColor,
metadata.FillColor,
new PsiCommand(() => this.StreamVisualizationObject.SetAnnotationValue(displayData.Annotation, schemaDefinition.Name, value))));
}
// Add a handler so that the timeline visualization panel continues to receive mouse move messages
// while the context menu is displayed, and remove the handler once the context menu closes.
MouseEventHandler mouseMoveHandler = new MouseEventHandler(this.FindTimelineVisualizationPanelView().ContextMenuMouseMove);
contextMenu.AddHandler(MouseMoveEvent, mouseMoveHandler, true);
contextMenu.Closed += (sender, e) => contextMenu.RemoveHandler(MouseMoveEvent, mouseMoveHandler);
// Show the context menu
contextMenu.IsOpen = true;
}
private void AddMenuItemButton_Click(object sender, EventArgs e)
{
using (var form = new MenuItemAddForm())
{
var result = form.ShowDialog();
if (result == DialogResult.OK)
{
MenuItemHelper addedItem = form.ReturnValue1;
bool exist = false;
foreach (var item in items)
{
if (item.ProductName == addedItem.ProductName)
{
exist = true;
item.Quantity += addedItem.Quantity;
break;
}
}
if (!exist)
{
items.Add(addedItem);
}
BindGrid();
}
}
BindGrid();
}
/// <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);
}
public void Expand()
{
if (ExpandCollapseState != ExpandCollapseState.Expanded)
{
MenuItemHelper.SimulateClick(menuItem);
}
}
public NavigationModel(IList <MainMenuDto> menuItems, Uri requestedUrl, LanguageDto currentLanguage)
{
// Build main navigation view model
MainVav = new MenuViewModel();
foreach (MainMenuDto item in menuItems)
{
MenuItemViewModel menuItem = new MenuItemViewModel(item, currentLanguage);
MainVav.MenuItems.Add(menuItem);
// Find out current item
menuItem.IsCurrent = MenuItemHelper.IsCurrent(item.NavigateUrl, requestedUrl.AbsolutePath, currentLanguage);
if (menuItem.IsCurrent)
{
// current item found
// Build sub menu view model
SubNav = new MenuViewModel();
foreach (MainMenuDto subItem in item.SubMenus)
{
MenuItemViewModel subMenuItem = new MenuItemViewModel(subItem, currentLanguage);
SubNav.MenuItems.Add(subMenuItem);
// Find out current item
subMenuItem.IsCurrent = MenuItemHelper.IsCurrent(subMenuItem.NavigateUrl, requestedUrl.AbsolutePath, currentLanguage);
}
}
}
}
public async Task <IViewComponentResult> InvokeAsync(string currentController)
{
var items = MenuItemHelper.GetAllMenuItem();
var item = items.Where(i => i.Controller == currentController).FirstOrDefault();
return(View(item));
}
/// <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);
}
public void Enable(string menuID, string controlContext)
{
var menu = new MenuItemHelper()
{
MenuID = menuID,
ControlContext = controlContext,
IsSystemMenu = true
};
_menuItems.Add(menu.MenuID, menu);
}
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);
}
public void Add(string menuID, string caption, int position, string controlContext)
{
var menu = new MenuItemHelper()
{
MenuID = menuID,
ParentID = "1280",
Caption = caption,
Position = position,
ControlContext = controlContext,
IsSystemMenu = false
};
_menuItems.Add(menu.MenuID, menu);
}
public void Collapse()
{
if (ExpandCollapseState != ExpandCollapseState.Collapsed)
{
if (menuItem.Parent == itemProvider.ParentMenu)
{
MenuItemHelper.SimulateClick(menuItem);
}
else if (menuItem.Parent is SWF.MenuItem)
{
MenuItemHelper.SimulateMotion((SWF.MenuItem)menuItem.Parent);
}
}
}
public void ExpandCollapseStateChangedEventTest()
{
MainMenu mainMenu = new MainMenu();
MenuItem item1 = new MenuItem("item1");
MenuItem item2 = new MenuItem("item2");
MenuItem item1sub1 = new MenuItem("item1 sub1");
MenuItem item1sub2 = new MenuItem("item1 sub2");
MenuItem item1sub1sub1 = new MenuItem("item1 sub1 sub1");
item1sub1.MenuItems.Add(item1sub1sub1);
item1.MenuItems.Add(item1sub1);
item1.MenuItems.Add(item1sub2);
mainMenu.MenuItems.Add(item1);
mainMenu.MenuItems.Add(item2);
Form.Menu = mainMenu;
IRawElementProviderSimple item1Provider =
ProviderFactory.GetProvider(item1);
bridge.ResetEventLists();
System.Threading.Thread.Sleep(1000);
//Expand
MenuItemHelper.SimulateClick(item1);
var propertyEventTuple = bridge.GetAutomationPropertyEventFrom(item1Provider,
ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty.Id);
Assert.IsNotNull(propertyEventTuple,
"ExpandCollapseState property change event should be raised");
Assert.AreEqual(ExpandCollapseState.Expanded,
propertyEventTuple.e.NewValue,
"New ExpandCollapseState value should be Expanded");
bridge.ResetEventLists();
// Collapse
MenuItemHelper.SimulateClick(item1);
propertyEventTuple = bridge.GetAutomationPropertyEventFrom(item1Provider,
ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty.Id);
Assert.IsNotNull(propertyEventTuple,
"ExpandCollapseState property change event should be raised");
Assert.AreEqual(ExpandCollapseState.Collapsed,
propertyEventTuple.e.NewValue,
"New ExpandCollapseState value should be Expanded");
}
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));
}
}
}
/// <summary>
/// Into A1 insert forms.ContextMenuHelper.Get
/// </summary>
/// <param name="cm"></param>
public static void Create(Action <bool> SetCancelClosing, Stream streamIcon, VoidObjectEventArgs onDoubleClick, ContextMenu cm, Action <object, EventArgs> quitAction, Dictionary <string, Action> contextMenuItems = null)
{
quit = quitAction;
setCancelClosing = SetCancelClosing;
System.Windows.Forms.NotifyIcon ni = new System.Windows.Forms.NotifyIcon();
ni.Icon = new System.Drawing.Icon(streamIcon);
ni.Visible = true;
ni.ContextMenu = cm;
ni.Click += new EventHandler(onDoubleClick);
//var mi = MenuItemHelper.Get(quitS, Quit);
//ni.ContextMenu.MenuItems.Add(mi);
if (contextMenuItems != null)
{
foreach (var item in contextMenuItems)
{
ni.ContextMenu.MenuItems.Add(MenuItemHelper.Get(item.Key, new VoidObjectEventArgs((a, b) => item.Value())));
}
}
}
/// <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);
}
private void OnResize(object sender, EventArgs e)
{
itemProvider.SetBounds(MenuItemHelper.GetBounds(itemProvider.Component as SWF.MenuItem));
RaiseAutomationPropertyChangedEvent();
}
public ResourceNode(
DocumentClient client,
dynamic document,
ResourceType resoureType,
PartitionKeyDefinition partitionKey = null,
string nodeText = null,
string dataBaseId = null,
string documentCollectionId = null
)
{
_databaseId = dataBaseId;
_documentCollectionId = documentCollectionId;
_resourceType = resoureType;
var docAsResource = (document as Resource);
var isDocument = _resourceType == ResourceType.Document;
var isOffer = _resourceType == ResourceType.Offer;
var isConflict = _resourceType == ResourceType.Conflict;
var isPermission = _resourceType == ResourceType.Permission;
var isAttachment = _resourceType == ResourceType.Attachment;
var isStoredProcedure = _resourceType == ResourceType.StoredProcedure;
var isTrigger = _resourceType == ResourceType.Trigger;
var isUserDefinedFunction = _resourceType == ResourceType.UserDefinedFunction;
var isUser = _resourceType == ResourceType.User;
if (isDocument)
{
var prefix = string.Empty;
if (partitionKey != null)
{
if (partitionKey.Paths.Count > 0)
{
var path = partitionKey.Paths[0];
prefix = document.GetPropertyValue <string>(path.Substring(1));
prefix = prefix + "_";
}
}
Text = string.IsNullOrWhiteSpace(nodeText)
? prefix + docAsResource.Id
: prefix + nodeText;
}
else if (isOffer)
{
string version = document.GetPropertyValue <string>("offerVersion");
if (string.IsNullOrEmpty(version))
{
var offer = document as Offer;
Text = string.Format("{0}_{1}", offer.OfferType, offer.GetPropertyValue <string>("offerResourceId"));
}
else
{
var offer = document as OfferV2;
Text = string.Format("{0}_{1}", offer.Content.OfferThroughput, offer.GetPropertyValue <string>("offerResourceId"));
}
}
else
{
Text = docAsResource.Id;
}
Tag = document;
_client = client;
var readMenuItem = AddMenuItem(string.Format("Read {0}", _resourceType), myMenuItemRead_Click);
MenuItemHelper.SetCustomShortcut(readMenuItem, Keys.Enter);
if (!isConflict && !isOffer)
{
AddMenuItem(string.Format("Replace {0}", _resourceType), myMenuItemUpdate_Click, Shortcut.CtrlR);
}
if (!isOffer)
{
AddMenuItem(string.Format("Delete {0}", _resourceType), myMenuItemDelete_Click, Shortcut.Del);
}
if (!isConflict && !isOffer)
{
_contextMenu.MenuItems.Add("-");
AddMenuItem("Copy id to clipboard", myMenuItemCopyIdToClipBoard_Click, Shortcut.CtrlShiftC);
AddMenuItem(string.Format("Copy {0} to clipboard", _resourceType), myMenuItemCopyToClipBoard_Click, Shortcut.CtrlC);
var cpWithnewIdItem = AddMenuItem(string.Format("Copy {0} to clipboard with new id", _resourceType), myMenuItemCopyToClipBoardWithNewId_Click);
MenuItemHelper.SetCustomShortcut(cpWithnewIdItem, Keys.Control | Keys.Alt | Keys.C);
if (isDocument)
{
var createWithnewIdItem = AddMenuItem(
string.Format("Create {0} with new id based on this", _resourceType), (sender, e) => InvokeCreateNewDocumentBasedOnSelectedWithNewId()
);
MenuItemHelper.SetCustomShortcut(createWithnewIdItem, Keys.Control | Keys.Alt | Keys.N);
}
}
if (isPermission)
{
ImageKey = "Permission";
SelectedImageKey = "Permission";
}
else if (isAttachment)
{
ImageKey = "Attachment";
SelectedImageKey = "Attachment";
AddMenuItem("Download media", myMenuItemDownloadMedia_Click);
AddMenuItem("Render media", myMenuItemRenderMedia_Click);
}
else if (isStoredProcedure || isTrigger || isUserDefinedFunction)
{
ImageKey = "Javascript";
SelectedImageKey = "Javascript";
if (isStoredProcedure)
{
AddMenuItem(string.Format("Execute {0}", _resourceType), myMenuItemExecuteStoredProcedure_Click);
}
}
else if (isUser)
{
ImageKey = "User";
SelectedImageKey = "User";
Nodes.Add(new PermissionNode(_client));
}
else if (isDocument)
{
Nodes.Add(new TreeNode("Fake"));
_contextMenu.MenuItems.Add("-");
AddMenuItem("Create attachment", myMenuItemCreateAttachment_Click);
AddMenuItem("Create attachment from file...", myMenuItemAttachmentFromFile_Click);
}
else if (isConflict)
{
ImageKey = "Conflict";
SelectedImageKey = "Conflict";
}
else if (isOffer)
{
ImageKey = "Offer";
SelectedImageKey = "Offer";
}
}
public async Task <IViewComponentResult> InvokeAsync()
{
var items = MenuItemHelper.GetParentMenuItem();
return(View(items));
}
