DocumentGridContextMenu.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / MS / Internal / documents / DocumentGridContextMenu.cs / 1305600 / DocumentGridContextMenu.cs
                        
                        
                            //---------------------------------------------------------------------------- 
//
// File: DocumentGridContextMenu.cs
//
// Copyright (C) Microsoft Corporation.  All rights reserved. 
//
// Description: Context menu for DocumentGrid 
// 
//---------------------------------------------------------------------------
 
namespace MS.Internal.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 MS.Internal.Documents;
    using System.Security.Permissions; 
    using MS.Win32;
    using System.Windows.Interop; 
 
    // A Component of DocumentViewer supporting the default ContextMenu.
    internal static class DocumentGridContextMenu 
    {
        //-----------------------------------------------------
        //
        //  Class Internal Methods 
        //
        //----------------------------------------------------- 
 
        #region Class Internal Methods
 
        // Registers the event handler for DocumentGrid.
        /// 
        ///     Critical: This code hooks up a call back to context menu opening event which has the ability to spoof copy
        ///     TreatAsSafe: This code does not expose the callback and does not drive any input into it 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        internal static void RegisterClassHandler() 
        {
            EventManager.RegisterClassHandler(typeof(DocumentGrid), FrameworkElement.ContextMenuOpeningEvent, new ContextMenuEventHandler(OnContextMenuOpening)); 
            EventManager.RegisterClassHandler(typeof(DocumentApplicationDocumentViewer), FrameworkElement.ContextMenuOpeningEvent, new ContextMenuEventHandler(OnDocumentViewerContextMenuOpening));
        }

        #endregion Class Internal Methods 

        //------------------------------------------------------ 
        // 
        //  Private Methods
        // 
        //-----------------------------------------------------

        #region Private Methods
 
        /// 
        /// Callback for FrameworkElement.ContextMenuOpeningEvent, when fired from DocumentViewer.  This is 
        /// here to catch the event when it is fired by the keyboard rather than the mouse. 
        /// 
        ///  
        /// Critical - forwards user-initiated information to OnContextMenuOpening, which is also SecurityCritical
        /// 
        [SecurityCritical]
        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);
                }
            } 
        }
 
        // Callback for FrameworkElement.ContextMenuOpeningEvent. 
        // If the control is using the default ContextMenu, we initialize it
        // here. 
        /// 
        /// Critical - accepts a parameter which may be used to set the userInitiated
        ///             bit on a command, which is used for security purposes later.
        ///  
        [SecurityCritical]
        private static void OnContextMenuOpening(object sender, ContextMenuEventArgs e) 
        { 
            DocumentGrid documentGrid = sender as DocumentGrid;
            ContextMenu contextMenu; 

            if (documentGrid == null)
            {
                return; 
            }
 
            // We only want to programmatically generate the menu for Mongoose 
            if (!(documentGrid.DocumentViewerOwner is DocumentApplicationDocumentViewer))
                return; 

            // If the DocumentViewer or ScrollViewer has a ContextMenu set, the DocumentGrid menu should be ignored
            if (documentGrid.DocumentViewerOwner.ContextMenu != null || documentGrid.DocumentViewerOwner.ScrollViewer.ContextMenu != null)
                return; 

            // Start by grabbing whatever's set to the UiScope's ContextMenu property. 
            contextMenu = documentGrid.ContextMenu; 

            // If someone explicitly set it null -- don't mess with it. 
            if (documentGrid.ReadLocalValue(FrameworkElement.ContextMenuProperty) == null)
                return;

            // If it's not null, someone's overriding our default -- don't mess with it. 
            if (contextMenu != null)
                return; 
 
            // It's a default null, so spin up a temporary ContextMenu now.
            contextMenu = new ViewerContextMenu(); 
            contextMenu.Placement = PlacementMode.RelativePoint;
            contextMenu.PlacementTarget = documentGrid;
            ((ViewerContextMenu)contextMenu).AddMenuItems(documentGrid, e.UserInitiated);
 
            Point uiScopeMouseDownPoint;
            if (e.CursorLeft == KeyboardInvokedSentinel) 
            { 
                uiScopeMouseDownPoint = new Point(.5 * documentGrid.ViewportWidth, .5 * documentGrid.ViewportHeight);
            } 
            else
            {
                uiScopeMouseDownPoint = Mouse.GetPosition(documentGrid);
            } 

            contextMenu.HorizontalOffset = uiScopeMouseDownPoint.X; 
            contextMenu.VerticalOffset = uiScopeMouseDownPoint.Y; 

            // This line raises a public event. 
            contextMenu.IsOpen = true;

            e.Handled = true;
        } 

        #endregion Private methods 
 
        //------------------------------------------------------
        // 
        //  Private Constants
        //
        //------------------------------------------------------
        #region Private Constants 

        private const double KeyboardInvokedSentinel = -1.0; // e.CursorLeft has this value when the menu is invoked with the keyboard. 
        #endregion 
        //-----------------------------------------------------
        // 
        //  Private Types
        //
        //------------------------------------------------------
 
        #region Private Types
 
        // Default ContextMenu for TextBox and RichTextBox. 
        private class ViewerContextMenu : ContextMenu
        { 
            // Initialize the context menu.
            // Creates a new instance.
            /// 
            /// 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
            ///  
            [SecurityCritical]
            internal void AddMenuItems(DocumentGrid dg, bool userInitiated)
            {
                // create a special menu item for paste which only works for user initiated copy 
                // within the confines of partial trust this cannot be done programmatically
                if (userInitiated == false) 
                { 
                    SecurityHelper.DemandAllClipboardPermission();
                } 

                this.Name = "ViewerContextMenu";

                SetMenuProperties(new EditorMenuItem(), dg, ApplicationCommands.Copy); // Copy will be marked as user initiated 

                // build menu for XPSViewer 
                SetMenuProperties(new MenuItem(), dg, ApplicationCommands.SelectAll); 

                AddSeparator(); 

                SetMenuProperties(
                    new MenuItem(),
                    dg, 
                    NavigationCommands.PreviousPage,
                    SR.Get(SRID.DocumentApplicationContextMenuPreviousPageHeader), 
                    SR.Get(SRID.DocumentApplicationContextMenuPreviousPageInputGesture)); 

                SetMenuProperties( 
                    new MenuItem(),
                    dg,
                    NavigationCommands.NextPage,
                    SR.Get(SRID.DocumentApplicationContextMenuNextPageHeader), 
                    SR.Get(SRID.DocumentApplicationContextMenuNextPageInputGesture));
 
                SetMenuProperties( 
                    new MenuItem(),
                    dg, 
                    NavigationCommands.FirstPage,
                    null, //menu header
                    SR.Get(SRID.DocumentApplicationContextMenuFirstPageInputGesture));
 
                SetMenuProperties(
                    new MenuItem(), 
                    dg, 
                    NavigationCommands.LastPage,
                    null, //menu header 
                    SR.Get(SRID.DocumentApplicationContextMenuLastPageInputGesture));

                AddSeparator();
 
                SetMenuProperties(new MenuItem(), dg, ApplicationCommands.Print);
            } 
 
            private void AddSeparator()
            { 
                this.Items.Add(new Separator());
            }

            //Helper to set properties on the menu items based on the command 
            private void SetMenuProperties(MenuItem menuItem, DocumentGrid dg, RoutedUICommand command)
            { 
                SetMenuProperties(menuItem, dg, command, null, null); 
            }
 
            private void SetMenuProperties(MenuItem menuItem, DocumentGrid dg, RoutedUICommand command, string header, string inputGestureText)
            {
                menuItem.Command = command;
                menuItem.CommandTarget = dg.DocumentViewerOwner; // the text editor expects the commands to come from the DocumentViewer 
                if (header == null)
                { 
                    menuItem.Header = command.Text; // use default menu text for this command 
                }
                else 
                {
                    menuItem.Header = header;
                }
 
                if (inputGestureText != null)
                { 
                    menuItem.InputGestureText = inputGestureText; 
                }
 
                menuItem.Name = "ViewerContextMenu_" + command.Name; // does not require localization
                this.Items.Add(menuItem);
            }
        } 

        // Default EditorContextMenu item base class. 
        // Used to distinguish our items from anything an application 
        // may have added.
        private class EditorMenuItem : MenuItem 
        {
            internal EditorMenuItem() : base() {}

            ///  
            /// Critical - accepts a parameter which may be used to set the userInitiated
            ///             bit on a command, which is used for security purposes later. 
            ///  
            [SecurityCritical]
            internal override void OnClickCore(bool userInitiated) 
            {
                OnClickImpl(userInitiated);
            }
 
        }
 
        #endregion Private Types 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
DocumentGridContextMenu.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
