You can use XML markup to customize the Fluent UI. The following example shows the general format of an XML markup file that customizes the Fluent UI in Word 2007. Examples in the following sections use this markup.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> <ribbon> <tabs> <tab idMso="TabHome"> <group idMso="GroupFont" visible="false" /> </tab> <tab  label="My Tab"> <group  label="Sample Group"> <toggleButton  size="large"               label="Large Toggle Button"               getPressed="ThisDocument.MyToggleMacro"                /> <checkBox  label="A CheckBox"               screentip="This is a check box"                /> <editBox  getText="ThisDocument.MyTextMacro"               label="My EditBox" /> <comboBox  label="My ComboBox"               > <item  label="33455" /> <item  label="81611" /> <item  label="31561" /> </comboBox> <dialogBoxLauncher> <button  screentip="My Launcher"                  /> </dialogBoxLauncher> </group> <group  label="My Group" > <button  label="My Large Button"               size="large"  /> <button  label="My Normal Button"               size="normal"  /> </group > </tab> </tabs> </ribbon> </customUI>

This XML markup results in a modified Fluent UI, as the following figure shows.

Figure 2. Sample of Fluent UI customization in Word

This sample makes the following changes to the Fluent UI in Word 2007, in the order shown:

1. The sample declares the default namespace for the XML markup.
2. The sample hides the built-in GroupFont group that is located on the built-in Home tab.
3. The sample adds a new CustomTab tab to the right of the last built-in tab, with the label My Tab.

   Note:
   Use the id identifier attribute to create a custom item, such as a custom tab. Use the idMso identifier attribute to refer to a built-in item, such as the TabHome tab.

4. The sample adds a new SampleGroup group to the My Tab tab.
5. The sample adds a large-sized ToogleButton1 button to the My Group group. The markup specifies onAction and getPressed callbacks.
6. The sample adds a CheckBox1 check box to the My Group group with a custom screentip. It also specifies an onAction callback.
7. The sample adds an EditBox1 edit box to the My Group group and specifies an onChange callback.
8. The sample adds a Combo1 combo box to the My Group group with three items and specifies an onChange callback.
9. The sample adds a Launcher1 launcher to the My Group group with the onAction callback set.

   A launcher normally displays a custom dialog box that offers more options to the user.

10. The sample adds a new My Group group to the custom tab.
11. The sample adds a large-sized Button1 button to the My Group group and specifies getText and onAction callbacks.
12. The sample adds a normal-sized Button2 button to the My Group group and specifies an onAction callback.

The easiest way to create RibbonX markup is to use a validating XML editor. Microsoft Visual Studio 2005 provides such an editor that you can use, if you can provide the necessary schema (XSD) file. In this case, you need a current copy of customUI.xsd, which is available in several places. For example, when you install Microsoft Visual Studio 2005 Tools for the 2007 Microsoft Office System (also known as Visual Studio 2005 Tools for Office Second Edition), it adds the schema to the Visual Studio schema catalog, so the schema is available by default in a Visual Studio project. You can also find the schema at the 2007 Office System: XML Schema Reference Web site. In Visual Studio, create a new XML file, and in the Properties window, set the Schemas property to include the customUI.xsd file (or enter the schema reference in the code, as shown in the previous XML document). Then, as you enter XML content into the file, you can take advantage of Microsoft IntelliSense technology. You might also find the XML Notepad 2006 download useful; it is available from the Microsoft Download Center. This tool enables you to edit and view XML content in a tree-based format.

At the document level, the process for customizing the Fluent UI by using XML markup involves the following steps. For more information, see Adding Document-Based Add-ins to the Fluent UI later in this article. You can follow these steps, using the XML markup described in the previous section.

Note:

Although it is useful to know what is going on within the Office Open XML Formats structure, you may be able to bypass these steps. You can take advantage of the Custom Fluent UI Editor, available at OpenXMLDeveloper.org. This tool enables you to open a document, insert custom UI, and then save the document with the RibbonX markup in place. It performs for you the steps listed in this example. It also enables you to add custom icons to the customUI folder, and makes it easy to refer to these icons. You can download the Custom UI Editor from the OpenXMLDeveloper.org Custom UI Editor Tool Web page.

To customize the Fluent UI by using Office Open XML Formats files

<Relationship Type="http://schemas.microsoft.com/office/2006/    relationships/ui/extensibility" Target="/customUI/customUI.xml"      />

When you open the file in the Office application, the UI appears with your customizations. Depending on your application settings, if you use the markup from the previous section in this example, you might receive several warning messages as you open the document. Because you have not supplied the code that corresponds to the various callback procedures, you have not really created a complete custom UI yet.

1. Start Excel 2007.
2. Click the Developer tab, and then click Visual Basic.

   Note:
   If you do not see the Developer tab, you must identify yourself as a developer. To do this in your application, click the Microsoft Office Button, click Application Options, click Popular, and then select Show Developer Tab in the Ribbon. This is a global setting that identifies you as a developer in all Office applications that implement the Fluent UI.

3. In the Visual Basic Editor, double-click ThisWorkbook to open the Code window.
4. Type the following VBA function, and then click the Excel icon in the left corner of the toolbar to return to Excel.
   Visual Basic

   复制代码

   Sub MyMacro(ByVal control as IRibbonControl)     MsgBox("Hello World")  End Sub

5. Save the document as a macro-enabled workbook with the file name extension .xlsm.

   Note:
   If you save the document as a standard .xlsx document, you will not be able to run the macro code. When you save the document, you must explicitly select the Save As menu option, and then select Excel Macro-Enabled Workbook (*.xlsm).

6. Exit Excel.

1. Create a folder on your desktop named customUI.
2. Create a new text file, add the following XML, and then save the file as customUI.XML in the customUI folder on your desktop.
   Xml

   复制代码

   <customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> <ribbon startFromScratch="true"> <tabs> <tab  label="My Tab"> <group  label="My Group"> <button  imageMso="HappyFace" size="large"               label="Large Button"                /> </group> </tab> </tabs> </ribbon> </customUI>

1. In Windows Explorer, find the macro-enabled file you created. Rename the file by adding the .zip extension.
2. In Windows Explorer, double-click the file to open it.
3. Add the customization file to the container by dragging the customUI folder from the desktop to the compressed folder and clicking the Add button when prompted.
4. Drag the _rels folder to the desktop.
5. Open the new folder, and then open the .rels file in a text editor.
6. Add the following text between the last <Relationship> element and the </Relationships> element, and then save and close the file.
   Xml

   复制代码

   <Relationship  Type="http://schemas.microsoft.com/office/2006/relationships/ui/extensibility"   Target="customUI/customUI.xml" />

7. Drag the .rels file from the desktop to the _rels folder in the compressed folder, replacing the existing .rels file.
8. Remove the .zip extension from the container file name.
9. Open the macro-enabled file in Excel 2007. The custom UI replaces the built-in Fluent UI.

   Note:
   Depending on your security settings, you might see a security warning telling you that macros have been disabled. If you do, click the Options button that appears next to the warning, select Enable this content, and then click OK.

10. Click Large Button. Clicking the button triggers the onAction callback, which calls the macro in the workbook, which displays the “Hello World” message.

1. Create a COM add-in project.

   The add-in you create must implement the Extensibility.IDTExtensibility2 interface and the IRibbonExtensibility interface (found in the Microsoft.Office.Core namespace).

2. Build the add-in and Setup project and then install the project.
3. Start the Office application.

When the add-in loads, the IDTExtensibility2::OnConnection event is triggered, which initializes the add-in, just as in previous versions of Office.

