File: src\Framework\System\windows\Documents\TextEditorContextMenu.cs
Project: wpf\PresentationFramework.csproj (PresentationFramework)
//---------------------------------------------------------------------------
//
// File: TextEditorContextMenu.cs
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
// Description: A Component of TextEditor supporting the default ContextMenu.
//
//---------------------------------------------------------------------------
 
namespace System.Windows.Documents
{
    using MS.Internal;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Controls.Primitives;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Threading;
    using System.Runtime.InteropServices;
    using System.Security;
    using System.Security.Permissions;
    using MS.Win32;
    using System.Windows.Interop;
 
    // A Component of TextEditor supporting the default ContextMenu.
    internal static class TextEditorContextMenu
    {
        //------------------------------------------------------
        //
        //  Class Internal Methods
        //
        //------------------------------------------------------
 
        #region Class Internal Methods
 
        // Registers all text editing command handlers for a given control type.
        internal static void _RegisterClassHandlers(Type controlType, bool registerEventListeners)
        {
            if (registerEventListeners)
            {
                EventManager.RegisterClassHandler(controlType, FrameworkElement.ContextMenuOpeningEvent, new ContextMenuEventHandler(OnContextMenuOpening));
            }
        }
 
        // Callback for FrameworkElement.ContextMenuOpeningEvent.
        // If the control is using the default ContextMenu, we initialize it
        // here.
        /// <SecurityNote>
        /// Critical - calls EditorContextMenu.AddMenuItems, using the UserInitiated
        ///             bit in the event args, to add (critical) clipboard commands.
        /// TreatAsSafe - the bit is protected by UserIniatedRoutedEvent permission
        /// </SecurityNote>
        [SecurityCritical,SecurityTreatAsSafe]
        internal static void OnContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            TextEditor This = TextEditor._GetTextEditor(sender);
            const double KeyboardInvokedSentinel = -1.0; // e.CursorLeft has this value when the menu is invoked with the keyboard.
 
            if (This == null || This.TextView == null)
            {
                return;
            }
 
            // Get the mouse position that base on RenderScope which we will set
            // the caret on the RenderScope.
            Point renderScopeMouseDownPoint = Mouse.GetPosition(This.TextView.RenderScope);
            ContextMenu contextMenu = null;
            bool startPositionCustomElementMenu = false;
 
            if (This.IsReadOnly)
            {
                // If the TextEditor is ReadOnly, only take action if
                // 1. The selection is non-empty AND
                // 2. The user clicked inside the selection.
                if ((e.CursorLeft != KeyboardInvokedSentinel && !This.Selection.Contains(renderScopeMouseDownPoint)) ||
                    (e.CursorLeft == KeyboardInvokedSentinel && This.Selection.IsEmpty))
                {
                    return;
                }
            }
            else if ((This.Selection.IsEmpty || e.TargetElement is TextElement) &&
                     e.TargetElement != null)
            {
                // Targeted element has its own ContextMenu, don't override it.
                contextMenu = (ContextMenu)e.TargetElement.GetValue(FrameworkElement.ContextMenuProperty);
            }
            else if (e.CursorLeft == KeyboardInvokedSentinel)
            {
                // If the menu was invoked from the keyboard, walk up the tree
                // from the selection.Start looking for a custom menu.
                TextPointer start = GetContentPosition(This.Selection.Start) as TextPointer;
                if (start != null)
                {
                    TextElement element = start.Parent as TextElement;
 
                    while (element != null)
                    {
                        contextMenu = (ContextMenu)element.GetValue(FrameworkElement.ContextMenuProperty);
                        if (contextMenu != null)
                        {
                            startPositionCustomElementMenu = true;
                            break;
                        }
                        element = element.Parent as TextElement;
                    }
                }
            }
 
            // Update the selection caret.
            //
            // A negative offset for e.CursorLeft means the user invoked
            // the menu with a hotkey (shift-F10).  Don't mess with the caret
            // unless the user right-clicked.
            if (e.CursorLeft != KeyboardInvokedSentinel)
            {
                if (!TextEditorMouse.IsPointWithinInteractiveArea(This, Mouse.GetPosition(This.UiScope)))
                {
                    // Don't bring up a context menu if the user clicked on non-editable space.
                    return;
                }
 
                // Don't update the selection caret if we're bringing up a custom UIElement
                // ContextMenu.
                if (contextMenu == null || !(e.TargetElement is UIElement))
                {
                    using (This.Selection.DeclareChangeBlock()) // NB: This raises a PUBLIC EVENT.
                    {
                        // If we're not over the selection, move the caret.
                        if (!This.Selection.Contains(renderScopeMouseDownPoint))
                        {
                            TextEditorMouse.SetCaretPositionOnMouseEvent(This, renderScopeMouseDownPoint, MouseButton.Right, 1 /* clickCount */);
                        }
                    }
                }
            }
 
