Microsoft Access Team Blog : Ribbon

Access 2010 Create ribbon

Clint Covington — Wed, 18 Nov 2009 05:31:20 GMT

Web databases introduced a few ribbon design challenges, particularly how to present client and web create options? We wanted to make sure that people creating client objects are just as successful as web objects.

When you create a new database from scratch, you have two options: either to open a blank database or a blank Web database.

Creating a new blank Web database opens a new database that allows you to create both Web and Client objects. Client objects have the full designers and ability to include VBA whereas the Web object designers enable you to build tables, queries, forms, reports and macros that can run on the Web and take advantage of the functionalities of Access Services. The Create ribbon makes it easy to create Web objects by selecting any of the top level options. Client objects can be created by selecting the options in the Client Forms, Client Reports and Client Objects dropdowns.

Creating a new blank database opens a new database that has the full designers. Any form, report, query or macro you create in this database cannot run on the Web. This Create ribbon is below and gives all the Client objects you can create.

You can still publish the database to Access Services. You do this by going to the File tab, going to the Save & Publish tab and selecting the Publish to Access Services option. Once the database passes compatibility checker and publishes, you can create Web objects to bring parts of your database to the Web. At this point, the ribbon changes to the Web database ribbon that optimizes entry points to create Web objects.

There will be a few changes coming after Beta 2… For book authors interested in how the Create ribbon will look when we ship Access 2010, you can reference the ribbon below.

RTM Web Database:

RTM Client Database:

Enjoy!

Using the ShowToolbar Method to Hide the Ribbon

Mike Stowe — Fri, 16 Oct 2009 21:31:29 GMT

Today’s guest blogger is Edwin Blancovitch. Edwin is president of Advanced Developers.net, creators of Easy Payroll, a software package to manage your human resources, payroll, scheduling, time and attendance needs.

I have been using the ribbon for the last two years and I like it so much, however there was a situation where I wanted to hide the ribbon. I used the Minimize the Ribbon command to hide it, but there was still some space being used by the Office button and the ribbon tabs.

After some experimentation and some research I found that I could use the ShowToolbar method to hide the ribbon. The following line of code makes the ribbon disappear completely, and allows you to see the application like in Office 2003, without the command bars.

DoCmd.ShowToolbar "Ribbon", acToolbarNo

That will make the ribbon disappear completely, and allow you to see the application like in Office 2003, without the command bars.

To display the ribbon again, use this code:

DoCmd.ShowToolbar "Ribbon", acToolbarYes

I wrote an article a long time ago for creating context command bars with VBA code, now it will be great to experiment by creating new command bars that go in the top menu. You can use context command bars in your forms, and make it work the way you wanted.

Simplifying Ribbon Modification at Runtime

accblog — Tue, 28 Apr 2009 00:27:23 GMT

Access MVP Albert Kallal has developed a Ribbon class object that you can use to simplify modifying Ribbon commands at runtime.

The office ribbon is an amazing new interface.

The problem with the ribbon is that takes a lot of code to change the ribbon at runtime.

Solution: With my ribbon class you can enable, hide, change label text, or pictures of a button with great ease and very little code.

This ribbon class allows you to use the simple "old style" syntax to enable, hide, or change the text of a button.

e.g.:

meRib("Button1").enabled = true

meRib("Button1").label = "this is the new text" & _

" for button1 on the ribbon"

meRib("Button1").picture = "HappyFace.png"

The entire article, along with a sample implementation of the class, is available here.

Review of ribbon design tool

Clint Covington — Fri, 27 Mar 2009 07:42:06 GMT

Access MVP Garry Robinson and editor of vb123.com recently wrote a nice review article on IBDE Ribbon Creator. You all should find it enlightening.

http://www.databasejournal.com/features/msaccess/article.php/3803996/Making-Your-Own-Access-2007-Ribbon.htm

Built-in Tab Names in Access Ribbons

robcooper — Wed, 10 Dec 2008 08:16:04 GMT

