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)); }