            if (contextMenu == null)
            {
                // If someone explicitly set it null -- don't mess with it.
                if (This.UiScope.ReadLocalValue(FrameworkElement.ContextMenuProperty) == null)
                    return;
 
                // Grab whatever's set to the UiScope's ContextMenu property.
                contextMenu = This.UiScope.ContextMenu;
            }
 
            // If we are here, it means that either a custom context menu or our default context menu will be opened.
            // Setting this flag ensures that we dont loose selection highlight while the context menu is open.
            This.IsContextMenuOpen = true;
 
            // If it's not null, someone's overriding our default -- don't mess with it.
            if (contextMenu != null && !startPositionCustomElementMenu)
            {
                // If the user previously raised the ContextMenu with the keyboard,
                // we've left h/v offsets non-zero, and they need to be cleared now
                // for mouse placement to work.
                contextMenu.HorizontalOffset = 0;
                contextMenu.VerticalOffset = 0;
 
                // Since ContextMenuService doesn't open the menu, it won't fire a ContextMenuClosing event.
                // We need to listen to the Closed event of the ContextMenu itself so we can clear the
                // IsContextMenuOpen flag.  We also do this for the default menu later in this method.
                contextMenu.Closed += new RoutedEventHandler(OnContextMenuClosed);
                return;
            }
 
            // Complete the composition before creating the editor context menu.
            This.CompleteComposition();
 
            if (contextMenu == null)
            {
                // It's a default null, so spin up a temporary ContextMenu now.
                contextMenu = new EditorContextMenu();
                ((EditorContextMenu)contextMenu).AddMenuItems(This, e.UserInitiated);
            }
            contextMenu.Placement = PlacementMode.RelativePoint;
            contextMenu.PlacementTarget = This.UiScope;
 
            ITextPointer position = null;
            LogicalDirection direction;
 
            // Position the ContextMenu.
 
            SpellingError spellingError = (contextMenu is EditorContextMenu) ? This.GetSpellingErrorAtSelection() : null;
 
            if (spellingError != null)
            {
                // If we have a matching speller error at the selection
                // start, position relative to the end of the error.
                position = spellingError.End;
                direction = LogicalDirection.Backward;
            }
            else if (e.CursorLeft == KeyboardInvokedSentinel)
            {
                // A negative offset for e.CursorLeft means the user invoked
                // the menu with a hotkey (shift-F10).  Place the menu
                // relative to Selection.Start.
                position = This.Selection.Start;
                direction = LogicalDirection.Forward;
            }
            else
            {
                direction = LogicalDirection.Forward;
            }
 
            // Calculate coordinats for the ContextMenu.
            // They must be set relative to UIScope - as EditorContextMenu constructor assumes.
            if (position != null && position.CreatePointer(direction).HasValidLayout)
            {
                double horizontalOffset;
                double verticalOffset;
 
                GetClippedPositionOffsets(This, position, direction, out horizontalOffset, out verticalOffset);
 
                contextMenu.HorizontalOffset = horizontalOffset;
                contextMenu.VerticalOffset = verticalOffset;
            }
            else
            {
                Point uiScopeMouseDownPoint = Mouse.GetPosition(This.UiScope);
 
                contextMenu.HorizontalOffset = uiScopeMouseDownPoint.X;
                contextMenu.VerticalOffset = uiScopeMouseDownPoint.Y;
            }
 
            // Since ContextMenuService doesn't open the menu, it won't fire a ContextMenuClosing event.
            // We need to listen to the Closed event of the ContextMenu itself so we can clear the
            // IsContextMenuOpen flag.
            contextMenu.Closed += new RoutedEventHandler(OnContextMenuClosed);
 
            // This line raises a public event.
            contextMenu.IsOpen = true;
 
            e.Handled = true;
        }
 
        #endregion Class Internal Methods
 
        //------------------------------------------------------
        //
        //  Private Methods
        //
        //------------------------------------------------------
 
        #region Private Methods
 