Next, Office calls either the QueryInterface method (for unmanaged add-ins) or the QueryService method (for managed add-ins), which determines whether the add-in implements the IRibbonExtensibility interface. If it does, Office calls the IRibbonExtensibility::GetCustomUI method, which returns the XML markup (from an XML customization file or from XML markup embedded in the procedure), and then Office loads the customized Fluent UI into the application. Finally, the customized UI is ready for the user.

Warning:
Because of the internal architecture of the Ribbon callback mechanism, it is important that you perform no initialization within the GetCustomUI method other than preparing and returning the XML markup for the Ribbon. Specifically, do not display dialog boxes or message windows from within this callback method.

Each control specified in the XML markup exposes its functionality by calls to callback procedures. For example, the XML markup for a button control can specify an onAction attribute that points to a procedure that is executed when the user clicks the button. In most cases, the callback procedure exposes an IRibbonControl interface that identifies the control. The callback might pass other arguments as well, such as a Boolean object that specifies the state of a toggle button as pressed or not pressed. The IRibbonControl interface implements three properties: the Context object, the Id object, and the Tag property. The Context object is the active window that contains the Ribbon that triggers the callback. The Id object is the string identifier of the custom control specified in the markup. The Tag property is a non-unique property that you can optionally specify in the markup.

1. Create a table named USysRibbons with columns as described earlier. Add rows for each different Ribbon you want to make available.
2. Close and then reload the database.
3. Click the Microsoft Office Button, and then click Access Options.
4. Click the Current Database option and then, in the Ribbon and Toolbar Options section, click the Ribbon Name drop-down list and click one of the Ribbons.

To remove an existing customization (so that your database uses the default Fluent UI), delete the existing Ribbon name from the Ribbon Name list, and leave an empty value for the name of the Ribbon.

The following procedure describes, in a generalized manner, how to add form-level customizations or report-level customizations in Access.

1. Follow the process described previously to make the customized Ribbon available to the application, by adding the USysRibbons table.
2. Open the form or report in Design view.
3. On the Design tab, click Property Sheet.
4. In the Property window, on the Other tab, click the Ribbon Name drop-down list, and then click one of the Ribbons.

5. Save, close, and then re-open the form or report. The UI you selected is displayed.

   Note:
   The tabs displayed in the Fluent UI are additive. That is, unless you specifically hide the tabs or set the Start from Scratch attribute to True, the tabs displayed by a form or report’s UI appear in addition to the existing tabs.

To explore this process further, work through the following examples.

The first part of the example sets an option that reports any errors that exist when you load custom UI (although you are performing these steps in Access, you can perform similar steps in other applications).

1. Start Access. Open an existing database, or create a new database.
2. Click the Microsoft Office Button, click Access Options, and then click the Advanced tab.
3. In the General section, select the option Show add-in user interface errors (this option might be in a different location, in different applications).
4. Click OK to close the Access Options dialog box.

   Next, create a table that contains your customization XML markup.

5. With a database open in Access, right-click the Navigation pane. Point to Navigation Options, and then click Show System Objects. (You cannot view the USysRibbons table in the Navigation pane unless this option is set.) Click OK to dismiss the dialog box. The Access system tables appear in the Navigation pane.
6. On the Create tab, click Table Design.
7. Add the following fields to the table.
   

   Table 2. USysRibbons table field definitions

   Field Name	Type
   ID	AutoNumber
   RibbonName	Text
   RibbonXml	Memo

8. Select the ID field. On the Design tab, select Primary Key.
9. Click the Microsoft Office Button, and then click Save. Name the new table USysRibbons.
10. Right-click the USysRibbons tab, and then click Datasheet View.
11. Add the following data to the fields you created.
    

    Table 3. USysRibbons table da

    ta

    Field Name	Value
    ID	(AutoNumber)
    RibbonName	HideData
    RibbonXml	Xml 复制代码 <customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> <ribbon startFromScratch="false"> <tabs> <tab idMso="TabCreate" visible="false" /> <tab label="A Custom Tab" visible="true"> <group label="A Custom Group"> <control idMso="Paste" label="Built-in Paste" enabled="true"/> </group> </tab> </tabs> </ribbon> </customUI>

    This markup sets the startfromScratch attribute to False, and then hides the built-in Create tab. Next, it creates a custom tab and a custom group, and adds the built-in Paste control to the group.