If you've tried to create a Ribbon customization that included one of the built-in controls in Access you've probably seen that you can use the Customize page in the Access Options dialog to get the names of groups and controls. You can also download the entire list of controls from the Microsoft web site. Unfortunately, the dialog does not include the list of built-in tabs.

For simplicity, here is the list of built-in tabs taken from this list:

TabPrintPreviewAccess
TabHomeAccess
TabCreate
TabExternalData
TabDatabaseTools
TabSourceControl
TabAddIns
TabFormToolsFormatting
TabControlLayout
TabFormToolsDesign
TabFormToolsLayout
TabReportToolsFormatting
TabReportToolsLayout
TabReportToolsPageSetupLayout
TabReportToolsDesign
TabReportToolsAlignment
TabReportToolsPageSetupDesign
TabRelationshipToolsDesign
TabQueryToolsDesign
TabMacroToolsDesign
TabPivotTableDesign
TabPivotChartDesign
TabTableToolsDatasheet
TabTableToolsDesignAccess
TabAdpFunctionAndViewToolsDesign
TabAdpStoredProcedureToolsDesign
TabAdpSqlStatementDesign
TabAdpDiagramDesign

Tell me about how you are extending the Ribbon

Clint Covington — Thu, 03 Apr 2008 19:02:29 GMT

I'm thinking about putting together a blog post that shows what the community has done with ribbon extensibility. From my conversations with lots of developers people are still trying to wrap their heads around the new user model It seems that having a few examples might stimulate some ideas.

This will also be helpful as we think about the ribbon in Office 14.

If you want me to consider your app as one of the featured apps email my spam account a brief description with a few screen shots.

New update for Ribbon Creator

Clint Covington — Thu, 27 Mar 2008 08:01:35 GMT

Avenius Gunter's Ribbon Creator just got better. Earlier this month he released version 1.1016 with a number of changes:

New Features:

Callback "getVisible" integrated in Ribbon XML.

Callback "getEnabled" integrated in Ribbon XML.

Tab Finish: Option to disable the Help Button on the ribbon.

Tab Finish: Open the selected Database.

Tab Finish: Option to replace an existing modul "basCallbacks" in a database.

ButtonGroups

ButtonGroup Editor for

Button

Togglebuttons

Control idMsos for Buttons (Only Access).

Control idMsos for ToogleButtons (Only Access).

Tag "RibbonName" for Ribbon Controls.

Modifications:

"basRibbonCallbacks" has been moved to "%Appdata%IDBE AveniusIDBE Ribbon Creator".

The small images were updated (2.326 images total now).

Number of "Recent Documents" increased to five.

BugFix: Error related to idMso controls fixed.

BugFix: The "&" sign will be properly displayed on a ribbon.

BugFix: related to basRibbonCallbacks - Word/ Excel fixed (ID DD).

Modul "basGDIPlus" in Word / Excel removed.

Modul "basRibbonCallbacks" adapted.

Online help enhanced and updated.

... and many more.

Please note, I haven't personally used Ribbon Creator and this post is not an official endorsement. From what I have read it does look like a useful tool.

The story of the Office Ribbon

Clint Covington — Thu, 13 Mar 2008 21:53:59 GMT

Some of you may have already seen this posted in Jensen’s blog. Jensen is the GPM of the Office User Experience team and was the lead for the implementation of the Ribbon in Office 2007.

Last week at the MIX conference in Las Vegas, Jensen presented “The Story of the Ribbon”. It’s a chance to get a glimpse of how much design iteration was taking place and some of the good and bad ideas that led to what we have today.

Links to the talk are posted here in Jensen’s blog: http://blogs.msdn.com/jensenh/archive/2008/03/12/the-story-of-the-ribbon.aspx

Maybe in the future I can put together the story of the Access redesign... In the mean time I highly recommend watching the video--great stuff.

New Ribbon Reference: RibbonX for Dummies

Zac Woodall — Sun, 06 Jan 2008 05:12:47 GMT

Those of you out there building custom Ribbon UI for Access/Office might be interested to know that the Dummies folks have recently released a guide for building Ribbon UI titled (as you might expect) "RibbonX for Dummies". The book is a general guide to building Ribbon XML, and it does include a section specifically on Access 2007.

