Office Development with Visual Studio : Office Development

Migrating an Outlook Solution to .NET Framework 4 in Visual Studio 2010 (Norm Estabrook)

VSTO Team — Wed, 16 Dec 2009 22:33:37 GMT

Visual Studio can help migrate your Outlook solutions from .NET Framework 3.5 to the .NET Framework 4. However, you still have to do a few things manually to make it all work.

Beth Massi converts an Outlook Solution that targets the .NET Framework 3.5 to an Outlook Solution that targets the .NET Framework 4 client profile in this very cool and informative blog entry - Migrating an Outlook Client to .NET Framework 4 in Visual Studio 2010.

Making a Custom Group Appear in the Message Tab of a Mail Item (Norm Estabrook)

VSTO Team — Tue, 15 Dec 2009 22:14:38 GMT

You can add a custom group to the Message tab of an Outlook mail item. For example, here is a custom group named "MyCoolGroup" that I added to the message tab of a new message:

Outlook lets you open a message in the following two modes:

Compose (you are drafting a new message).
Read (you are reading a message).

Making a custom group appear for only one of these modes is pretty easy. Making it appear for both modes is a tad more challenging. That is because the control ID of the Message tab in read mode is different than the control ID of the Message tab in compose mode. When you design your custom group in the VSTO Ribbon designer, you can only specify one control ID. This means that when you run the project, the custom group will only appear in the Message tab of a compose window or the Message tab of a read window depending on which control ID you specify at design-time.

If you want the group to appear in both versions of the Message tab (read and compose), you have to do a bit more work. Here is how you make the group appear for both modes:

First, add a Ribbon (Visual Designer) to an Outlook 2007 add-in project.

Then, set the RibbonType property of the Ribbon to Microsoft.Outlook.Mail.Read as follows:

On the Ribbon designer, add a group to a tab and customize the group as desired.

On the Ribbon designer, select the tab, open the Properties window, and then set the OfficeId of the tab to TabReadMessage. TabReadMessage is the control ID of the default tab that appears on the Ribbon of a mail message that is open in read mode.

Ok. Now when you run the project, your custom group will appear only if you open a mail item in read mode. Now you need to add second Ribbon to your project to display this custom group in a mail item that is open in compose mode.

Add a second Ribbon (Visual Designer) to the project. Then, set the RibbonType property of the Ribbon to Microsoft.Outlook.Mail.Compose as follows:

On the Ribbon designer, select the tab of the second Ribbon, open the Properties window, and then set the OfficeId of the tab to TabNewMailMessage. TabNewMailMessage is the control ID of the default tab that appears on the Ribbon of a mail message that is open in compose mode.

I know what your thinking. Do you mean I have to create two separate custom groups? That defeats the whole point of trying to do this right? Yes that would. Fortunately, you don’t have to create two custom groups. You only have to create two Ribbons as I have shown here. You can use the same custom group in both Ribbons. Here is how:

Open the first Ribbon that you created in the Ribbon Designer. In the Ribbon Designer, select your custom group. In the Properties window, set the Modifiers property of the group to Public.

Open the code file of the second Ribbon that you created (called Ribbon2 in my project).

In the constructor of the second Ribbon, add the custom group from Ribbon1 to Ribbon2 as follows:

public Ribbon2()
{
    InitializeComponent();
    Ribbon1 firstRibbon = new Ribbon1();
    this.tab1.Groups.Add(firstRibbon.group1);
}

You can read more about adding custom groups to built-in tabs in the following MSDN articles:

How to: Customize a Built-in tab

How to: Get Started Customizing the Ribbon

Ribbon Designer

Customizing a Ribbon for Outlook

Using Office 2010 Extensibility Schemas with VSTO addins for Beta 2 (Stephen Peters)

VSTO Team — Fri, 04 Dec 2009 22:06:00 GMT

Office 2010 brings in many new features to the Ribbon and Backstage extensibility. In order to take advantage of those changes in VSTO addins, you will need to update your ribbon XML projects to use the new Office 2010 schema.

