Office Development with Visual Studio : Ribbon

VSTO Performance: Delay Loading and You (Stephen Peters)

VSTO Team — Thu, 07 Jan 2010 19:04:00 GMT

There have been a couple of blog posts about delay loading VSTO addins, and with Dev10 being released soon, it’s a good time to expand on the subject a little bit.

This has been covered before, and I’ll avoid spending too much time here on topics that have already been covered. For an overview of delay loading, please read these posts.

http://blogs.msdn.com/andreww/archive/2008/07/14/demand-loading-vsto-add-ins.aspx

http://blogs.msdn.com/andreww/archive/2008/04/19/delay-loading-the-clr-in-office-add-ins.aspx

There are many reasons why you would want to delay load your addin, the most important of which is for performance – loading the CLR can easily double the amount of time that it takes to load an Office application. If your addin is only used occasionally, your users will appreciate the faster load times.

One important improvement that has gone into Dev10 is that you no longer need to manually change the LoadBehavior in the registry for your addin to make it DelayLoad. If you go into project properties of your addin, click on the “Publish” tab, and go into “Options…”, you can adjust the Add-in Load Behavior under “Office Settings”.

For more information about publishing, please see Publishing VSTO Solutions.

Now, once you have done this, your addin will not be loaded until Office decides that it needs to load the addin. This can happen a number of ways, but the most common is that a user action (like clicking on a ribbon button) calls into the addin, and causes the addin to be loaded.

One important note is that any custom “get” handler (getEnabled, getVisible, getLabel) will not trigger the loading of your addin. The first time that your addin is loaded, Office will call the handler and cache the response given, and use that response as the default. It will then call the handler again to use in the current session. This is important because if the control is disabled initially, and then later enabled via a call to RibbonUI.Invalidate or RibbonUI.InvalidateControl, it will only invalidate this second value and not the first value.

Consider the following example where a database connection is necessary for the addin to function:

XML:

<group id="MyGroup"
       label="Database controls"  >
    <button id="Button1" label="Get Data" onAction="GetDataClick" getEnabled="GetEnabled" />
</group>

Callbacks in Ribbon Class:

#region Ribbon Callbacks

Boolean dbEnabled = false; 
public void Ribbon_Load(Office.IRibbonUI ribbonUI)
{
    this.ribbon = ribbonUI;

    //[aDeveloper] moving the database connection to another thread
    Thread databaseConnectionThread = 
        new Thread(delegate()
        { 
            Thread.Sleep(500); // todo:  Actually connect
            dbEnabled = true;
            ribbon.Invalidate();
        });
    databaseConnectionThread.Start();
}

public Boolean GetEnabled(Office.IRibbonControl rc)
{
    return dbEnabled;
}

public void GetDataClick(Office.IRibbonControl rc)
{
    //pull data from the database and populate the spreadsheet with it.
}
#endregion

This can cause a chicken and egg type situation if by default none of its ribbon controls are available (Ie, they’re not enabled or visible). The next time Office is started, it will use the cached “false” response resulting in none of the controls being enabled, and the user will have no easy way to load the addin and cause the “get” handlers to be called.

The best way around this issue would be to have a control that is always enabled that calls into the addin and thus would load the addin. You can then call ribbonUI.Invalidate in the custom UI’s onLoad handler to force the Office application to call each “get” handler.

XML:

<group id="MyGroup"
       label="Database controls">
    <button id="Button0" label="Connect Database" onAction="ConnectDatabase" enabled="true" />
    <button id="Button1" label="Get Data" onAction="GetDataClick" getEnabled="GetEnabled" />
</group>

Callbacks in Ribbon Class:

#region Ribbon Callbacks

Boolean dbEnabled = false; 
public void Ribbon_Load(Office.IRibbonUI ribbonUI)
{
    this.ribbon = ribbonUI;
}

public Boolean GetEnabled(Office.IRibbonControl rc)
{
    return dbEnabled;
}

public void GetDataClick(Office.IRibbonControl rc)
{
    //pull data from the database and populate the spreadsheet with it.
}