        // We listen to this event to reset TextEditor._isContextMenuOpen flag.
        private static void OnContextMenuClosed(object sender, RoutedEventArgs e)
        {
            UIElement placementTarget = ((ContextMenu)sender).PlacementTarget;
 
            if (placementTarget != null)
            {
                TextEditor This = TextEditor._GetTextEditor(placementTarget);
 
                if (This != null)
                {
                    This.IsContextMenuOpen = false;
                    This.Selection.UpdateCaretAndHighlight();
                    ((ContextMenu)sender).Closed -= new RoutedEventHandler(OnContextMenuClosed);
                }
            }
        }
 
        /// <summary>
        /// Calculates x, y offsets for a ContextMenu based on an ITextPointer and
        /// the viewports of its containers.
        /// </summary>
        /// <SecurityNote>
        ///     SecurityCritical: This code asserts to get the containing HWND.
        ///     TreatAsSafe: The HWND is not exposed, only its RECT.
        /// </SecurityNote>
        [SecurityCritical, SecurityTreatAsSafe]
        private static void GetClippedPositionOffsets(TextEditor This, ITextPointer position, LogicalDirection direction,
            out double horizontalOffset, out double verticalOffset)
        {
            // GetCharacterRect will return the position that base on UiScope.
            Rect positionRect = position.GetCharacterRect(direction);
 
            // Get the base offsets for our ContextMenu.
            horizontalOffset = positionRect.X;
            verticalOffset = positionRect.Y + positionRect.Height;
 
            // Clip to the child render scope.
            FrameworkElement element = This.TextView.RenderScope as FrameworkElement;
            if (element != null)
            {
                GeneralTransform transform = element.TransformToAncestor(This.UiScope);
                if (transform != null)
                {
                    ClipToElement(element, transform, ref horizontalOffset, ref verticalOffset);
                }
            }
 
            // Clip to parent visuals.
            // This is unintuitive -- you might expect parents to have increasingly
            // larger viewports.  But any parent that behaves like a ScrollViewer
            // will have a smaller view port that we need to clip against.
            for (Visual visual = This.UiScope; visual != null; visual = VisualTreeHelper.GetParent(visual) as Visual)
            {
                element = visual as FrameworkElement;
                if (element != null)
                {
                    GeneralTransform transform = visual.TransformToDescendant(This.UiScope);
                    if (transform != null)
                    {
                        ClipToElement(element, transform, ref horizontalOffset, ref verticalOffset);
                    }
                }
            }
 
            // Clip to the window client rect.
            PresentationSource source = PresentationSource.CriticalFromVisual(This.UiScope);
            IWin32Window window = source as IWin32Window;
            if (window != null)
            {
                IntPtr hwnd = IntPtr.Zero;
                new UIPermission(UIPermissionWindow.AllWindows).Assert(); // BlessedAssert
                try
                {
                    hwnd = window.Handle;
                }
                finally
                {
                    CodeAccessPermission.RevertAssert();
                }
 
                NativeMethods.RECT rc = new NativeMethods.RECT(0, 0, 0, 0);
                SafeNativeMethods.GetClientRect(new HandleRef(null, hwnd), ref rc);
 
                // Convert to mil measure units.
                Point minPoint = new Point(rc.left, rc.top);
                Point maxPoint = new Point(rc.right, rc.bottom);
 
                CompositionTarget compositionTarget = source.CompositionTarget;
                minPoint = compositionTarget.TransformFromDevice.Transform(minPoint);
                maxPoint = compositionTarget.TransformFromDevice.Transform(maxPoint);
 
                // Convert to local coordinates.
                GeneralTransform transform = compositionTarget.RootVisual.TransformToDescendant(This.UiScope);
                if (transform != null)
                {
                    transform.TryTransform(minPoint, out minPoint);
                    transform.TryTransform(maxPoint, out maxPoint);
 
                    // Finally, do the clip.
                    horizontalOffset = ClipToBounds(minPoint.X, horizontalOffset, maxPoint.X);
                    verticalOffset = ClipToBounds(minPoint.Y, verticalOffset, maxPoint.Y);
                }
 
                // ContextMenu code takes care of clipping to desktop.
            }
        }
 