First, you will need to see if the schema is installed. To do this, look in “C:\Program Files\Microsoft Visual Studio 10.0\Xml\Schemas\1033” (you might need to modify this to point to your Visual Studio installation directory). If customui14.xsd is there, you can skip ahead to the next paragraph. Otherwise download the schema from here, and install it in the directory above. When you are done, double check to make sure that the custom14ui.xsd file is there.

Go to the Ribbon XML item that you want to use on Office 2010. For this blog post I am going to use a Word 2010 addin with a single Ribbon XML item, but the same code can work with any VSTO project with only minor modifications.

At the top Ribbon1.xml, there is a line

  <customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui" onLoad="Ribbon_Load">

You will want to replace the URL with

  http://schemas.microsoft.com/office/2009/07/customui

If you look in the properties window for the XML document, the schema for the document should now point to the customui14.xsd that was installed. Now we can play around with it a bit. Under </ribbon> in Ribbon1.xml, add the following code:

  <backstage>
    <tab id="VSTOTab" label="VSTO Tab" insertAfterMso="TabInfo">
      <firstColumn>
        <group id="VSTOGroup" label="Hello From VSTO!">
          <topItems>
            <button id="AddMoreCowbell"
              label="Add More Cowbell"
              onAction="AddMoreCowbell" />
          </topItems>
        </group>
      </firstColumn>
    </tab>
  </backstage>

We will also need to add the callback to Ribbon1.cs:

public void AddMoreCowbell(Office.IRibbonControl control)
{
    System.Windows.Forms.MessageBox.Show("Fever Cured");
}

And, of course, the integration in ThisAddin.cs

protected override Microsoft.Office.Core.IRibbonExtensibility CreateRibbonExtensibilityObject()
{
    return new Ribbon1();
}

Run your add-in, and when you go to the backstage, you will find the backstage tab that we just added:

Now that you have the schemas set up, you can read up more on extending Backstage and new Ribbon features here:

Microsoft Office 2010 Technical Articles

- Customizing the Office 2010 Backstage View for Developers

- Ribbon Extensibility in Office 2010: Tab Activation and Auto-Scaling

Office 2010 Custom UI Schema (repost from above)

Will your VSTO addin run on Office 2010 64-bit? Yes, probably. (Christin Boyd)

VSTO Team — Thu, 06 Aug 2009 01:05:00 GMT

The Visual Studio team is designing the runtime components for Office 2010 so that your Visual Studio Tools for Office 2005 and Visual Studio 2008 .NET addins, document solutions and spreadsheet solutions will run on 64-bit Office 2010. These runtime components will ship with Office 2010, so your end-users won’t even have to download a new runtime! How easy is that? There are a few rare exceptions that I’ll discuss in this blog entry.

The miracle of managed code allows you to write C# or Visual Basic .NET code that compiles to “Any CPU” using the Compile setting in your Visual Studio project. Your code compiles to MSIL with Visual Studio, and then at runtime it gets JIT compiled to the correct chip set, either AMD, Intel, 32-bit or 64-bit. The first exception to this wondrous technology is the oldest versions of .NET Framework 1.0 and 1.1 will not enable this 64-bit transformation.

The other thing to lookout for is calls to process invoke (p/invoke) in your code. If you try to call native API methods using p/invoke you could have issues with your VSTO solution running properly on 64-bit Office 2010.

You will have problems if your code makes deliberate calls to p/invoke a Win32 API that does not have exactly the same signature (method name, parameter list, and DLL name) of an equivalent Win64 API. This is true for any solution you write regardless of targeting Office as the platform. You can find a ton of information in MSDN and blogs by such luminaries as Scott Hanselman about writing Windows API calls so that they will run on either 32-bit or 64-bit Windows. Here is a generalized code snippet for handling cases where the method name or the DLL name is different:

//YourFunction has the same name, parameters, and DLL name in 32bit and 64bit
YourFunction();

Import("LIBRARY", EntryPoint = "YOURFUNCTION", CharSet = CharSet.Unicode)]
private static extern bool YouFunction();



//In some cases, the method name is different in Win32 API and Win64 API, 
//so use the following code block in stead of the above 3 lines of code.
if (Marshal.SizeOf(typeof(IntPtr)) == 4)
{
    YourFunction32();
}
else if (Marshal.SizeOf(typeof(IntPtr)) == 8)
{
    YourFunction64();
}



Import("LIBRARY32", EntryPoint = "YOURFUNCTION32", CharSet = CharSet.Unicode)]
private static extern bool YourFunction32();

Import("LIBRARY64", EntryPoint = " YOURFUNCTION64", CharSet = CharSet.Unicode)]
private static extern bool YourFunction64();

Resources:

Here are more resources to help you author your solutions today so that they will run without needing a recompile when your users install 64-bit Office 2010.

MSDN Library Visual Studio 2005 article on developing 64-bit Applications

MSDN Library Visual Studio 2008 article on developing 64-bit Applications

How to access the “real” x64 registry from a Win32 .NET Application – Part I

The Myth of .NET Purity, Reloaded

For migrating your really old apps with lots of native calls to .NET, try checking if your native calls have an equivalent .NET call:

Microsoft Win32 to Microsoft .NET Framework API Map

Interoperating with Unmanaged Code

Finally I should mention that this is my last post (for a while at least) on this blog because I am leaving Microsoft. I’m going to work on a charity project teaching robotics programming to high school kids in my “inner city” neighborhood for at least the next 6 months. The project is called Team Xbot! Keep an eye on these kids as they go on to good colleges and great jobs in the next few years!

Sincerely, Christin Boyd, Program Manager

BUG: “Old format or invalid type library” error when automating Excel (Christin Boyd)

VSTO Team — Tue, 07 Jul 2009 01:54:33 GMT

A customer recently reported this bug when running their Shared Addin for Excel on French Windows.

Error: 0x80028018 (-2147647512)
Description: Old Format or Invalid Type Library

His solution worked great on English Windows, but gave errors in any other language. This is a known problem in Excel and there are a few workarounds that work depending on the way you’re writing your Excel Addin. Let me take you through the problem, variations on the problem, and different solutions depending on which Visual Studio project template you choose to start your Addin.

The bug was originally documented in a KB 320369 article, which gives detailed repro steps, explanation, and two workarounds with sample code. So why am I writing a blog post if the KB article covers everything? Three reasons.

Because we’re fixing the problem in CLR 4 and I want to encourage you to use one of the recommended workarounds in your current solutions so that you’re ready when your users upgrade to .NET Framework 4.
Also, there are parts of the KB article that are a bit confusing, so I’ll try to add some color commentary to help explain what’s causing the problem.
And third, these problems do not occur if you use VSTO 2005 SE, VSTO 3.0 (which ships with Visual Studio 2008), or Visual Studio 2010. I’ll explain why and how later.

The KB article describes the problem:

Error: 0x80028018 (-2147647512)
Description: Old Format or Invalid Type Library

You receive this error calling an Excel method when the following conditions are true:

The method requires an LCID (locale identifier).

You run an English version of Excel. However, the regional settings for the computer are configured for a non-English language.

If the client computer runs the English version of Excel and the locale for the current user is configured for a language other than English, Excel will try to locate the language pack for the configured language. If the language pack is not found, the error is reported.

The quote from the KB article is accurate, but can be confusing. It is very difficult to determine if the Excel method you want to call requires LCID or not. The Primary Interop Assembly (PIA) does not indicate whether or not the LCID is needed, however VBA does not hide the need for LCID. Part of the reason why Excel hasn’t changed its methods is to maintain back compatibility with all the VBA code in the universe.

Fixed in VSTO