Access Ribbon Customizer

Zac Woodall — Thu, 06 Dec 2007 02:05:00 GMT

One of our Access support leads, Claton Hendricks, has put together a tool he calls Access Ribbon Customizer for Access developers who need to build custom ribbons. This tool is slightly reminiscent of (though not exactly the same as) the built-in command bar customization in Access 2003. It has a visual picker which allows you to see what commands are available and use them to build a ribbon on the fly, cool stuff.

Thank you Claton for your contribution to the community!

BTW: this is not to be confused with Patrick Schmid's Ribbon Customizer which we've previously blogged about, which is also a very cool tool.

UPDATE: By the way, Claton's tool is still in testing. He's actively working on improving the quality and taking other feedback. Please feel free to contact him through his page to send yours. Also, Tony D'Ambra has a tool called the Custom RibbonX Reviewer for Access 2007 which is currently at the beta 2 stage. Thank you Tony for the pointer! It is awesome to see so many members of the community stepping in here to try and address the need for a graphical ribbon building tool!

If anyone else has Ribbon related tools that they would like to send a pointer to, please respond in the comments for this post. I'm going to be putting together a page for Access developer tools and other resources like this, and I'll be sure you get listed.

Ribbon Customization - Repurposing Commands

robcooper — Thu, 11 Oct 2007 01:45:00 GMT

Sue and I were talking the other day about Ribbon customizations with regard to some training materials that she is preparing for our support engineers. Along the way I mentioned command repurposing and how you could do some pretty cool stuff with it in Access applications. She suggested that this might make a good blog post and I think she's right.

I've been working on an application to track the work that I do throughout the year, and thought I would add a database password to encrypt the database. Since Access has this command built in on the Ribbon, I could use the idMso attribute of a button set to SetDatabasePassword to add this command to my database. Cool - however, adding a database password requires that the database is opened exclusively, and I didn't really want to see the built-in error message with the built-in command. Enter command repurposing.

Repurposing a command refers to the ability to use a built-in command in the Ribbon, but to provide your own functionality with that command. In my scenario, I wanted Access to encrypt the database, but I want my own error message when the database is not opened exclusively. To do this is actually quite simple. In the XML for the customization, specify the command that you want to repurpose using the command element. Then, specify the control that you want to use (in this case, the SetDatabasePassword button) in a Ribbon.

<customUI xmlns="http://schemas.microsoft.com/office/2006/01/customui">
    <commands>
        <command idMso="SetDatabasePassword" onAction="OnSetPassword"/>
    </commands>
    <ribbon>
        <tabs>
            <tab id="tabTab1" label="Password">
                <group id="grpGroup1" label="Password">
                    <button idMso="SetDatabasePassword" size="large" label="Set Password"/>
                </group>
            </tab>
        </tabs>
    </ribbon>
</customUI>

Add this XML to a USysRibbons table and set the RibbonName property of the database to match the entry in the table.

The onAction callback of a repurposed command is slightly different from that of a regular control in that it allows you to indicate whether or not to cancel the default action of the built-in command. Add the following code for the OnSetPassword callback routine:

Public Sub OnSetPassword(control As IRibbonControl, ByRef CancelDefault) If (CurrentProject.Connection.Properties!Mode = 12) Then CancelDefault = False Else MsgBox "You must open the database exclusively to set the database password.", _ vbExclamation, "Cannot Set Password" CancelDefault = True End If End Sub

If the database is opened exclusively (Mode=12), we'll allow the default action to continue by setting the CancelDefault parameter to False. If the database is not opened exclusively, we'll stop the built-in action by setting it this argument to True. To try this out, click the button in the new tab that was added by the customization.

Thanks Sue for the suggestion!

Access 2003 --> Access 2007 UI Guide

Zac Woodall — Fri, 05 Oct 2007 01:38:00 GMT

The Access help team has just finished up our new interactive guide for users moving from 2003 to 2007. The guide is a flash based tutorial which allows you to select a command from the 2003 Access UI, and then see where it has moved to in the 2007 ribbon.