12. Close the table.
13. Close and then re-open the database.
14. Click the Microsoft Office Button, and then click Access Options.
15. Click the Current Database tab, and scroll down until you find the Ribbon and Toolbar Options section.
16. In the Ribbon Name drop-down list, select HideData. Click OK to dismiss the dialog box.
17. Close and re-open the database.

    The Edit group is no longer displayed, and the Fluent UI includes the A Custom Tab tab, which contains the A Custom Group group with the Built-in Paste button.

    Figure 3. The Access application-level UI

    

18. To clean up, repeat the previous few steps to display the Access Options dialog box. Delete the contents of the Ribbon Name option, so that Access displays its default Fluent UI after you close and re-open the database.

    Note:
    You can also use a Ribbon from the USysRibbons table to supply the UI for a specific form or report. To do this, open the form or report in Design or Layout mode, and set the form’s RibbonName property to the name of the Ribbon you want to use. You must select the form itself, rather than any control or section on the form, before you can set this property.

1. Load the database that you worked with in the previous section into Access 2007. If your database does not already include more than one form, create a few forms, and add a control or two to each form.

2. On the Create tab, in the Other group, click the drop-down list of the Macro button, and then click Module.
3. In the Visual Basic Editor, on the View menu, click Properties Window.
4. In the Properties window, in the Name property box, change the name of the module to RibbonLoader.
5. In the code window, insert the following code. Even though this method does not return a value, it must be a function—otherwise, you cannot call it from an Access macro.
   Visual Basic

   复制代码

   Function CreateFormButtons()    Dim xml As String    xml = _     "<customUI xmlns=""http://schemas.microsoft.com/" & _     "office/2006/01/customui"">" & vbCrLf & _     "  <ribbon startFromScratch=""false"">" & vbCrLf & _     "    <tabs>" & vbCrLf & _     "      <tab >"DemoTab"" label=""LoadCustomUI Demo"">" & _       vbCrLf & _     "        <group >"loadFormsGroup"" label=""Load Forms"">" & _       vbCrLf & _     "{0}" & vbCrLf & _     "        </group>" & vbCrLf & _     "      </tab>" & vbCrLf & _     "    </tabs>" & vbCrLf & _     "  </ribbon>" & vbCrLf & _     "</customUI>" Dim template As String    template = "<button >"load{0}Button"" " & _     "label=""Load {0}"" >"HandleOnAction"" " & _     "tag=""{0}""/>" & vbCrLf        Dim formContent As String Dim frm As AccessObject    For Each frm In CurrentProject.AllForms      formContent = formContent & _       Replace(template, "{0}", frm.Name)    Next frm        xml = Replace(xml, "{0}", formContent)    Debug.Print xml    On Error Resume Next ' If you call this co

   de from the AutoExec macro, ‘ the only way it can fail is if you have a ‘ customization with the same name in the ‘ USysRibbons table. Application.LoadCustomUI “FormNames”, xml End Function

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui"> <ribbon startFromScratch="false"> <tabs> <tab  label="LoadCustomUI Demo"> <group  label="Load Forms"> <button  label="Load Form2"                tag="Form2"/> <button  label="Load Form1"                tag="Form1"/> </group> </tab> </tabs> </ribbon> </customUI>

Public Sub HandleOnAction(control As IRibbonControl)      ' Load the specified form, and set its ' RibbonName property so that it displays ' the custom UI.      DoCmd.OpenForm control.Tag      Forms(control.Tag).RibbonName = "FormNames" End Sub

Private Sub Form_Load()      CreateFormButtons      Me.RibbonName = "FormNames" End Sub