VSTO implemented a fix in VSTO 2005 Second Edition (SE). You can read more about this fix in Eric Carter’s blog post. The fix is also in all subsequent versions of Visual Studio 2008 and will be in Visual Studio 2010. You know you are using “VSTO” when you create a new Project in Visual Studio and select an Excel <version number> Workbook, Excel <version number> Template or Excel <version number> Addin. The fix was not implemented in the Shared Addin template in any version of Visual Studio. If you create a WinForms, WPF, Web or console application that calls Excel, then you will see this bug on non-English Windows.

Workarounds

If you are using the Shared Addin template, a WinForm, WPF, Web or Console application with any version of Visual Studio, then you should use the KB 320369 article to solve the problem.

The workaround is to write explicit calls to set the thread’s culture before calling into Excel. You can then reset the culture back to what it was before after you are finished calling Excel.

Install the Multilingual User Interface Pack for your version of Office.

Execute the Excel method or property by using InvokeMember so that you can specify the CultureInfo for the call. For example, the following code illustrates how you can invoke the Workbooks object Add method with "en-US" as the CultureInfo:

Dim oApp As New Excel.Application()
oApp.Visible = True
oApp.UserControl = True
Dim oBooks As Object = oApp.Workbooks
Dim ci As System.Globalization.CultureInfo = New System.Globalization.CultureInfo("en-US")
oBooks.GetType().InvokeMember("Add", Reflection.BindingFlags.InvokeMethod, Nothing, oBooks, Nothing, ci)

Or, instead of the above bullet and code sample, set the CultureInfo prior to calling the Excel method, and then you can reset it after your Excel call:

Dim oApp As New Excel.Application()
oApp.Visible = True
oApp.UserControl = True
Dim oldCI As System.Globalization.CultureInfo = _
    System.Threading.Thread.CurrentThread.CurrentCulture
System.Threading.Thread.CurrentThread.CurrentCulture = _
    New System.Globalization.CultureInfo("en-US")
oApp.Workbooks.Add()
System.Threading.Thread.CurrentThread.CurrentCulture = oldCI

The .NET Framework 4 will solve this whole culture problem. Excel is not going to change its culture sensitivity because of the need to support backwards compatibility. Starting with CLR 4.0, when managed code calls into a COM component and an LCID is required, then the CLR will pass LCID = 1033. Note that this is how VBA passes LCIDs. This means that Visual Studio 2010 project templates for Excel Addins can stop wrapping all Excel projects with LCID proxy. In the future, when you use VS 2010 and .NET 4 to write your Excel automation programs from a Shared Addin, console, Winforms, WPF, or Web application, you won’t need to wrap your calls either.

-Christin Boyd, Program Manager & Misha Shneerson, Senior Developer

Community Article: Automate Common Office Tasks (Beth Massi)

VSTO Team — Fri, 26 Jun 2009 02:34:37 GMT

If you haven’t seen it yet, we’ve got a new article from Robert Green (MVP) up on the VSTO Dev Center. In this article, learn how you can use Visual Studio to build application-level add-ins that automate common Microsoft Office tasks. It’s a good introduction to Office development with Visual Studio so check it out!

Create an Application-Level Add-In to Automate Common Office Tasks

Enjoy,
-Beth Massi, Visual Studio Community

Do Your Outlook UI Elements Need Counseling? - Get your Form Regions, Ribbons, and Task Panes Talking to Each Other Again (Norm Estabrook)

VSTO Team — Thu, 04 Jun 2009 01:30:31 GMT

So you want to open a task pane by using a button on the Ribbon. You also want a form region that appears in an e-mail item to detect the state of a control on a custom task pane so that you can add or remove an option that appears in a Ribbon menu right? Ok, I completely made this scenario up. But at some point, somewhere along the way, you might say to yourself – how do I get to that gallery on my Ribbon from my task pane? or how do I enable the user to populate that combo box on the form region by selecting a control on the Ribbon? Well if that describes something that you are trying to do, then this post is for you. Let’s start with Ribbons. The other two (form regions and task panes) are bit more troublesome.