Ribbon Customization: Using a dynamicMenu to Show a List of Open Objects

robcooper — Fri, 28 Sep 2007 08:06:00 GMT

This is the third post in my short three-part series on ribbon customizations in Access. In the previous post, I showed how you could fill a dropdown with a list of the open forms in the database. This time, we'll fill a dynamicMenu control in a ribbon customization with a list of open objects of any type. This might be useful to let users switch between open objects in an application.

Again, we'll start with the XML for customization:

Add this customization as a record in a USysRibbons table and set the RibbonName property of the database to match the entry in the USysRibbons table.

Before I go into the details of the callbacks, there are a few things you should keep in mind about the dynamicMenu control:

Content is filled at runtime using the getContent attribute
The content of the menu is the XML for a customization which contains a menu control as the root control
The root-level menu in the customization that you create dynamically should include the XML namespace for the Ribbon
The root-level menu in the customization cannot have an id or a label

The dynamicMenu control also has this pretty cool attribute called invalidateContentOnDrop. When set to true, this causes the control to invalidate which means that the getContent callback is executed for the control. This allows you to show the most recent information in the menu. Given that, let's add the VBA for the callback. Remember that you'll need a reference to the Microsoft Office 12.0 Object Library to compile this code.

' build the list of open objects Public Sub OnGetObjectList(ctl As IRibbonControl, ByRef content) ' add menu content = "<menu xmlns=""http://schemas.microsoft.com/office/2006/01/customui"">" ' tables content = content & BuildOpenObjectList(acTable, CurrentData.AllTables) ' queries content = content & BuildOpenObjectList(acQuery, CurrentData.AllQueries) ' forms content = content & BuildOpenObjectList(acForm, CurrentProject.AllForms) ' reports content = content & BuildOpenObjectList(acReport, CurrentProject.AllReports) ' macros content = content & BuildOpenObjectList(acMacro, CurrentProject.AllMacros) ' modules content = content & BuildOpenObjectList(acModule, CurrentProject.AllModules) ' close the menu content = content & "</menu>" End Sub

You'll notice that this routine calls a helper function called BuildOpenObjectList which is used to create the necessary XML for a menu at runtime. Here's the helper function.

Private Function BuildOpenObjectList(lngType As AcObjectType, col As AllObjects) As String Dim strTemp As String Dim obj As AccessObject ' menu separator node strTemp = "<menuSeparator id=""ms|1"" title=""|1""/>" ' add the text in the menu separator Select Case lngType Case AcObjectType.acForm strTemp = Replace(strTemp, "|1", "Forms") Case AcObjectType.acMacro strTemp = Replace(strTemp, "|1", "Macros") Case AcObjectType.acModule strTemp = Replace(strTemp, "|1", "Modules") Case AcObjectType.acQuery strTemp = Replace(strTemp, "|1", "Queries") Case AcObjectType.acReport strTemp = Replace(strTemp, "|1", "Reports") Case AcObjectType.acTable strTemp = Replace(strTemp, "|1", "Tables") End Select ' add buttons for the open objects For Each obj In col If (obj.IsLoaded) Then strTemp = strTemp & _ "<button " & _ BuildAttribute("id", "btn" & CleanObjectName(obj.Name)) & " " & _ BuildAttribute("label", obj.Name) & " " & _ BuildAttribute("tag", obj.Name & "|" & obj.Type) & " " & _ BuildAttribute("onAction", "OnOpenObject") & "/>" End If Next ' return BuildOpenObjectList = strTemp End Function

Yeah, there's another helper function in there. This one is called BuildAttribute and is used to wrap a string in quotes.

Private Function BuildAttribute(strName As String, strValue As String) As String BuildAttribute = strName & "=" & Chr(34) & strValue & Chr(34) End Function

And, lastly, there's one more helper function to replace some characters that are valid in Access object names but not very XML friendly.

Private Function CleanObjectName(ByVal strName As String) As String ' clean the object name so it is more XML-friendly Const REPLACE_CHARS As String = " <>\/{}" Dim intCounter As Integer For intCounter = 1 To Len(REPLACE_CHARS) strName = Replace(strName, Mid(REPLACE_CHARS, intCounter, 1), "") Next ' return CleanObjectName = strName End Function