        // Clips a Point to the ActualWidth/Height of a containing FrameworkElement.
        private static void ClipToElement(FrameworkElement element, GeneralTransform transform,
            ref double horizontalOffset, ref double verticalOffset)
        {
            Point minPoint;
            Point maxPoint;
 
            Geometry clip = VisualTreeHelper.GetClip(element);
 
            if (clip != null)
            {
                Rect bounds = clip.Bounds;
                minPoint = new Point(bounds.X, bounds.Y);
                maxPoint = new Point(bounds.X + bounds.Width, bounds.Y + bounds.Height);
            }
            else
            {
                if (element.ActualWidth == 0 && element.ActualHeight == 0)
                {
                    // Some elements, noteably Canvas, have a (0, 0) desired size
                    // and should be ignored.
                    return;
                }
 
                minPoint = new Point(0, 0);
                maxPoint = new Point(element.ActualWidth, element.ActualHeight);
            }
 
            transform.TryTransform(minPoint, out minPoint);
            transform.TryTransform(maxPoint, out maxPoint);
 
            // NB: ClipToBounds will handle the case where transform flips a coordinate
            // axis.  In that case, minPoint.X will be > maxPoint.X.
            horizontalOffset = ClipToBounds(minPoint.X, horizontalOffset, maxPoint.X);
            verticalOffset = ClipToBounds(minPoint.Y, verticalOffset, maxPoint.Y);
        }
 
        // Clips value to the range min to (max - 1).
        private static double ClipToBounds(double min, double value, double max)
        {
            // If we're clipping against something with an inverted coordinate axis
            // (the common case is an RTL control in an LTR environment), then
            // "min" in the parent space is a max for the child.
            if (min > max)
            {
                double temp = min;
                min = max;
                max = temp;
            }
 
            if (value < min)
            {
                value = min;
            }
            else if (value >= max)
            {
                value = max - 1;
            }
 
            return value;
        }
 
        // Returns a position ajacent to the supplied position, skipping any
        // intermediate Inlines.
        // This is useful for sliding inside the context of adjacent Hyperlinks,
        // Spans, etc.
        private static ITextPointer GetContentPosition(ITextPointer position)
        {
            while (position.GetAdjacentElement(LogicalDirection.Forward) is Inline)
            {
                position = position.GetNextContextPosition(LogicalDirection.Forward);
            }
 
            return position;
        }
 
        #endregion Private methods
 
        //------------------------------------------------------
        //
        //  Private Types
        //
        //------------------------------------------------------
 
        #region Private Types
 
        // Default ContextMenu for TextBox and RichTextBox.
        private class EditorContextMenu : ContextMenu
        {
            // Initialize the context menu.
            // Creates a new instance.
            /// <SecurityNote>
            /// Critical - accepts a parameter which may be used to set the userInitiated
            ///             bit on a command, which is used for security purposes later.
            ///             Although there is a demand here to prevent non userinitiated
            ///             code paths to be blocked this function is not TreatAsSafe because
            ///             we want to track any new callers to this call
            /// </SecurityNote>
            [SecurityCritical]
            internal void AddMenuItems(TextEditor textEditor, bool userInitiated)
            {
 
                // create a special menu item for paste which only works for user initiated paste
                // within the confines of partial trust this cannot be done programmatically
                if (userInitiated == false)
                {
                    SecurityHelper.DemandAllClipboardPermission();
                }
 
                if (!textEditor.IsReadOnly)
                {
                    if (AddReconversionItems(textEditor))
                    {
                        AddSeparator();
                    }
                }
 
                if (AddSpellerItems(textEditor))
                {
                    AddSeparator();
                }
                AddClipboardItems(textEditor, userInitiated);
            }
            // Finalizer release the candidate list if it remains.
            ~EditorContextMenu()
            {
                ReleaseCandidateList(null);
            }
 
            // Called when the ContextMenu is shutting down.
            protected override void OnClosed(RoutedEventArgs e)
            {
                base.OnClosed(e);
 
                // OnClick for the menu item might be called after the context menu is closed. It depends
                // on how this context menu is created.
                // We will release CandidateList after all the current events are handled.
                DelayReleaseCandidateList();
            }
 
            // Helper which appends a separator item.
            private void AddSeparator()
            {
                this.Items.Add(new Separator());
            }
 
