Office Development with Visual Studio : Word 2007

Office Development with Visual Studio 2008 Tutorial Series – Part 2(Beth Massi)

VSTO Team — Tue, 08 Dec 2009 18:36:03 GMT

Last month Robert Green, VSTO MVP, started a series of tutorials on building on Office 2007. Today we published part 2 of his step-by-step tutorials.

In this second part of the series of tutorials on Office Business Applications, learn how to create a Word 2007 price quote generation solution using Visual Studio 2008. This tutorial shows you how to create a custom task pane to display data from a database and binding that data to content controls. This step-by-step tutorial also includes full source code in Visual Basic and C#. Check out the tutorial on the VSTO Developer Center:

Building an Office Business Application Part 2 – Generating Automobile Quotes

And if you missed part 1:

Building an Office Business Application Part 1 - Scheduling Customer Appointments

If you’re just getting started with Office development in Visual Studio, this is a great place to start.

Enjoy,
-Beth Massi, Visual Studio Community

VSTO Bug Tracker (Eric Carter, Beth Massi)

VSTO Team — Mon, 18 May 2009 23:16:30 GMT

Eric Carter released a sample and series of articles based on his TechEd demo last week that shows you how to bring bug data from TFS into Excel and Word using VSTO so it can be further analyzed.

If you you went to TechEd but missed the session you can watch it here if you’ve registered:

Advanced Microsoft Office Word and Excel 2007 Development in Microsoft Visual Studio 2008 with Visual Studio Tools for Office

Everyone can download the sample here.

And don’t forget to check the VSTO Dev Center often for more news, articles, videos, and samples.

Enjoy,
-Beth Massi, Visual Studio Community

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

Test Automation Tips: “User Name” dialog after new install of Word (Christin Boyd, Bill Robertson)

VSTO Team — Wed, 06 May 2009 00:12:12 GMT

We have a team of developers who focus entirely on writing test automation programs for the purpose of covering the huge matrix of test cases that Visual Studio requires. We often configure new installs of Office and our automated tests need to deal with the special things that Office products do when you first run them after a new install. For example, when you first run Microsoft Word after a new install, it prompts you to enter your name and initials in a dialog that looks like this:

Our talented SDET’s (Software Development Engineer in Test) use the following function in their automated tests to suppress this dialog:

using System.IO;

using System.Diagnostics;

public static bool AddOffice12UserInfo()

            bool passed = false;

            string[] commands = new string[5];

            commands[0] = @"add HKCU\Software\Microsoft\Office\12.0\Common /v UserData /t REG_DWORD /d 1 /f";

            commands[1] = @"add HKCU\Software\Microsoft\Office\Common\UserInfo /v Company /t REG_SZ /d Microsoft /f";

            commands[2] = @"add HKCU\Software\Microsoft\Office\Common\UserInfo /v UserName /t REG_SZ /d TestRun /f";

            commands[3] = @"add HKCU\Software\Microsoft\Office\Common\UserInfo /v UserInitials /t REG_SZ /d t /f";

            commands[4] = @"add HKCU\Software\Microsoft\Office\12.0\Common\General /v ShownOptIn /t REG_DWORD /d 00000001 /f";

            for (int i = 0; i < commands.Length; i++)

                bool temp = StartREG(commands[i]);

                if (!temp)

                    return false;

            passed = true;

            return passed;

public static bool StartREG(string arguments)

    bool passed = false;

    int exitcode = -100;

try

        string localpath = Path.Combine(System.Environment.GetEnvironmentVariable("SYSTEMROOT"), "system32");

        System.Diagnostics.Process myProcess = new System.Diagnostics.Process();

        myProcess.EnableRaisingEvents = false;

        myProcess.StartInfo.FileName = Path.Combine(localpath, "reg.exe");

        myProcess.StartInfo.Arguments = arguments;

        myProcess.StartInfo.UseShellExecute = false;

        myProcess.Start();

        myProcess.WaitForExit();

        exitcode = myProcess.ExitCode;

        if (exitcode == 0)

            passed = true;

        else

            Debug.WriteLine("reg exit code is::" + myProcess.ExitCode.ToString());

    catch (Exception ex)

        Debug.Fail(ex.Message, ex.StackTrace);

    return passed;

Let me know if these Test Automation samples are useful and we will try to publish more of these.