When you put this all together and open some objects for testing, you should have something that looks like this:

Ribbon Customization: Filling Dropdown Lists

robcooper — Wed, 26 Sep 2007 03:35:00 GMT

In the previous post, I showed you how to create a simple customization to close the currently open object. Continuing along the lines of adding object helpers to an application, we'll add two dropdown lists to a customization to work with forms. The first will list all forms in a database and the second will list the open forms in an application. Start with the XML for the customization. For readability, I've left out the button created in the previous post.

Add this customization as an entry in a USysRibbons table in the database and set the Ribbon Name property of the database.

The customization shown here defines three callback routines used by the dropdown: getItemCount, getItemLabel, and onAction. These callbacks are used to determine the number of items in a dropdown, the label for a single item, and when an item is selected respectively. We're going to write one callback to cover both controls, starting with OnGetItemCount. We'll tell the dropdown to either display the number of forms in the database using the AllForms collection, or the number of open forms using the Forms collection.

Public Sub OnGetItemCount(ctl As IRibbonControl, ByRef Count) ' set the number of items to the number of forms in the database If (ctl.ID = "ddlAllForms") Then Count = CurrentProject.AllForms.Count ' Total number of forms ElseIf (ctl.ID = "ddlOpenForms") Then Count = Forms.Count ' Number of open forms End If End Sub

Next, create the OnGetItemLabel callback:

Public Sub OnGetItemLabel(ctl As IRibbonControl, Index As Integer, ByRef Label) ' set the label If (ctl.ID = "ddlAllForms") Then Label = CurrentProject.AllForms(Index).Name ElseIf (ctl.ID = "ddlOpenForms") Then ' for open forms, use the Caption property of the form if set If (Len(Forms(Index).Caption) > 0) Then Label = Forms(Index).Caption Else Label = Forms(Index).Name End If End If End Sub

Now, add the OnSelectItem callback that is called when you choose an item in the dropdown. Here, we'll open the currently selected form.

Public Sub OnSelectItem(ctl As IRibbonControl, selectedId As String, selectedIndex As Integer) If (ctl.ID = "ddlAllForms") Then DoCmd.OpenForm CurrentProject.AllForms(selectedIndex).Name ElseIf (ctl.ID = "ddlOpenForms") Then DoCmd.OpenForm Forms(selectedIndex).Name End If End Sub

Re-open the database to try it out and open some forms. When you go to the Object Helpers tab, you should have something that looks like this:

Ribbon Customization - Closing the Currently Open Object

robcooper — Mon, 24 Sep 2007 19:45:00 GMT

In a previous post, I talked about how much I enjoy developing solutions that use the new Office Fluent Ribbon UI. Along those lines, this post is the first of three upcoming posts on some specific customizations I've used in some applications recently.

The general scenario is a ribbon customization to help users work with objects in an application. This first post is pretty straight-forward where we'll create a button to close the currently open object. Start with the XML for the customization:

Next, create the USysRibbons table in a database to store ribbon customizations if you haven't already. You can run the following SQL statement in a new query to create the table. Since this is a data definition query, the database will need to be enabled for this to work.

CREATE TABLE USysRibbons ( RibbonName Text(255) CONSTRAINT PrimaryKey PRIMARY KEY, RibbonXml MEMO );

In the USysRibbons table, add a new record and set the RibbonName field to "BlogSample1" and the RibbonXml field to the XML for the customization. Close and re-open the database and click the Object Helpers tab. You should have something that looks like this:

You'll notice that the button in the customization calls a callback in the onAction attribute called OnCloseCurrentObject. Add the following code to a new module to implement this routine. You'll need a reference to the Microsoft Office 12.0 Object Library for this code to work.

Public Sub OnCloseCurrentObject(ctl As IRibbonControl) DoCmd.Close CurrentObjectType, CurrentObjectName End Sub

We're using the CurrentObjectType and CurrentObjectName properties of the Application object to close the object that is currently open. To try this out, open a few different types of objects and click the button.