            // Appends spell check related items.
            // Returns false if no items are added.
            private bool AddSpellerItems(TextEditor textEditor)
            {
                SpellingError spellingError;
                MenuItem menuItem;
 
                spellingError = textEditor.GetSpellingErrorAtSelection();
                if (spellingError == null)
                    return false;
 
                bool addedSuggestion = false;
 
                foreach (string suggestion in spellingError.Suggestions)
                {
                    menuItem = new EditorMenuItem();
                    TextBlock text = new TextBlock();
                    text.FontWeight = FontWeights.Bold;
                    text.Text = suggestion;
                    menuItem.Header = text;
                    menuItem.Command = EditingCommands.CorrectSpellingError;
                    menuItem.CommandParameter = suggestion;
                    this.Items.Add(menuItem);
                    menuItem.CommandTarget = textEditor.UiScope;
 
                    addedSuggestion = true;
                }
 
                if (!addedSuggestion)
                {
                    menuItem = new EditorMenuItem();
                    menuItem.Header = SR.Get(SRID.TextBox_ContextMenu_NoSpellingSuggestions);
                    menuItem.IsEnabled = false;
                    this.Items.Add(menuItem);
                }
 
                AddSeparator();
 
                menuItem = new EditorMenuItem();
                menuItem.Header = SR.Get(SRID.TextBox_ContextMenu_IgnoreAll);
                menuItem.Command = EditingCommands.IgnoreSpellingError;
                this.Items.Add(menuItem);
                menuItem.CommandTarget = textEditor.UiScope;
 
                return true;
            }
 
            // Add the description to the candidate string of Cicero's
            // reconversion if necessary.
            private string GetMenuItemDescription(string suggestion)
            {
                if (suggestion.Length == 1)
                {
                    if (suggestion[0] == 0x0020)
                    {
                        return SR.Get(SRID.TextBox_ContextMenu_Description_SBCSSpace);
                    }
                    else if (suggestion[0] == 0x3000)
                    {
                        return SR.Get(SRID.TextBox_ContextMenu_Description_DBCSSpace);
                    }
 
                }
                return null;
            }
 
            // Appends Cicero reconversion related items.
            // Returns false if no items are added.
            /// <SecurityNote>
            /// Critical - calls unmanaged code.
            /// TreatAsSafe - does not expose the unmanaged interface. retrieve the candidate list and add menu item.
            /// </SecurityNote>
            [SecurityCritical, SecurityTreatAsSafe]
            private bool AddReconversionItems(TextEditor textEditor)
            {
                MenuItem menuItem;
                TextStore textStore = textEditor.TextStore;
 
                if (textStore == null)
                {
                    GC.SuppressFinalize(this);
                    return false;
                }
 
                ReleaseCandidateList(null);
                _candidateList = new  SecurityCriticalDataClass<UnsafeNativeMethods.ITfCandidateList>(textStore.GetReconversionCandidateList());
                if (CandidateList == null)
                {
                    GC.SuppressFinalize(this);
                    return false;
                }
 
                int count = 0;
                CandidateList.GetCandidateNum(out count);
 
                if (count > 0)
                {
                    // Like Winword, we show the first 5 candidates in the context menu.
                    int i;
                    for (i = 0; i < 5 && i < count; i++)
                    {
                        string suggestion;
                        UnsafeNativeMethods.ITfCandidateString candString;
 
                        CandidateList.GetCandidate(i, out candString);
                        candString.GetString(out suggestion);
 
                        menuItem = new ReconversionMenuItem(this, i);
                        menuItem.Header = suggestion;
                        menuItem.InputGestureText = GetMenuItemDescription(suggestion);
                        this.Items.Add(menuItem);
 
                        Marshal.ReleaseComObject(candString);
                    }
                }
 
                // Like Winword, we show "More" menu to open TIP's candidate list if there are more
                // than 5 candidates.
                if (count > 5)
                {
                    menuItem = new EditorMenuItem();
                    menuItem.Header = SR.Get(SRID.TextBox_ContextMenu_More);
                    menuItem.Command = ApplicationCommands.CorrectionList;
                    this.Items.Add(menuItem);
                    menuItem.CommandTarget = textEditor.UiScope;
                }
 
                return (count > 0) ? true : false;
            }
 
            // Appends clipboard related items.
            // Returns false if no items are added.
            /// <SecurityNote>
            /// Critical - accepts a parameter which may be used to set the userInitiated
            ///             bit on a command
            ///             Although there is a demand here to prevent non userinitiated
            ///             code paths to be blocked this function is not TreatAsSafe because
            ///             we want to track any new callers to this call
            /// </SecurityNote>
            [SecurityCritical]
            private bool AddClipboardItems(TextEditor textEditor, bool userInitiated)
            {
                MenuItem menuItem;
 
                menuItem = new EditorMenuItem();
                menuItem.Header = SR.Get(SRID.TextBox_ContextMenu_Cut);
                menuItem.CommandTarget = textEditor.UiScope;
                menuItem.Command = ApplicationCommands.Cut;
                this.Items.Add(menuItem);
 
                menuItem = new EditorMenuItem();
                menuItem.Header = SR.Get(SRID.TextBox_ContextMenu_Copy);
                menuItem.CommandTarget = textEditor.UiScope;
                menuItem.Command = ApplicationCommands.Copy;
                this.Items.Add(menuItem);
 
                // create a special menu item for paste which only works for user initiated paste
                // within the confines of partial trust this cannot be done programmatically
                if (userInitiated == false)
                {
                    SecurityHelper.DemandAllClipboardPermission();
                }
                menuItem = new EditorMenuItem();
                menuItem.Header = SR.Get(SRID.TextBox_ContextMenu_Paste);
                menuItem.CommandTarget = textEditor.UiScope;
                menuItem.Command = ApplicationCommands.Paste;
                this.Items.Add(menuItem);
 
                return true;
            }
 