-Christin Boyd, Program Manager, Visual Studio and Bill Robertson, Software Development Engineer in Test, Visual Studio

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();
}

My Word Add-In Creates Duplicate Menu Items. Make it Stop! (Norm Estabrook)

VSTO Team — Fri, 06 Mar 2009 20:33:19 GMT

So I want my add-in to place a custom command into the shortcut menu. The shortcut menu is that cool menu that appears when you right-click a document. Great, so I read some articles in MSDN, write some code, run the add-in and voila there it is! I give it to my buddy, he is proud of my accomplishment and and installs my add-in. Now he hates me because every time he opens up Word, a duplicate menu appears. Where did I go wrong?

Well actually, I didn’t do anything wrong. It’s just that Word requires a little more attention when it comes to handling menus. I guess you can say that Word is a bit more “needy” than other Office applications. But being “higher maintenance” does not have to mean “higher maintenance costs”. Hopefully this post will get your friend talking to you again.

My code

Here is the code that did not work for me. BTW – I will paste in both Visual Basic and C# examples for this post.

[Visual Basic]

Private MyApplication As Word.Application
Private WithEvents myControl As Office.CommandBarButton

Private Sub ThisAddIn_Startup _
(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup

    MyApplication = Me.Application
    AddMenuItem()

End Sub

Private Sub AddMenuItem()

    Dim menuItem As Office.MsoControlType = _
        Office.MsoControlType.msoControlButton

    myControl = CType(MyApplication.CommandBars("Text").Controls.Add _
       (menuItem, 1, True), Office.CommandBarButton)

    myControl.Style = Office.MsoButtonStyle.msoButtonCaption
    myControl.Caption = "My Menu Item"
    myControl.Tag = "MyMenuItem"

End Sub


Sub myControl_Click(ByVal Ctrl As Microsoft.Office.Core.CommandBarButton, _
                    ByRef CancelDefault As Boolean) Handles myControl.Click

    System.Windows.Forms.MessageBox.Show("My Menu Item clicked")

End Sub

[C#]

private Word.Application myApplication;
private Office.CommandBarButton myControl;

private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
    myApplication = this.Application;
    AddMenuItem(); 
}
 
private void AddMenuItem()
{
   Office.MsoControlType menuItem = 
        Office.MsoControlType.msoControlButton;

    myControl = 
        (Office.CommandBarButton)myApplication.CommandBars["Text"].Controls.Add
        (menuItem,missing, missing, 1, true);

    myControl.Style = Office.MsoButtonStyle.msoButtonCaption;
    myControl.Caption = "My Menu Item";
    myControl.Tag = "MyMenuItem";

    myControl.Click += 
        new Microsoft.Office.Core._CommandBarButtonEvents_ClickEventHandler
            (myControl_Click);

}

void myControl_Click(Microsoft.Office.Core.CommandBarButton Ctrl, 
    ref bool CancelDefault)
{
    System.Windows.Forms.MessageBox.Show("My Menu Item clicked");
}

Why my code does not work as expected

Here is one issue I can see right off the bat. Note this line of code for adding a control:

myControl = CType(MyApplication.CommandBars("Text").Controls.Add _ (menuItem, 1, True), Office.CommandBarButton)

I set the last parameter of the Add method to True. This value specifies that I want my control to be temporary. I am trying to tell Word not to save the control so that duplicate menu items won’t be added every time Word opens. Only there is a problem here. Word ignores this parameter (at least for controls in a CommandBar collection anyway). So I can keep it set to true, but it really means false. Lovely.

So what is happening? Well, Word is actually saving your new menu command to the Normal.dot template every time a new instance of Word opens – hence the duplicates.

What can I do about this?

There are probably a billion creative ways to stop the duplicate menus from appearing, but here are three tips that work really well. Here they are:

Check for duplicates before adding an item (control) to a menu.
Always set the customization context of the application to the same document or template before adding or deleting a control.
Because there are no temporary commands in Word, use a custom template to save the commands.

Tip # 1: Check for Duplicates:

This one is pretty easy. Just add code to your add-in that looks for a control that has the same tag as the control you are about to add. If one exists, perform one of the following actions:

Don’t add the control (It is already there).
Delete the control. Then you can add it.

I modified my code to delete the control. Here is my code.

[Visual Basic]

Private Sub RemoveExistingMenuItem()

    Dim contextMenu As Office.CommandBar = _
    MyApplication.CommandBars("Text")

    MyApplication.CustomizationContext = customTemplate

    Dim control As Office.CommandBarButton = contextMenu.FindControl _
        (Office.MsoControlType.msoControlButton, System.Type.Missing, _
         "MyMenuItem", True, True)

    If Not (control Is Nothing) Then
        control.Delete(True)
    End If

End Sub

[C#]

private void RemoveExistingMenuItem()
{
    Office.CommandBar contextMenu = myApplication.CommandBars["Text"];
    myApplication.CustomizationContext = customTemplate;

    Office.CommandBarButton control = 
        (Office.CommandBarButton)contextMenu.FindControl
        (Office.MsoControlType.msoControlButton, missing,
        "MyMenuItem", true, true);

    if ((control != null))
    {
        control.Delete(true);
    }

}

Tip #2: Set the Customization Context

The customization context of the application tells Word where to save your customizations. To specify the customization context, set the CustomizationContext property of the Application object.

By default, Word uses the Normal.dot template as it’s customization context. This is not reliable and can change. If you do not explicitly set the context, you might search for controls saved to one context such as a document, delete controls from another context such as a custom template and then add the control to another context such as Normal.dot.

To avoid these issues, always set the customization context of the application to the same document or template every time you search for, delete, or add controls to a menu.

Note that in a Word document-level customization, it is probably best to set the customization context to the active document. That way when the user uninstalls the customization, the document and the menu commands that pertain to that document disappear as expected.

In Word application-level add-in, the best practice is to use a custom template for reasons mentioned later on in this post.

In the following example, I highlighted in bold the line that sets the customization context. Further along in this post, I will show you where I got customTemplate.

[Visual Basic]

Private Sub AddMenuItem()

    MyApplication.CustomizationContext = customTemplate

    Dim menuItem As Office.MsoControlType = _
        Office.MsoControlType.msoControlButton

    myControl = CType(MyApplication.CommandBars("Text").Controls.Add _
       (menuItem, 1, True), Office.CommandBarButton)

    myControl.Style = Office.MsoButtonStyle.msoButtonCaption
    myControl.Caption = "My Menu Item"
    myControl.Tag = "MyMenuItem"
    customTemplate.Saved = True

    GC.Collect()

End Sub

[C#]

private void AddMenuItem()
{
    myApplication.CustomizationContext = customTemplate;
    Office.MsoControlType menuItem = 
        Office.MsoControlType.msoControlButton;

    myControl = 
        (Office.CommandBarButton)myApplication.CommandBars["Text"].Controls.Add
        (menuItem,missing, missing, 1, true);

    myControl.Style = Office.MsoButtonStyle.msoButtonCaption;
    myControl.Caption = "My Menu Item";
    myControl.Tag = "MyMenuItem";

    myControl.Click += 
        new Microsoft.Office.Core._CommandBarButtonEvents_ClickEventHandler
            (myControl_Click);

    customTemplate.Saved = true;

    GC.Collect();

Also – a quick tip – set the Saved property of the template to true after you add the control. This stops that annoying prompt from appearing that asks if you would like to save your customizations to the template.

Tip #3: Use a Custom Template

It is very difficult to delete a control before the add-in shuts down. For example, if you attempt to delete a control in the ThisAddIn_Shutdown event handler, you will receive a not so helpful COM exception. You will get similar results in the Quit event of Word.

That is because the template that you are using as your application’s customization context is not writable in either of those event handlers. So if you cannot easily delete the control when Word closes, that means that the control will always live inside of the template.

This is a problem if you are using Normal.dot to persist the controls. Here is why. Let’s say the user decides that he does not want to see your command in a menu anymore. With a caption such as “My Menu Item”, can you really blame him? So the user uninstalls your add-in. However, the menu command still lives in Normal.dot! When that user opens his document in Word, "My Menu Item” still appears. Doooh! Here comes the support calls!

The way around this is to provide your own custom template to store customizations such as custom menus and menu items. Your setup application can remove the template along with add-in. That way when the user uninstalls the add-in, they also remove the template that contains the menu items.

In the following example, I retrieve a custom template from the users documents folder. Yes, your setup application will probably use a different location to place the custom template, but this is just for an example.

[Visual Basic]

Private Sub GetCustomTemplate()

    Dim TemplatePath As String = Environment.GetFolderPath _
        (Environment.SpecialFolder.MyDocuments) + "\MyCustomTemplate.dotx"
    Dim install As Boolean = True

    For Each installedTemplate As Word.Template In MyApplication.Templates
        If installedTemplate.FullName = DirectCast(TemplatePath, String) Then
            install = False
        End If
    Next

    If install = True Then
        MyApplication.AddIns.Add(TemplatePath.ToString(), True)
    End If

    customTemplate = MyApplication.Templates(TemplatePath)

End Sub

[C#]

private void GetCustomTemplate()
{
    object TemplatePath = Environment.GetFolderPath
        (Environment.SpecialFolder.MyDocuments) +
        "\\MyCustomTemplate.dotx";
    object install = true;

    foreach (Word.Template installedTemplate in myApplication.Templates)
    {
        if (installedTemplate.FullName == (string)TemplatePath)
        {
            install = false;
        }
    }
    if ((bool)install)
    {
        myApplication.AddIns.Add(TemplatePath.ToString(), ref install);
    }
    customTemplate = myApplication.Templates.get_Item(ref TemplatePath);

}

Drum roll please .. I present the complete example

To provide context, here is the complete sample:

[Visual Basic]

Public Class ThisAddIn

    Private MyApplication As Word.Application
    Private WithEvents myControl As Office.CommandBarButton
    Private customTemplate As Word.Template

    Private Sub ThisAddIn_Startup _
    (ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup

        MyApplication = Me.Application

        GetCustomTemplate()
        RemoveExistingMenuItem()
        AddMenuItem()

    End Sub

    Private Sub GetCustomTemplate()
        Dim TemplatePath As String = Environment.GetFolderPath _
            (Environment.SpecialFolder.MyDocuments) + "\MyCustomTemplate.dotx"
        Dim install As Boolean = True

        For Each installedTemplate As Word.Template In MyApplication.Templates
            If installedTemplate.FullName = DirectCast(TemplatePath, String) Then
                install = False
            End If
        Next

        If install = True Then
            MyApplication.AddIns.Add(TemplatePath.ToString(), True)
        End If

        customTemplate = MyApplication.Templates(TemplatePath)

    End Sub

    Private Sub RemoveExistingMenuItem()

        Dim contextMenu As Office.CommandBar = _
        MyApplication.CommandBars("Text")

        MyApplication.CustomizationContext = customTemplate

        Dim control As Office.CommandBarButton = contextMenu.FindControl _
            (Office.MsoControlType.msoControlButton, System.Type.Missing, _
             "MyMenuItem", True, True)

        If Not (control Is Nothing) Then
            control.Delete(True)
        End If

    End Sub


    Private Sub AddMenuItem()

        MyApplication.CustomizationContext = customTemplate

        Dim menuItem As Office.MsoControlType = _
            Office.MsoControlType.msoControlButton

        myControl = CType(MyApplication.CommandBars("Text").Controls.Add _
           (menuItem, 1, True), Office.CommandBarButton)

        myControl.Style = Office.MsoButtonStyle.msoButtonCaption
        myControl.Caption = "My Menu Item"
        myControl.Tag = "MyMenuItem"
        customTemplate.Saved = True

        GC.Collect()

    End Sub

    Sub myControl_Click(ByVal Ctrl As Microsoft.Office.Core.CommandBarButton, _
                        ByRef CancelDefault As Boolean) Handles myControl.Click

        System.Windows.Forms.MessageBox.Show("My Menu Item clicked")

    End Sub

    Private Sub ThisAddIn_Shutdown() Handles Me.Shutdown

    End Sub

End Class

[C#]

public partial class ThisAddIn
{
    private Word.Application myApplication;
    private Office.CommandBarButton myControl;
    private Word.Template customTemplate;

    private void ThisAddIn_Startup(object sender, System.EventArgs e)
    {
        myApplication = this.Application;

        GetCustomTemplate();
        RemoveExistingMenuItem();
        AddMenuItem();
    }

    private void GetCustomTemplate()
    {
        object TemplatePath = Environment.GetFolderPath
            (Environment.SpecialFolder.MyDocuments) +
            "\\MyCustomTemplate.dotx";
        object install = true;
        foreach (Word.Template installedTemplate in myApplication.Templates)
        {
            if (installedTemplate.FullName == (string)TemplatePath)
            {
                install = false;
            }
        }
        if ((bool)install)
        {
            myApplication.AddIns.Add(TemplatePath.ToString(), ref install);
        }
        customTemplate = myApplication.Templates.get_Item(ref TemplatePath);

    }

    private void RemoveExistingMenuItem()
    {
        Office.CommandBar contextMenu = myApplication.CommandBars["Text"];
        myApplication.CustomizationContext = customTemplate;

        Office.CommandBarButton control =
            (Office.CommandBarButton)contextMenu.FindControl
            (Office.MsoControlType.msoControlButton, missing,
            "MyMenuItem", true, true);

        if ((control != null))
        {
            control.Delete(true);
        }

    }

    private void AddMenuItem()
    {
        myApplication.CustomizationContext = customTemplate;
        Office.MsoControlType menuItem =
            Office.MsoControlType.msoControlButton;

        myControl =
            (Office.CommandBarButton)myApplication.CommandBars["Text"].Controls.Add
            (menuItem, missing, missing, 1, true);

        myControl.Style = Office.MsoButtonStyle.msoButtonCaption;
        myControl.Caption = "My Menu Item";
        myControl.Tag = "MyMenuItem";

        myControl.Click +=
            new Microsoft.Office.Core._CommandBarButtonEvents_ClickEventHandler
                (myControl_Click);

        customTemplate.Saved = true;

        GC.Collect();

    }

    void myControl_Click(Microsoft.Office.Core.CommandBarButton Ctrl,
        ref bool CancelDefault)
    {
        System.Windows.Forms.MessageBox.Show("My Menu Item clicked");
    }
    private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
    {
    }
}

Now you can issue a patch to your buddy so that he has only one “My Menu Item” appearing in his shortcut menu. Although .. I am not sure what “My Menu Item” is really suppose to do …

New "How Do I" Video on Creating Smart Tags in Word (Beth Massi)

VSTO Team — Thu, 18 Dec 2008 20:00:00 GMT

Our very own Mary Lee has got a new video up on the Dev Center on programming smart tags in with custom recognizers in Word using Visual Studio 2008 Service Pack 1. This is a video version of the How To topic in the MSDN library.

Watch or download the video here.

Thanks Mary!

Enjoy,
-Beth Massi, Visual Studio Community

Why Can’t I Change the Update Path when Redeploying VSTO Solutions? (Christin Boyd, Kris Makey, Jeff Young)

VSTO Team — Wed, 17 Dec 2008 01:45:39 GMT

The other day I was asked about the automatic Updates feature of VSTO 3.0 deployment. In this scenario, he used the Publish Wizard in VS 2008 to create a Word document solution and the install manifest. Then a bunch of people used the Word document, and kicked off the installer which then copied things to their ClickOnce cache. Everything worked fine. Then he needed to make changes to the code, recompile, and somehow get the solution to all of his customers. Instead of using the Publish Wizard to create the update in the same server, he chose to use a different server path. The customers were unable to install the updates. He tried editing the custom properties of the document to change the install path to the new server, but it still didn’t work. Then he tried testing with a new, clean computer, and on that computer he was able to install from the new path and use the new Word document. He asked us why were the “old” users unable to get the update?

This question shows up on the Forum occasionally. “Why can I not change the update location of VSTO v3 Add-in or Document once it is installed?” (Or) “Why does VSTO continue to check in the old location even after I change location property on client machines that installed the old version?”

The Path to the deployment manifest is used as part of the Identity for an Add-in. During the First installation of an Add-in or Document, the Full Path is set and stored by the VSTO Runtime for that client machine. Once you have installed an Add-in changing the path in the registration will cause the Add-in to throw an Error. Once you have installed a customized Document, the code-behind will only check the original location and changes to the path stored in the document will be ignored (this is to allow copying a local version of a customized document that you installed from a remote location). In order to change the location that an Add-in or Document checks for updates, you must First uninstall the “old” version on the installed clients and then install from the new location.

Now, if you want to delve deeper, then keep reading this paragraph, or skip to the next one. The low-level explanation is that ClickOnce uses the solution path as part of its identity when storing solutions into the ClickOnce cache. You will get similar behavior in a CO-deployed Windows Application as well _unless_ you use the deploymentProviderURL (DPURL). Setting the DPURL can allow WinForms applications to change where updates are pulled from so that Server A (from which a solution was original installed) can be decommissioned and updates can be retrieved from Server B. VSTO does not support DPURL. Why not, you ask? At the time we were considering it during the development of VS 2008, the amount of development work-months required was more than the time we had remaining (DPURL has implications on migration of data from old solution to new solution, for instance). After much discussion, we decided to have the ClickOnce team throw an exception of a DPURL is set for VSTO solutions. At the start of development for VS 2010, we considered this feature again, but again this feature did not make our list of highest priority deployment features. We are implementing a lot of new deployment features for VS 2010.

In conclusion, the solution Path is used as part of the identity. You can’t change the update path after you've installed an Office solution. In a Windows solution, you can change the update path using DPURL. VSTO doesn’t support DPURL because we couldn’t fit that feature in the development schedule. The workaround is to uninstall the solution from the user’s computer when it is stuck pointing to an old path that you can’t update anymore and then reinstall with a new Install Path set in the Publish wizard. We recommend that you set your Install Path to a URL that you predict can stay the same for as long as your users will need updates.

This explanation applies to Word document and template solutions, and to Excel spreadsheet and template solutions.

I hope this blog entry is helpful! Please leave comments to this article if you have feedback.

-Kris Makey, Jeff Young, Christin Boyd, Mary Lee and Saurabh Bhatia contributed to this blog post

Community Article: Enabling Speech Recognition in Microsoft Word 2007 with Visual Studio 2008 (Beth Massi)

VSTO Team — Wed, 22 Oct 2008 01:51:47 GMT

A new community submitted article was just released on the Office Development with Visual Studio portal by MVP Alessandro Del Sole. In this article learn how to control the Vista operating system's speech recognition engine in .NET from a custom task pane in Microsoft Word 2007. This article compliments Alessandro's previous article on a text-to-speech add-in for Word 2007.

Enjoy,
-Beth Massi, Visual Studio Community

Word Add-ins Part 3: Search for Text Strings in Documents and Add Comments (Harry Miller)

VSTO Team — Thu, 11 Sep 2008 00:49:40 GMT

You can search the text in any open Microsoft Office Word document for specific strings if you put the code in an application-level add-in. When you find an instance of the string, you can perform some action on it. This video shows how to flag the string with a comment that contains text passed in from a calling method.

The code comes from the forum thread that's linked below, under "Related resources." You could just look at it there, but then you'd miss the whole "why did he get knocked in the head last time" thing. Oh, the title is different in the video because no one would search the Web for "to hunt lives the add-in" to answer this question, but I think it's a much more dramatic title for a video about an add-in that searches for stuff, after you've already found the video.

Related resources:

Forum: Look for a string and comment it - how?

How to: Search for Text in Documents

How to: Set Search Options in Word

Find Object (Word 2007 Reference)

Duration: 3 minutes, 39 seconds

Word Add-ins Part 1: Clear the Ribbon Except for My Controls (Harry Miller)

VSTO Team — Wed, 03 Sep 2008 04:48:56 GMT

You can easily customize the Ribbon to show only the controls you want to display. This video shows how to clear the Ribbon in Microsoft Office Word so it contains only a single button. The button inserts a graphic into the open Word document at the cursor location. Why? Well, really it's just to demo the Ribbon thing. But some day you might want to insert images into a document too, who knows?

Related resources

Forum: Ribbon and Start from Scratch

OfficeRibbon.StartFromScratch Property

Duration: 4 minutes, 11 seconds

Catching Save or SaveAs in Word 2007 (Harry Miller)

VSTO Team — Fri, 04 Jul 2008 00:57:00 GMT

You can override Ribbon commands and run your own code for Save or Save As, or you can simply cancel attempts to save a document in the DocumentBeforeSave event handler.

Code and resources:

Forum post: Microsoft Word 2007 Disable Save As

Temporarily Repurpose Commands on the Office Fluent Ribbon

DocumentBeforeSave event

Video duration: 51 seconds

<\/embed><\/div>";" galleryimg="no" mce_src="http://blogs.msdn.com/blogfiles/vsto/WindowsLiveWriter/CatchingSaveorSaveAsinWord2007_D0A7/video550e2d8692f1.jpg">

Peek at Service Pack 1 (Christin Boyd)

VSTO Team — Mon, 12 May 2008 08:42:10 GMT

Visual Studio 2008 Service Pack 1 is not finished yet, but we do have a beta version of the documentation ready for you to read! You can learn about some of the features that you'll see later this year when we release SP1.

I recommend starting with reading about a totally new feature that we put into SP1 that allows you to extend Word documents and Excel Workbooks at runtime from an Application-Level Add-in. Here is the link to the Beta of the documentation:

http://vs2008sp1docs.msdn.microsoft.com/en-us/ms334311.aspx

You'll be able to create objects and respond to events including:

Host Controls
ListObjects
Smart Tags
Word Content Controls
and Events such as DocumentBeforeSave

Only some of the new deployment features have been documented so far. You can read about one of the new deployment features in the Event Logging (2007 System) page in the SP1 documentation here:

http://vs2008sp1docs.msdn.microsoft.com/en-us/ms331997.aspx

Starting in Visual Studio 2008 Service Pack 1 (SP1), you can use the event viewer in Windows to see error messages that are captured by the Visual Studio Tools for Office runtime when you install or uninstall Visual Studio Tools for Office solutions. You can use these messages from the event logger to resolve installation and deployment problems.

The Beta version of the Service Pack is only getting distributed to about a thousand beta testers who have great reputations for submitting clear feedback and bug reports. I hope this little peek at the documentation will get you excited about what's coming later this summer in Service Pack 1.

-Christin Boyd, Program Manager

Visual Studio Command Bar for Arranging Controls on Documents and Worksheets (McLean Schofield)

VSTO Team — Fri, 11 Apr 2008 00:05:00 GMT

One of the lesser-known features of Visual Studio Tools for Office is the Microsoft Office Word and Microsoft Office Excel command bar. When you are developing a document-level project for Word or Excel (for example, a Word Document or Excel Workbook project) and you have the document or one of your worksheets open in the designer, this command bar appears in Visual Studio, just above the designer. In Excel, this command bar looks like the following by default.

The first several buttons in this command bar are for changing the keyboard scheme and mapping XML to the document or worksheet. This post is about the purpose of the rest of the buttons.

If you are designing a custom UI for your document or worksheet that includes Windows Forms controls that you add by using the designer, you can use these buttons to arrange the controls with a single click. When you select multiple controls in the designer, these buttons become enabled.

From left to right, here are the buttons you can use:

Align Lefts. This button moves all of the controls to the left, so that they are aligned with the left side of the left-most control.
Align Centers. This button moves all of the controls left or right so that they are aligned around the vertical axis of the widest control.
Align Rights. This button moves all of the controls to the right, so that they are aligned with the right side of the right-most control.
Align Tops. This button moves all of the controls up, so that they are aligned with the top side of the upper-most control.
Align Middles. This button moves all of the controls up or down, so that they are aligned around the horizontal axis of the tallest control.
Align Bottoms. This button moves all of the controls down, so that they are aligned with the bottom side of the bottom-most control.
Make Horizontal Spacing Equal. The left-most and right-most control remain in place; the controls in between move horizontally so that there is equal horizontal space between each control.
Make Vertical Spacing Equal. The top-most and bottom-most control remain in place; the controls in between move vertically so that there is equal vertical space between each control.

A special note about Word. In Word projects, the alignment buttons are enabled only if the selected controls are not in line with text. By default, controls that you add to a Word document at design time are in line with text. To change the layout style of the control, right-click the control and then click Format Control. Then, on the Layout tab, select a wrapping style other than In line with text:

Examples. Enough words! Here are some examples that show these alignment options in action. These examples are pretty contrived, but they should give you an idea of the effects of each option.

Given the following buttons on a worksheet:

Align Lefts rearranges the controls as follows:

Align Centers rearranges the controls as follows:

And Align Rights rearranges the controls as follows:

Given the following buttons on a worksheet:

Align Tops rearranges the controls as follows:

Align Middles rearranges the controls as follows:

And Align Bottoms rearranges the controls as follows:

Given the following buttons on a worksheet:

Make Horizontal Spacing Equal rearranges the controls as follows:

Finally, given the following buttons on a worksheet:

Make Vertical Spacing Equal rearranges the controls as follows:

I hope these options come in handy then next time you are adding controls to a document or worksheet in VSTO.

-------------------------------------------------

McLean Schofield, Programming Writer