/Visual Studio 2008/CSVSPackageWPFToolWindow/CSVSPackageWPFToolWindowPackage.cs

/***************************************** Module Header *****************************\

* Module Name:  CSVSPackageWPFToolWindowPackage.cs

* Project:      CSVSPackageWPFToolWindow

* Copyright (c) Microsoft Corporation.

* 

* This sample demostrate how to host a WPF control into Visual Studio 

* ToolWindow. 

*

* To use the sample

* 1. Run the sample

* 2. Open tool window by View / Other Windows / WPFToolWindow

* 3. A tool window will be docked at place of solution explorer

* 4. The tool window hosts a WPF control which represents MyDocuments folder

* structure

* 

* This source is subject to the Microsoft Public License.

* See http://www.microsoft.com/opensource/licenses.mspx#Ms-PL.

* All other rights reserved.

* 

* History:

* * 03/16/2010 04:35 PM Hongye Sun Created

\*************************************************************************************/



using System;

using System.Diagnostics;

using System.Globalization;

using System.Runtime.InteropServices;

using System.ComponentModel.Design;

using Microsoft.Win32;

using Microsoft.VisualStudio.Shell.Interop;

using Microsoft.VisualStudio.OLE.Interop;

using Microsoft.VisualStudio.Shell;



namespace Company.VSPackageWPFToolWindow

{

    /// <summary>

    /// This is the class that implements the package exposed by this assembly.

    ///

    /// The minimum requirement for a class to be considered a valid package for Visual Studio

    /// is to implement the IVsPackage interface and register itself with the shell.

    /// This package uses the helper classes defined inside the Managed Package Framework (MPF)

    /// to do it: it derives from the Package class that provides the implementation of the 

    /// IVsPackage interface and uses the registration attributes defined in the framework to 

    /// register itself and its components with the shell.

    /// </summary>

    // This attribute tells the registration utility (regpkg.exe) that this class needs

    // to be registered as package.

    [PackageRegistration(UseManagedResourcesOnly = true)]

    // A Visual Studio component can be registered under different regitry roots; for instance

    // when you debug your package you want to register it in the experimental hive. This

    // attribute specifies the registry root to use if no one is provided to regpkg.exe with

    // the /root switch.

    [DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\9.0")]

    // This attribute is used to register the informations needed to show the this package

    // in the Help/About dialog of Visual Studio.

    [InstalledProductRegistration(false, "#110", "#112", "1.0", IconResourceID = 400)]

    // In order be loaded inside Visual Studio in a machine that has not the VS SDK installed, 

    // package needs to have a valid load key (it can be requested at 

    // http://msdn.microsoft.com/vstudio/extend/). This attributes tells the shell that this 

    // package has a load key embedded in its resources.

    [ProvideLoadKey("Standard", "1.0", "Package Name", "Company", 1)]

    // This attribute is needed to let the shell know that this package exposes some menus.

    [ProvideMenuResource(1000, 1)]

    // This attribute registers a tool window exposed by this package.

    [ProvideToolWindow(typeof(MyToolWindow), Style = VsDockStyle.Tabbed, Window = "3ae79031-e1bc-11d0-8f78-00a0c9110057")]

    [Guid(GuidList.guidVSPackageWPFToolWindowPkgString)]

    public sealed class CSVSPackageWPFToolWindowPackage : Package

    {

        /// <summary>

        /// Default constructor of the package.

        /// Inside this method you can place any initialization code that does not require 

        /// any Visual Studio service because at this point the package object is created but 

        /// not sited yet inside Visual Studio environment. The place to do all the other 

        /// initialization is the Initialize method.

        /// </summary>

        public CSVSPackageWPFToolWindowPackage()

        {

            Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", this.ToString()));

        }



        /// <summary>

        /// This function is called when the user clicks the menu item that shows the 

        /// tool window. See the Initialize method to see how the menu item is associated to 

        /// this function using the OleMenuCommandService service and the MenuCommand class.

        /// </summary>

        private void ShowToolWindow(object sender, EventArgs e)

        {

            // Get the instance number 0 of this tool window. This window is single instance so this instance

            // is actually the only one.

            // The last flag is set to true so that if the tool window does not exists it will be created.

            ToolWindowPane window = this.FindToolWindow(typeof(MyToolWindow), 0, true);

            if ((null == window) || (null == window.Frame))

            {

                throw new NotSupportedException(Resources.CanNotCreateWindow);

            }

            IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;

            Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());

        }





        /////////////////////////////////////////////////////////////////////////////

        // Overriden Package Implementation

        #region Package Members



        /// <summary>

        /// Initialization of the package; this method is called right after the package is sited, so this is the place

        /// where you can put all the initilaization code that rely on services provided by VisualStudio.

        /// </summary>

        protected override void Initialize()

        {

            Trace.WriteLine (string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", this.ToString()));

            base.Initialize();



            // Add our command handlers for menu (commands must exist in the .vsct file)

            OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;

            if ( null != mcs )

            {

                // Create the command for the tool window

                CommandID toolwndCommandID = new CommandID(GuidList.guidVSPackageWPFToolWindowCmdSet, (int)PkgCmdIDList.cmdidWPFToolWindow);

                MenuCommand menuToolWin = new MenuCommand(ShowToolWindow, toolwndCommandID);

                mcs.AddCommand( menuToolWin );

            }

        }

        #endregion



    }

}