            /// <SecurityNote>
            /// Critical - access CandidateList
            /// TreatAsSafe - does not do anything for the unmanaged interface. It's just a null check.
            /// </SecurityNote>
            [SecurityCritical, SecurityTreatAsSafe]
            private void DelayReleaseCandidateList()
            {
                if (CandidateList != null)
                {
                    Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(ReleaseCandidateList), null);
                }
            }
 
 
            /// <SecurityNote>
            /// Critical - calls unmanaged code.
            /// TreatAsSafe - just release it.
            /// </SecurityNote>
            [SecurityCritical, SecurityTreatAsSafe]
            private object ReleaseCandidateList(object o)
            {
                if (CandidateList != null)
                {
                    Marshal.ReleaseComObject(CandidateList);
                    _candidateList = null;
 
                    // We released CandidateList and Finalizer does not need to be called.
                    GC.SuppressFinalize(this);
                }
                return null;
            }
 
            // ReconversionMenuItem uses this to finalzie the candidate string.
 
            /// <SecurityNote>
            /// Critical - calls unmanaged code and return critical ITfCandidateList
            /// </SecurityNote>
            internal UnsafeNativeMethods.ITfCandidateList CandidateList
            {
                 [SecurityCritical]
                 get
                 {
                     if ( _candidateList == null)
                     {
                         return null;
                     }
 
                     return _candidateList.Value;
                 }
            }
 
            // The candidate list for Cicero Reconversion.
            // We need to use same ITfCandidateList object for both listing up and finalizing because
            // the index of the candidate string needs to match.
            /// <SecurityNote>
            ///  Critical : Field for critical type ITfCandidateList
            /// </SecurityNote>
            [SecurityCritical]
            private SecurityCriticalDataClass<UnsafeNativeMethods.ITfCandidateList> _candidateList;
        }
 
        // Default EditorContextMenu item base class.
        // Used to distinguish our items from anything an application
        // may have added.
        private class EditorMenuItem : MenuItem
        {
            internal EditorMenuItem() : base() {}
 
            /// <SecurityNote>
            /// Critical - accepts a parameter which may be used to set the userInitiated
            ///             bit on a command, which is used for security purposes later.
            /// </SecurityNote>
            [SecurityCritical]
            internal override void OnClickCore(bool userInitiated)
            {
                OnClickImpl(userInitiated);
            }
 
        }
 
        // Reconversion menu item
        // We finalize the candidate in the context menu if one of reconversion menu item is selected.
        private class ReconversionMenuItem : EditorMenuItem
        {
            internal ReconversionMenuItem(EditorContextMenu menu, int index) : base()
            {
                _menu = menu;
                _index = index;
            }
 
            // OnClick handler.
            // This is called when the item is selected.
            /// <SecurityNote>
            /// Critical - calls unmanaged code.
            /// </SecurityNote>
            [SecurityCritical]
            internal override void OnClickCore(bool userInitiated)
            {
                Invariant.Assert(_menu.CandidateList != null);
 
                try
                {
                    _menu.CandidateList.SetResult(_index, UnsafeNativeMethods.TfCandidateResult.CAND_FINALIZED);
                }
                catch (COMException)
                {
                    // When TextBox.MaxLength is smaller than the candidate item,
                    // TextStore.SetText will reject the insert with E_FAIL and
                    // we end up here.  In this case, we want to silently eat the exception
                    // since it derives from user action and our code.
                    // Bug 107395 is tracking a fundamental fix to the problem, rather
                    // than this workaround.
                }
 
                // always passes in false for userInitiated. This won't call command manager.
                base.OnClickCore(false);
            }
 
            // The index for this candidate string.
            private int _index;
 
            // The context menu of this item.
            private EditorContextMenu _menu;
        }
 
        #endregion Private Types
    }
}