Ribbons

Ribbon controls are the easiest to access from other areas of your application. Assuming that your custom Ribbon is named Ribbon1, here is what you do:

ThisRibbonCollection ribbonCollection =
Globals.Ribbons
[Globals.ThisAddIn.Application.ActiveInspector()];
ribbonCollection.Ribbon1.comboBox1.Text = "Hello World";

You can read more about this here.

Form Regions

For the VB folks, this is a snap. C# developers have to do a bit more work. That is because by default, in a C# project, the controls that you add to a form region are private. For each control that you want to access, you have to set the Modifiers property of the control to Internal or Public. For example:

You can then add code to access the control. For example, assuming that your form region is named FormRegion1, you could use the following code:

WindowFormRegionCollection formRegions =
    Globals.FormRegions
        [Globals.ThisAddIn.Application.ActiveInspector()];
formRegions.FormRegion1.textBox1.Text = "Hello World";

You can read more about this here.

Custom Task Panes

Controls on task panes require the same tweaks described for form regions above. Here is an example of how to get to a button on a task pane. This example makes the following assumptions:

The user control of the custom task pane is named MyUserControl.
The task pane is named myCustomTaskPane and it is declared as public in your code.

((MyUserControl)Globals.ThisAddIn.myCustomTaskPane.Control).button1.Text = "It Worked";

If have not yet created a custom task pane, see this topic and it will all make sense.

As a side note, if you are adding custom task panes to Outlook Inspector windows, you have to write a bit of code to map each Inspector window with it’s own instance of a custom task pane. If you don’t do this mapping, you get all kinds of wacky issues. For an example of how to do this, see the following article.

For the sake of being thorough, here is an example of how you can access a task pane created by using the guidance in that article.

private void toggleButton1_Click(object sender, RibbonControlEventArgs e)
{
    Outlook.Inspector inspector = (Outlook.Inspector)e.Control.Context;
    InspectorWrapper inspectorWrapper = Globals.ThisAddIn.InspectorWrappers[inspector];
    CustomTaskPane taskPane = inspectorWrapper.CustomTaskPane;
    if (taskPane != null)
    {
        taskPane.Visible = ((RibbonToggleButton)sender).Checked;
        taskPane.DockPosition = Microsoft.Office.Core.MsoCTPDockPosition.msoCTPDockPositionBottom;
        taskPane.Height = 475;
    }
}

Hope this helps!

Norm E.

Sign up for Office 2010 Technical Preview

VSTO Team — Tue, 12 May 2009 20:36:36 GMT

I’m at TechEd in LA, but it seems I could get just as much excitement just watching the Twittersphere today and watching #tela09 tags! And my feet are killing me. So be glad you’re sitting at your computer instead of walking around Los Angeles! Let me give you some highlights for Office developers:

Watch the Keynotes which include Office 2010 demos. Also some interviews on Office and SharePoint on the same TechEd site.

Office 2010 The Movie: Countdown to Awesome is the new site where you can watch a slick video and more importantly, click the Sign up for the Microsoft Office 2010 Technology Preview. When you click the link they show you the “fine print” which I will now print in large font:

By registering you are signing up to be considered for the Technical Preview Program, you will be waitlisted for consideration to be invited into the Technical Preview Program. We will notify invitees in early to mid July.

“What does that mean?” you ask. Well, it means that Microsoft wants to collect a wide variety of customer-types and ensure that our TechPreview covers all the different types of customers. For example, the sign-up form asks if you will test the Tech Preview at Home or Work. Be honest in your answer because we truly want to get perspectives from all types of Office users. Similarly the survey asks the size of your company and if you read Japanese. There is no trick to get invited.

If you don’t get invited, then don’t fret. We’ll give you some useful information on this blog and other Office blogs to help you prepare your business for the future. For now, I encourage you to build great solutions for Office using all of the resources at Microsoft including Visual Studio, VBA, Open XML SDK, code samples, Forum support, Code Gallery, and the Office Developer Center.

