protected override void OnContextMenuOpening(ContextMenuEventArgs e)
		{
			var treeNode = this.SelectedItem as ModelCollectionTreeNode;
			if (treeNode != null) {
				treeNode.ShowContextMenu();
			}
		}

        private void DataGridContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            var element = e.OriginalSource as FrameworkElement;
            var dg = (MultiSelector)sender;

            if (element != null && element.DataContext is ITrack)
            {
                var commandbar = new CommandBar();

                if (dg.SelectedItems.Count == 1)
                {
                    var track = (ITrack)dg.SelectedItems[0];
                    _eventAggregator.GetEvent<TrackCommandBarEvent>().Publish(new TrackCommandBarModel(track, commandbar));
                }
                else if (dg.SelectedItems.Count > 1)
                {
                    var tracks = dg.SelectedItems.Cast<ITrack>();
                    _eventAggregator.GetEvent<TracksCommandBarEvent>().Publish(new TracksCommandBarModel(tracks, commandbar));
                }

                dg.ContextMenu = new CommandBarContextMenu
                {
                    ItemsSource = commandbar.ChildMenuItems
                };
            }
        }

 private void RichTextBoxContextMenuClosing(object sender, ContextMenuEventArgs e)
 {
     foreach (Control menuItem in dynamicContextMenuItems)
     {
         contextMenu.Items.Remove(menuItem);
     }
 }

        private void listView2_ContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            if (listView2.SelectedItems == null || listView2.SelectedItems.Count == 0)
            {
                e.Handled = true;
                return;
            }

            System.Windows.Controls.ListBox src = e.Source as System.Windows.Controls.ListBox;

            src.ContextMenu.Items.Clear();

            MenuItem m = new MenuItem();
            m.Foreground = Brushes.Black;
            m.Header = "Download selected items";
            m.Command = Model.Download;
            m.CommandParameter = listView2.SelectedItems;
            src.ContextMenu.Items.Add(m);

           /* m = new MenuItem();
            m.Foreground = Brushes.Black;
            m.Header = "View in share";
            m.Command = Model.ViewShare;
            m.CommandParameter = listView2.SelectedItems;
            src.ContextMenu.Items.Add(m);*/
        }

		void treeView_ContextMenuOpening(object sender, ContextMenuEventArgs e)
		{
			SharpTreeNode[] selectedNodes = treeView.GetTopLevelSelection().ToArray();
			if (selectedNodes.Length == 0)
				return;
			ContextMenu menu = new ContextMenu();
			foreach (var category in entries.OrderBy(c => c.Metadata.Order).GroupBy(c => c.Metadata.Category)) {
				if (menu.Items.Count > 0) {
					menu.Items.Add(new Separator());
				}
				foreach (var entryPair in category) {
					IContextMenuEntry entry = entryPair.Value;
					if (entry.IsVisible(selectedNodes)) {
						MenuItem menuItem = new MenuItem();
						menuItem.Header = entryPair.Metadata.Header;
						if (!string.IsNullOrEmpty(entryPair.Metadata.Icon)) {
							menuItem.Icon = new Image {
								Width = 16,
								Height = 16,
								Source = Images.LoadImage(entry, entryPair.Metadata.Icon)
							};
						}
						if (entryPair.Value.IsEnabled(selectedNodes)) {
							menuItem.Click += delegate {
								entry.Execute(selectedNodes);
							};
						}
						menu.Items.Add(menuItem);
					}
				}
			}
			if (menu.Items.Count > 0)
				treeView.ContextMenu = menu;
		}

        protected override void OnContextMenuOpening(ContextMenuEventArgs e)
        {
            this.SelectedLink = boxOutput.SelectedLink;
            if (!string.IsNullOrEmpty(this.SelectedLink))
            {
                if (Constants.UrlRegex.IsMatch(this.SelectedLink))
                {
                    boxOutput.ContextMenu = this.Resources["cmHyperlink"] as ContextMenu;
                }
                else
                {
                    if (this.Type == ChatPageType.DccChat)
                    {
                        return;
                    }
                    this.SelectedLink = this.GetNickWithoutLevel(this.SelectedLink);
                    boxOutput.ContextMenu = this.Resources["cmNickname"] as ContextMenu;
                }
                boxOutput.ContextMenu.IsOpen = true;
                e.Handled = true;
            }
            else
            {

                boxOutput.ContextMenu = this.GetDefaultContextMenu();
                if (this.IsServer && boxOutput.ContextMenu != null)
                {
                    boxOutput.ContextMenu.Items.Refresh();
                }
            }

            base.OnContextMenuOpening(e);
        }

 private void listFilters_ContextMenuOpening(object sender, ContextMenuEventArgs e)
 {
     if (listFilters.SelectedIndex==-1)
     {
         e.Handled = true;
     }
 }

        private static void ContextMenu_Showing(SystemOptionsView systemOptionsView, object sender, ContextMenuEventArgs e)
        {
            if (e.ContextMenuGroupCollection.Any(c => c.Type == ContextMenuGroupType.Custom))
            {
                return;
            }

            var cmd = new Telerik.Windows.Documents.RichTextBoxCommands.InsertPictureCommand(systemOptionsView.HTMLRichTextBox);
            var insertImageMenuItem = new RadMenuItem
                                          {
                                              Header = "Insert Image...",
                                              Command = cmd,
                                              Icon = new Image()
                                                      {
                                                          Source = new BitmapImage(new Uri("/Cebos.Veyron.Common.SL;component/Assets/Icons/presentation.png", UriKind.Relative)),
                                                          //// This is valid too, if the image is within the same assembly
                                                          //Source = new BitmapImage(new Uri("Images/MenuIcons/Clear.png", UriKind.Relative)),              
                                                          Stretch = Stretch.Fill
                                                      }
                                          };
            var customContextMenuGroup = new ContextMenuGroup { insertImageMenuItem };
            e.ContextMenuGroupCollection.Add(customContextMenuGroup);

            var textFormatting = e.ContextMenuGroupCollection.FirstOrDefault(x => x.Type == ContextMenuGroupType.FloatingBlockCommands);
            if (textFormatting != null)
            {
                e.ContextMenuGroupCollection.Remove(textFormatting);
            }
        }

        private void MainWindowContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            var fe = sender as FrameworkElement;
            var _scriptingUIHelper = CompositionManager.Get<IScriptingUIHelper>();
            var _scriptingConfiguration = CompositionManager.Get<IScriptingConfiguration>();

            if (fe == null)
                return;

            var newcontextualmenu = new ContextMenu();
            if (_scriptingUIHelper != null)
            {
                List<object> menu = _scriptingUIHelper.CreateContextMenusFromScripts(false,
                                                                                     _scriptingConfiguration.
                                                                                         MainWindowContextMenuEntryPoint,
                                                                                     MenuItemClick);

                if (menu != null)
                {
                    foreach (object i in menu)
                        newcontextualmenu.Items.Add(i);
                }
            }

            fe.ContextMenu = newcontextualmenu;
        }

        protected override void OnContextMenuOpening(ContextMenuEventArgs e)
        {
            this.ContextMenu.ItemsSource = ContextMenuOptions;

            if (this.ContextMenu.Items.Count == 0)
                e.Handled = true;

            base.OnContextMenuOpening(e);
        }

 private void _OnContextMenuOpening(object sender, ContextMenuEventArgs e)
 {
     try
     {
       //  _UpdateContextMenuItemsStatus(sender as Button);
     }
     catch
     { }
 }

        private void contextMenuSelectedTextOpening(object sender, ContextMenuEventArgs e)
        {
            var fe = sender as FrameworkElement;

            var newcontextualmenu = new ContextMenu();
            var _scriptingUIHelper = CompositionManager.Get<IScriptingUIHelper>();
            var _scriptingConfiguration = CompositionManager.Get<IScriptingConfiguration>();

            var ewf = Keyboard.FocusedElement as UIElement; // this retrieves the current textbox that has selection
            if (ewf is CompositionTextBox) // if it is a compositiontextbox
            {
                var tbwf = ewf as RichTextBox;
                var spellingSuggestions = tbwf.GetSpellingError(tbwf.CaretPosition);
                if (spellingSuggestions != null)
                {
                    if (spellingSuggestions.Suggestions.HasItems())
                    {
                        foreach (string str in spellingSuggestions.Suggestions)
                        {
                            var mi = new MenuItem
                                         {
                                             Header = str,
                                             FontWeight = FontWeights.Bold,
                                             Command = EditingCommands.CorrectSpellingError,
                                             CommandParameter = str,
                                             CommandTarget = tbwf
                                         };
                            newcontextualmenu.Items.Add(mi);
                        }
                    }
                    else
                    {
                        var mi = new MenuItem
                                     {Header = "No Suggestions", FontWeight = FontWeights.Bold, IsEnabled = false};
                        newcontextualmenu.Items.Add(mi);
                    }
                    newcontextualmenu.Items.Add(new Separator());
                }
            }
            if (_scriptingUIHelper != null)
            {
                _scriptingUIHelper.createCCPContextualMenus(newcontextualmenu, contextMenuItem_StandardCCP);

                var menu =
                    _scriptingUIHelper.CreateContextMenusFromScripts(true,
                                                                     _scriptingConfiguration.
                                                                         ComposeTextContextMenuEntryPoint,
                                                                     mi_TextSelect_Click);

                if (menu != null)
                {
                    foreach (object i in menu)
                        newcontextualmenu.Items.Add(i);
                }
            }
            if (fe != null) fe.ContextMenu = newcontextualmenu;
        }

 //Not Needed anymore since WindowChrome is Doing the Job now
 protected override void OnContextMenuOpening(ContextMenuEventArgs e)
 {
     //if (e.Handled)
     //    return;
     //var source = PresentationSource.FromVisual(this) as HwndSource;
     //if (source != null)
     //    ModernChromeWindow.ShowWindowMenu(source, this, Mouse.GetPosition(this), RenderSize);
     //e.Handled = true;
 }

        private void OnContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            var commit = GetCurrentSelectedCommit();

            if (commit == null)
            {
                e.Handled = true;
                return;
            }
        }

		void FrameworkElement_ContextMenuOpening(object sender, ContextMenuEventArgs e) {
			if (IsIgnored(sender, e))
				return;

			bool? b = menuService.ShowContextMenu(e, element, ctxMenuGuid, ctxMenuGuid, new GuidObject(guid, element), provider, initCtxMenu, e.CursorLeft == -1 && e.CursorTop == -1);
			if (b == null)
				return;
			if (!b.Value)
				e.Handled = true;
		}

 private static void OnDocumentViewerContextMenuOpening(object sender, ContextMenuEventArgs e)
 {
     if (e.CursorLeft == KeyboardInvokedSentinel)
     {
         DocumentViewer dv = sender as DocumentViewer;
         if (dv != null && dv.ScrollViewer != null)
         {
             OnContextMenuOpening(dv.ScrollViewer.Content, e);
         }
     }
 }

        /// <summary>
        /// Opens the shell context menu instead of the normal context menu on right click.
        /// </summary>
        static void OnContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            Control control = sender as Control;

            // Attempt to open the explorer context menu for the application. If the file does not exist or
            // there is some other problem then a context menu (defined in the XAML) with just "Edit Entry"
            // and "Remove Entry" is opened instead.
            if (control != null && control.DataContext is ApplicationViewModel)
            {
                ApplicationViewModel application = (ApplicationViewModel)control.DataContext;

                if (File.Exists(application.FilePath))
                {
                    ContextMenuWrapper cmw = new ContextMenuWrapper();
                    cmw.OnQueryMenuItems += (QueryMenuItemsEventHandler)delegate(object s, QueryMenuItemsEventArgs args)
                    {
                        args.ExtraMenuItems = new string[] { "Edit Dock Entry", "Remove Dock Entry", "---" };

                        args.GrayedItems = new string[] { "delete", "rename", "cut", "copy" };
                        args.HiddenItems = new string[] { "link" };
                        args.DefaultItem = 1;
                    };
                    cmw.OnAfterPopup += (AfterPopupEventHandler) delegate(object s, AfterPopupEventArgs args)
                    {
                        Messenger.Default.Send<ShellContextMenuMessage>(ShellContextMenuMessage.Closed());
                    };

                    Messenger.Default.Send<ShellContextMenuMessage>(ShellContextMenuMessage.Opened());

                    try
                    {
                        FileSystemInfoEx[] files = new[] { FileInfoEx.FromString(application.FilePath) };
                        int[] position = Win32Mouse.GetMousePosition();
                        string command = cmw.Popup(files, new System.Drawing.Point(position[0], position[1]));

                        // Handle the click on the 'ExtraMenuItems'.
                        switch (command)
                        {
                            case "Edit Dock Entry":
                                Messenger.Default.Send<ApplicationMessage>(ApplicationMessage.Edit(application));
                                break;
                            case "Remove Dock Entry":
                                Messenger.Default.Send<ApplicationMessage>(ApplicationMessage.Remove(application));
                                break;
                        }
                        e.Handled = true; // Don't open the normal context menu.
                    }
                    catch (Exception ex)
                    {
                        Debug.Print("Problem displaying shell context menu: {0}", ex);
                    }
                }
            }
        }

 private void HandlerForCMO2(object sender, ContextMenuEventArgs e)
 {
     if (!_flagForCustomContextMenu)
     {
         e.Handled = true; //need to suppress empty menu
         var fe = e.Source as FrameworkElement;
         fe.ContextMenu = BuildMenu();
         _flagForCustomContextMenu = true;
         fe.ContextMenu.IsOpen = true;
     }
 }

 int mousepos_whenmenuopened = -1;  // The mouse position (as a text offset) upon context menu opening; -1 = could not be determined
 private void txtCodeContextMenu_ContextMenuOpening(object sender, ContextMenuEventArgs e)
 {
     // the mouse position upon context menu opening is stored in mousepos_whenmenuopened
     Nullable<TextViewPosition> vp = txtCode.TextArea.TextView.GetPosition(new Point(e.CursorLeft, e.CursorTop));
     if (vp != null)
     {
         mousepos_whenmenuopened = txtCode.Document.GetOffset(vp.Value.Line, vp.Value.Column);
     }
     else
         mousepos_whenmenuopened = -1;
 }

        private void MainTree_ContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            if (MainTree.SelectedItem == null)
            {
                e.Handled = true;
                return;
            }

            var item = (IMainTreeItem) ((TreeViewItem) MainTree.SelectedItem).Tag;
            item.CreateContextMenu();
        }