public void ConnectDatabase(Office.IRibbonControl rc)
{
    //[aDeveloper] we don't do this automatically since we don't want to connect to the database
    //             unless the user wants to - there's a chance for a hang if the database isn't
    //             available.
    Thread.Sleep(500); // todo:  Actually connect
    dbEnabled = true;
    ribbon.Invalidate();
}
#endregion

Another trick is to have the handler return “true” the first time that it’s called, so that Office caches the “true” response as the default, and the control is enabled. If you do this, you’ll want to make sure that your click handlers can handle the case where the button should be disabled.

(n.b.: This example is a little bit contrived, but will illustrate what you need to do if your application would be best served by this behavior.)

In this case, the “Get Data” button will be enabled by default. The first click will generate the message box since by the time that GetDataClick is called, the addin hasn’t had time to ‘connect’, and the button will remain disabled until the connection is done.

XML:

<group id="MyGroup"
       label="Database controls">
    <button id="Button1" label="Get Data" onAction="GetDataClick" getEnabled="GetEnabled" />
</group>

Callbacks in Ribbon Class:

#region Ribbon Callbacks
Boolean dbEnabled = false;
Boolean firstCall = true;
public void Ribbon_Load(Office.IRibbonUI ribbonUI)
{
    this.ribbon = ribbonUI;
    //[aDeveloper] moving the database connection to another thread so that we don't hang office
    Thread databaseConnectionThread = 
        new Thread(delegate()
        { 
            Thread.Sleep(5000); // todo:  Actually connect
            dbEnabled = true;
            ribbon.Invalidate();
        });
    databaseConnectionThread.Start();
}

public Boolean GetEnabled(Office.IRibbonControl rc)
{
    if (true == firstCall)
    {
        firstCall = false;
        return true;
    }
    return dbEnabled;
}

public void GetDataClick(Office.IRibbonControl rc)
{
    if (false == dbEnabled)
    {
        System.Windows.Forms.MessageBox.Show("Could not connect to database");
                
        //Disable this button until we get the connection up.
        firstCall = false;
        ribbon.Invalidate();
        return;
    }
    //Get the data and populate the spreadsheet
}
#endregion

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)

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.

Making a Custom Ribbon Appear Only for a Custom Outlook Form (Norm Estabrook)

VSTO Team — Wed, 28 Jan 2009 23:09:46 GMT

Many of you have posted questions to the VSTO Forum about how to make custom tabs, groups and controls appear only in cases where the user opens a custom form in Outlook.

The reason why that is difficult to accomplish is because there is no way to specify the names of custom forms in the Ribbon Designer. You can only specify inspector window types.

So if I set the RibbonType property of the Ribbon to “Microsoft.Outlook.Mail.Compose”, then the Ribbon controls appear for all new mail items including items that I create by using a custom mail form. So how can I make sure that the Ribbon controls only appear in my custom mail form?

One possible workaround is to show and hide controls based on the message class of an Outlook form. It seemed to work for me and here is how I did it.

In the Ribbon designer, set the Visible property of your custom controls to false. At this point, those controls will not appear in any Outlook form custom or otherwise.

Next, add a property to the ThisAddIn class that stores the name of a custom message class as follows:

private string strMessageClass = "";
public string MessageClass
{
    get
    {
        return strMessageClass;
    }
    set
    {
        strMessageClass = value;
    }
}

Create an event handler for the NewInspector event. This event is raised every time a new Outlook inspector is open. The item that opens in the inspector has a message class name. For example, if you open a standard mail item, the message class name of the item is “IPM.Note”. A custom form based on a standard email form might have the message class name “IPM.Note.MyCustomForm”.

In the event handler, set your custom string property to the message class name of the open item. Here is an example:

private Outlook.Inspectors inspectors;
private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
    inspectors = this.Application.Inspectors;
    inspectors.NewInspector +=
        new Microsoft.Office.Interop.Outlook.InspectorsEvents_NewInspectorEventHandler
            (Inspectors_NewInspector);

}