Sincerely, Christin Boyd, Program Manager

TechEd Sessions on Office Development

VSTO Team — Fri, 08 May 2009 00:16:02 GMT

If you’re going to TechEd in Los Angeles next week, then don’t miss these four sessions:

DTL03-INT Meet the Microsoft Visual Studio Team
Christin Boyd, Eric Carter, Paul Yuknewicz, Jay Schmelzer, Dustin Campbell, Jonathan Aneja, Luke Hoban, Igor Zinkovsky, Faisal Nasir, Harry Pierson, Lisa Feigenbaum
Mon 5/11 2:45 PM-4:00 PM | Blue Theater 1

OFC325 Building Custom Applications in Microsoft Office Outlook 2007
Ty Anderson, Damon Armstrong
Tue 5/12 2:45 PM-4:00 PM | Room 408A

DTL324 - Microsoft Visual Studio 2010 Overview for the Business Application Developer
Jay Schmelzer
Tue 5/12 4:30 PM-5:45 PM | Room 515B

OFC324
Advanced Microsoft Office Word and Excel 2007 Development in Microsoft Visual Studio 2008 with Visual Studio Tools for Office
Eric Carter
Thursday 5/14 1:00PM-2:15PM | Room 515A

Of course, there are a dozen other sessions that appeal to Office developers and SharePoint developers. These are the four that I highly recommend. Originally I was going to list the 3 not-to-be-missed sessions, but then I couldn’t drop any of these from my list, so we have 4 Must See Sessions!

If you’re not going to TechEd, then please click the links on these speakers’ names to read their blogs where the will eventually post some of their demo code. Expect the posts to happen the Monday after their sessions. In the case of Eric Carter, he would probably love it if you’d buy his book, Visual Studio Tools for Office 2007: VSTO for Excel, Word and Outlook. Or you could just download a zip file with all of the of code from the book here. That should keep you busy for a while. The explanations in the book really do add to the overall value. I should credit the co-author, Eric Lippert. Both men are brilliant and funny, and very modest. At the Holiday Party this year, Eric Carter got up to sing karaoke and astounded us all with a bouncy rendition of “Sesame Street.”

-Christin Boyd, Program Manager, Visual Studio

Here is a Way to Get the ID of a Built-in Outlook Command Bar Menu (Norm Estabrook)

VSTO Team — Fri, 01 May 2009 00:09:27 GMT

Recently, a forum poster asked us how he could add a submenu item to a built-in menu item in Outlook. Note that these are not controls that appear on the Ribbon of an Outlook item, but rather the menus that drop down from the top of the Outlook Explorer such as the View menu and the Tools menu.

So one way to do this (In fact the only way that I know of) is to use the example shown in the following MSDN topic - How to: Add Custom Menus and Menu Items to Outlook.

You can’t just use the example as is. You will need to add a line of code to get a handle to a built-in menu. The following example gets a handle to the Junk E-Mail menu that appears off of the Actions menu of the Outlook Explorer window.

Office.CommandBarPopup junkEmailMenu = (Office.CommandBarPopup)
this.Application.ActiveExplorer().CommandBars.FindControl
(Office.MsoControlType.msoControlPopup, 31353, missing, missing);

Note the ID number shown in the second parameter to the FindControl method. How on earth did I know that the Junk E-Mail menu is the 31353 menu? The answer is … Not very easily. In fact to obtain that ID, I wrote a small Outlook add-in that iterates through all menus in Outlook and prints out their corresponding codes. I figured that I would share this with you in case you ever have a similar scenario.

Two notes about the sample below: First - this is a C# example, so my apologies to VB’ers. Second - this example is meant to be used in a Visual Studio 2008 Outlook (2007 or 2003) add-in project. These projects automatically include the appropriate using statements that enable you to use the prefix “Office” in place of “Microsoft.Office.Core” when referring to some objects etc.

Ok. Here is the code:

public partial class ThisAddIn
{
    private void ThisAddIn_Startup(object sender, System.EventArgs e)
    {
        Outlook.Application app = this.Application;
        //Create a new txt file to record controls' list

        System.IO.StreamWriter sw = System.IO.File.CreateText
            (@"C:\Outlook Menus.txt");

        //loop through Outlook ActiveExplorer CommandBars to get all CommandBars

        foreach (Office.CommandBarControl cb in app.ActiveExplorer().CommandBars.ActiveMenuBar.Controls)
        {
            PrintMenuItems(cb, sw);
        }

        sw.Close();

    }

    // Recursive method for printing menus and nested menus.
    // Either the menu is a commandbarpopup (contains submenus)
    // Or it is a commandbarbutton (contains no submenus)

    private void PrintMenuItems(object menuItem, System.IO.StreamWriter sw)
    {
        if (menuItem as Office.CommandBarButton == null)
        {
            // This is a menu bar popup control.
            sw.WriteLine((menuItem as Office.CommandBarPopup).Caption +
                "\t" + (menuItem as Office.CommandBarPopup).Id.ToString());

            if ((menuItem as Office.CommandBarPopup).accChildCount > 0)
            {
                for (int j = 1; j <= (menuItem as Office.CommandBarPopup).accChildCount; j++)
                {
                    PrintMenuItems((menuItem as Office.CommandBarPopup).get_accChild(j), sw);
                }
            }
        }
        else
        {
            // Must be a command
            sw.WriteLine("\t" + (menuItem as Office.CommandBarControl).Caption +
                "\t" + (menuItem as Office.CommandBarControl).Id.ToString());
        }

    }

Enjoy!

Norm E.

Clearing Off Custom Menu Items in Word (Norm Estabrook)

VSTO Team — Tue, 14 Apr 2009 21:37:15 GMT

Last month I posted this article that described how to prevent your add-in from creating duplicate menu items in Word. If you have been experimenting with customization contexts, you might have several menu items that appear when you right click a document. The article that I posted shows how to prevent this from happening for your users, but what about removing the items that appear in your instance of Word – the one that you use for testing?

To clear those off, just add a bit of code to the startup event handler of any old Word add-in. Set the customization context to each possible culprit (template, document, attached template etc.) and then call the Reset method. Be sure to save the template or document after words.

Note - I wouldn’t recommend that you put this code into an add-in that you send out to users as this code will remove all customizations in each context (Even ones that your add-in has not created!). However, it is a cool way to clear up left over menu items from the instance of Word that you use for testing.

private void ResetShortcutMenu()
{
    myApplication.CustomizationContext = myApplication.ActiveDocument;

    myApplication.CommandBars["Text"].Reset();
    myApplication.ActiveDocument.Save();

    myApplication.CustomizationContext = myApplication.ActiveDocument.get_AttachedTemplate();

    myApplication.CommandBars["Text"].Reset();
    ((Word.Template)myApplication.ActiveDocument.get_AttachedTemplate()).Save();

    myApplication.CustomizationContext = customTemplate;

    myApplication.CommandBars["Text"].Reset();
    customTemplate.Save();

    myApplication.CustomizationContext = myApplication.NormalTemplate;

    myApplication.CommandBars["Text"].Reset();
    myApplication.NormalTemplate.Save();
}

Building Office Business Applications with Visual Studio

VSTO Team — Tue, 03 Feb 2009 22:01:00 GMT

This week Microsoft is hosting an internal even called Tech Ready 8 in Seattle. Microsoft technical field reps and product teams come together to talk about all of the great products we're building. I presented a session on Building Office Development Applications with Visual Studio along with a couple team members. In preparation for that session we spent the past week building a demo application that surfaces LOB data exposed as an ADO .NET dataservices in Outlook and Excel clients and SharePoint. Beth Massi is doing a blog series on how we wrote the soloution. Check it out.