void Inspectors_NewInspector(Microsoft.Office.Interop.Outlook.Inspector Inspector)
{
    Outlook.MailItem tmpMailItem = (Outlook.MailItem)Inspector.CurrentItem;
    if (tmpMailItem != null)
        MessageClass = tmpMailItem.MessageClass;
}

In the load event of your Ribbon class, check your custom string property to determine the message class of the item that is attempting to load your custom Ribbon. If the name matches the name of your custom message class, you can show the controls on your custom Ribbon. Here is an example:

private void Ribbon1_Load(object sender, RibbonUIEventArgs e)
{
    if (Globals.ThisAddIn.MessageClass == "IPM.Note.Norm")
    {
        group1.Visible = true;
        Globals.ThisAddIn.MessageClass = "";
    }
    

}

Setting the Width of a Drop Down, Combo Box, or Edit Box in the Ribbon Designer (Norm Estabrook)

VSTO Team — Fri, 19 Dec 2008 21:56:00 GMT

Recently, a developer posted a question to the VSTO forum asking us how to set the width of a drop down control by using the Ribbon Designer (http://social.msdn.microsoft.com/Forums/en-US/vsto/thread/8965ae5a-9c02-4aec-9178-675650b7044e/).

As this person experienced, if you do not set the width of the control, the text that appears in a drop down, combo box, or edit box will truncate. For example, the string “I love Visual Studio Tools for Office!” is truncated in the following drop down:

So how do you fix this? The magic lies in the SizeString property. However, the use of this property is not so obvious. Instead of setting this property to a number such as 20 for 20 characters of space, you must type an actual character for each character’s worth of space you want to allocate for the text width.

For example, to make enough space for the string “I love Visual Studio Tools for Office!”, set the SizeString property of the drop down to “xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx” or “jlkjlkjlkjlkjdlslaledfoplklksjjklsfdf” etc.

You can also decrease the size of the text area to show fewer characters than appear by default. For example, just set SizeString to “xx” if you want only two characters to appear.

Norm E.

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

Activating a Custom Tab on the Ribbon When a Document Is Opened (Harry Miller)

VSTO Team — Wed, 13 Aug 2008 03:36:00 GMT

A lot of people would like to do this. It makes sense that a developer would want to select the custom tab automatically, if the controls that are most useful for the current document are all on that tab. This video goes in-depth about this programming question.

OK, not really. The video just says you can't do it, because the Ribbon is designed with the idea of leaving the user in control of the UI -- no surprise selection changes. But you should watch the video anyway. It's really short, and, you know, kinda funny.

Related resources

Forum: Is there a way to activate a certain tab on the Ribbon?

Duration: 1 minute, 8 seconds

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

Share a Ribbon Customization between Office Applications (Norm Estabrook)

VSTO Team — Mon, 10 Mar 2008 23:01:00 GMT

We have received feedback from several folks that they would like design one Ribbon by using the Ribbon visual designer, and then re-use that same Ribbon in more than one Office application. This approach makes sense. If my custom tab looks the same for each application, I really don’t want to create the same Ribbon in four separate Office projects.

So I poked around to see if this was possible. I caught up with one of developers who created the VSTO Ribbon designer and he showed me exactly how to do it.

First, add a Ribbon to a VSTO project. Then, copy the Ribbon code files to a class library project. Finally, add a reference to the class library assembly from within any VSTO project and voila. Well, it’s a tad more challenging. Here are all the detailed steps.

Create the Ribbon

1. Create a 2007 Excel, Outlook, PowerPoint, or Word project in Visual Studio. For the purpose of these steps, create a C# project and name the project RibbonStarterProject.

2. Add a Ribbon (Visual Designer) item to the project. For the purpose of these steps, accept the default name “Ribbon1”.

3. Save and close the project.

Create a Class Library Project

1. Create a new class library project in Visual Studio. For the purpose of these steps, name the project SharedRibbonLibrary.

2. Add a project reference to the Microsoft.Office.Tools.Common.v9.0 assembly.

3. On the Project Menu in Visual Studio, click Add Existing Item.

4. In the Add Existing Item dialog box, browse to the “RibbonStarterProject” project directory, select the Ribbon.cs file, and click Add.

Ribbon1.cs is copied to the project directory and appears beneath the project node in Solution Explorer.

5. Double-click Ribbon1.cs.

The Ribbon designer appears.

6. From the Office Ribbon Controls tab of the Toolbox, drag a button onto group1.

7. Click button1 to select it.

8. In the Properties window, set Modifiers to Public.

Note: By default, controls that you add to the Ribbon are Internal. That makes them only accessible to code inside the same assembly. However, when you access these controls, you will be accessing them through an assembly reference. Therefore, to reach them from code, you must make them public. More on this soon.

9. Right-click the Ribbon designer, and then click Properties.

10. In the Properties window, click the RibbonType property, and then select the Ribbon ID’s of the applications or Outlook Inspector windows in which you want the Ribbon to appear. For more information about this property, see the MSDN reference topic for the RibbonType property.

11. In Solution Explorer, right-click Ribbon1.cs, and then click View Code.

12. Change the namespace of the class to “SharedRibbonLibrary”.

13. Repeat this step for the Ribbon1.designer.cs file.

14. Compile and save the SharedRibbonLibrary project. You can now use the resulting assembly in any VSTO project that supports the Ribbon.

Consume the Ribbon Customization

1. Create 2007 Excel, Outlook, PowerPoint, or Word project.

2. Add a reference to the SharedRibbonLibrary assembly.

3. Add the following code to the ThisAddin, ThisWorkbook, or ThisDocument class of your project. This code overrides the CreateRibbonExtensibilityObject method and returns the Ribbon to the Office application.

protected override Microsoft.Office.Core.IRibbonExtensibility

CreateRibbonExtensibilityObject()

{

return new Microsoft.Office.Tools.Ribbon.RibbonManager(

new Microsoft.Office.Tools.Ribbon.OfficeRibbon[] { new

SharedRibbonLibrary.Ribbon1() });

}

4. Add a new class to the project. Accept the default name “Class1.cs”.

5. Replace the code in the Class1 file with the following:

partial class ThisRibbonCollection : Microsoft.Office.Tools.Ribbon.RibbonReadOnlyCollection

{

internal SharedRibbonLibrary.Ribbon1 Ribbon1

{

get { return this.GetRibbon<SharedRibbonLibrary.Ribbon1>(); }

}

Ok – You are done! You can now access the Ribbon and the button that you added to the Ribbon in your code. Lets try by handling an event in the consuming project.

Handle the Button Click Event

1. Add the following code to the startup event handler of project.

Globals.Ribbons.Ribbon1.button1.Click += new EventHandler<Microsoft.Office.Tools.Ribbon.RibbonControlEventArgs>(button1_Click);

2. Add the following event handler to your project:

void button1_Click(object sender,

Microsoft.Office.Tools.Ribbon.RibbonControlEventArgs e)

{

System.Windows.Forms.MessageBox.Show("I can handle events!");

}

3. Run the project.

4. When the Office application opens, click the Add-Ins tab, and then click your button.

A message that says “I can handle events!” appears.

- Norm Estabrook

Programming Writer for BizApps User Education

New Power Tools - Ribbon IDs Tool Window (Kemp Brown)

VSTO Team — Thu, 06 Mar 2008 02:57:00 GMT

The Visual Studio 2008 Tools for Office team just released a cool suite of productivity apps for VS Office development called the VSTO Power Tools. One of the tools included is the Ribbon IDs Tool Window, an add-in tool window for VS that lets you browse the MSO icons that come with Office. You can use these icons to spiff up your custom Ribbon controls. All you need to do is click an icon in the Ribbon IDs Tool Window to obtain its ID, and then plug the value into the control's OfficeImageID property.

I've recorded a short video that demonstrates the tool window and how to use it to customize some Ribbon controls:

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

There are a couple of additional items not in the video that bear mentioning:

You can also use this tool with XML-based ribbons, even dragging-and-dropping the icon value into the XML.
You are not limited to using only MSO images in your controls, although that this is the purpose of this tool.

Here are links to the Help topics I mentioned at the end of the video:

Try it out and let us know what you think!

- Kemp Brown
Programming Writer for BizApps User Education