Microsoft Access Team Blog

Office 2010 newsgroups

Clint Covington — Fri, 04 Dec 2009 20:21:00 GMT

Here is a link to Office 2010 newsgroups. The team will try to monitor and provide answers to questions in the Access newsgroup.

Access 15 and SQL Server

Clint Covington — Fri, 04 Dec 2009 00:28:38 GMT

Today’s guest writer is Greg Lindhorst the person looking into how to improve Access and SQL Server for Access 15.

Hello everyone! As Office 2010 nears shipping, we are starting to plan Office 15. One area that we are considering improving is our SQL Server support. Based on what I've heard from the community, that would be most welcome. Note that we are very early in planning, and considering many possible areas of investment, I unfortunately can't commit to any actual improvements at this time.

This is where you come in… I need your help to understand the need for improvements and make the case for improved SQL support. If you could take a few moments, please jot down your thoughts on the following:

What is unique about SQL Server scenarios? Why do you turn to SQL Server instead of using a local Access database? This is a bit of a rhetorical question, obviously there are many features that SQL offers that local Access databases do not, including better security, multi-user support, scalability, and manageability. And perhaps those are the main reasons. But are there other characteristics of a SQL Server solution that we should understand?
How often do create a ADP + SQL solution vs. a Access frontend linked to SQL? In other words, how often is it about something like an ADP, and how often do you work with linked SQL tables? Is one of these more important for us to improve than the other?
What existing features in Access, that are targeted at SQL Server, are falling short of your needs?
What features in SQL Server would you like to take advantage of, but currently can't because they are not exposed in Access?
What new features would you like to see in Access that would make development for SQL Server faster, more efficient, or more manageable? And any other data you would like to contribute to this subject is most welcome.

You can post responses here, send me send email through the blog.

Thanks much!

The Access Show: Managing Access Databases with SharePoint

Clint Covington — Thu, 03 Dec 2009 04:45:29 GMT

This is the third episode of The Access Show. Steve Greenberg recently gave a great talk (rated in the top 7 of all sessions) at the SharePoint Developers Conference about how Access 2010 and Access Services enable organizations to provide better oversight of Access development while empowering users. In episode three Steve and Clint walks you through the key points of this hit session.

Subscribe to The Access Show: RSS, iPod/MP4, WMV (high quality), Zune, MP3

Publish to SharePoint (part 2)

Clint Covington — Wed, 02 Dec 2009 00:25:53 GMT

Today’s guest writer is Ric Lewis—the PM in charge of publishing to SharePoint.

In our last post about publish, we covered the basics of how to publish your Access database to a SharePoint server. In this post, we’ll look at how to troubleshoot publish issues and maintain your published database.

Errors

When you try to publish, there are a few things that may go wrong. There are three places where you may be notified of these errors:

Compatibility Checker
Move to SharePoint
Application Log

Compatibility Checker

Access Services v1 does not support all the rich controls and properties that the Access client supports. While we’ve tweaked the designers to attempt to keep users from doing things that are not web legal, some issues may slip through. To prevent users from publishing things that are not supported by the server, we created a Web Compatibility Checker. This tool checks the web compatibility of the tables and web objects.

The Web Compatibility Checker acts as a gatekeeper, always checking before publish or import of objects to make sure that they are web-safe.

You can run the compat checker manually:

Or it will be run for you during sync/publish:

Move To SharePoint Issues

If your application is valid, but the publish operation failed while interacting with SharePoint, the errors will be logged in this table. Issues here include network issues, SharePoint errors, and exceptions from incorrectly formatted data. They are logged in the “Move to SharePoint Issues” table.

Application Log

Publish is an asynchronous operation. The client sends all of its information to the server, and in most cases, the server continues to process the new application even after the client is done publishing. If there are issues in the server’s processing of your application, the errors will be listed in this table as they happen.

You can look for notifications from this log from the Backstage area:

Server Side

So what’s happening when we publish a Web Database to a server to become an Access Web Application? Behind the scenes, the client outputs its web objects in standardized formats:

Tables –> SharePoint Lists
Forms –> ASPX pages that are compiled from XAML
Reports –> SQL Reporting Services’ Report Definition Language
Macros –> SharePoint Workflows
Queries –> Query AXL

After publish, the server takes these objects and compiles them together into the series of web pages and data objects which comprise an Access Web Database.

Note: The format of web objects has been documented in the Access Application Transfer Protocol Structure Specification so that third parties can write additional tools on the platform.

Maintenance

At this point, the local ACCDB on your computer is a cached version of your database. Changes made in your ACCDB will be reflected as changes in the web application and visa versa. These changes fall into two categories: data/schema changes and object changes.

Data/Schema changes

In your published database, all of your tables are linked SharePoint lists. Any data updates you make on the Access client or through the web browser change the server data immediately. When you make schema changes on the client, these schema changes are propagated immediately to the server.

Conflicting data changes will be exposed through the data conflict dialog present in Access 2007.

Object changes

All the other objects in your database (forms, reports, queries, and macros) are only changed when you choose to sync. This means you can make a batch of changes and only apply those changes when you are ready to commit the entire set.

To send your changes to the server, you must use the “Sync All” button in the Backstage. This will pull down any new changes from the server and send local changes to the server.

If changes conflict with another user’s changes, Access will bring the most recent server changes down into your application, and create a copy of the conflicting object which contains your changes.

You’ll notice that you can see the user whose changes conflict with yours.

To get your changes on the server, delete the existing object and rename your copy to the original name, or you can try to merge your changes with the changes made by the other user by hand.

We welcome your feedback and questions.

The Cartesian product: a feature, not a bug

cdowns — Mon, 30 Nov 2009 23:46:51 GMT

Today's guest blogger is Access MVP Garry Robinson, who offers up another gem from the Smart Access collection of articles at http://www.vb123.com/kb.

In this article written by Peter Vogel, you will be given an overview about what it means to write queries where tables are not joined. This is a good thing to know because SQL queries written this way can help you now in exactly the same way as it did for Peter and I working on projects in the last century.

Article by Peter Vogel from 1997

When we first started using Access as our company’s end-user reporting tool, there were some unfortunate incidents. In one of those incidents, our president put two tables, each with about 100,000 records, in a query and clicked the Run button. His computer rumbled for about five minutes, sighed deeply, and locked up. So he did it again. After the fourth or fifth time, he decided that this repeated failure wasn’t accidental and called me to fix it.

What was happening, of course, was that he had failed to join any fields in the first table to any of the fields in the second table. When you put two tables in the same query without joining them, SQL’s default behavior is to give you a recordset that contains every combination of every record in both tables. This type of result set is called a Cartesian product. Because we had more than 100,000 records in each of the tables in this example, the big sigh the computer was making occurred when it discovered there wasn’t enough memory to hold the 10 billion records he was generating. In mathematical circles, this is known as the "law of large numbers:" if you multiply one large number by another large number you get a humongous number.

I explained what was happening and my boss’ immediate reaction was the one that most users have: he was the victim of a bug. I don’t think I ever really convinced him that it wasn’t a bug and that he had discovered the fundamental behavior that makes SQL work.

How SQL works

Back in the bad old days, there was no special SQL syntax for joining two tables together. Instead of using the Join keyword and coding this:

SELECT * 
FROM Table1 
INNER JOIN Table2 ON Table1.Field1 = Table2.Field2;

you simply added a Where clause to the SQL statement:

SELECT * 
FROM Table1 , Table2 
WHERE Table1.Field1 = Table2.Field2;

It’s important to see this in light of SQL’s default behavior. Simply putting two tables in a query like this:

SELECT * FROM Table1, Table2;

generates every possible combination of the rows in the two tables. A Where clause specifies which rows, out of all of those combinations, you’re interested in. In the sample case, it’s just the ones where Table1.Field1 equals Table2.Field2.

The Join keyword was added primarily to make it easier for query optimizers to determine the best strategy for retrieving the records—and also to introduce a standardized way of specifying outer joins (which every SQL implementation seemed to do differently). While the query optimizer may use the Join clause to work out some arcane way of retrieving the data, for the result to be valid it must match the result you would get if you generated every possible combination of rows and then went through those rows winnowing out the ones that don’t match the various Where clauses.

Useful results and No Joins Can Be A Feature

Sometimes you have to write your SQL code using Where clauses to specify how the tables in the query are related. If you’re joining two fields of incompatible types, for instance, you have no choice. If Field1 is a string and Field2 is an integer you can’t just drag Field1 over to Field2 in the Query Design window (well, you can, but the resulting query won’t run). What you have to do, after adding both tables to the query, is pull Field1 down to the query grid and give it a criteria of CStr([Field2]). The resulting SQL would look like this:

SELECT Table1.Field1, * 
FROM Table1, Table2Num 
WHERE Table1.Field1=CStr([Field2]);

This harks back to the original SQL method for joining tables. There are even occasions when you don’t want to join the tables in a query because you want to exploit the default behavior. This may occur when you’re loading a table with data. For instance, I have been trying to find a simple way to generate a round robin schedule for a hockey tournament. The first step of our solution is to load the tblGames table with all the possible games that could result from the teams in the tblTeams table playing each other. We do this by putting two unjoined copies of the Teams table in the same MakeTable query:

SELECT tblTeam.TeamName, tblTeam_1.TeamName 
INTO tblCombinations 
FROM tblTeam, tblTeam AS tblTeam_1;

This query creates a table of all the possible team combinations, including some impossible ones where a team ends up playing itself.

Here’s another example: at my company we have to keep track of the road graders we’re building. We build a grader in 65 separate steps and when a step is completed, we check off that step for that grader. I built the table for recording this information by using a query that takes a table of all the graders to be added and a table of every step, and then exploits SQL’s default behavior:

INSERT INTO tblStatus(Grader,Step) 
SELECT * FROM tblNewGraders, tblStepList

Once the table is built, recording progress is just a matter of the guys on the shop floor checking off each row as the grader finishes each step. It’s like I told my boss, when his computer kept blowing up trying to generate 10 billion records: "It isn’t a bug, it’s a feature." I don’t think he appreciated the usefulness of Cartesian product joins, but he had a memorable introduction to the fundamental nature of SQL.

If you like this article, read how Garry put this theory to good use in producing X-Y Grid queries for mining companies:

http://www.vb123.com/kb/200003_gr_space.htm

Become a guest blogger! Submit your tips to Mike and Chris at accpower@microsoft.com

Install Access Services on Vista or Windows 7 x64 OS

Clint Covington — Wed, 25 Nov 2009 06:54:55 GMT

I expect there are a number of folks that would love take Access Services for a spin and give us feedback. It is possible to create a dev install of SharePoint 2010 Beta 2 on Vista x64 or Windows x64. This is only intended for developers to develop custom solutions and isn’t a supported live scenarios.

The document should list in step 2 to install Reporting Services and here is the download. There was a glitch publishing the RS MSI where some users were getting a 1 byte file—that has been fixed.

There are plans next year to provide a hosted service through SharePoint Online that should make the barriers to entry much lower than it is today. I will get into that in more detail later but in the mean time—please install and give us your feedback.

Enjoy!

Publish to SharePoint (part 1)

Clint Covington — Mon, 23 Nov 2009 17:33:12 GMT

Today’s guest writer is Ric Lewis—the PM in charge of publishing to SharePoint.

A common question in the Access community is “how do I get my app on the web?” Here is the most recent example:

My wife and I have just started our own Recruitment business and I started an Access DB to basically be a contact manager and to track our jobs, candidates, clients and placements we make. I got to a certain point and realized I was out of my depth, so I enlisted the help of an Access Developer to finish it off. …

We currently work from home and are on a network so sharing the db is not a problem for just the 2 of us. In the new year, we plan to have 2 casuals start who are in different states from us, who we would like to be able to use the db as well.

From its inception, Access democratized data applications making it possible for non-developers to build client apps. Access 2010 is about to democratize data driven web apps. This means you can create a data application in Access 2010 client that can be published to a SharePoint server and used by other people who have only their web browser (no Access runtime or client required to use the app).

There are numerous implications of these new “Access Web databases” and I’ve no doubt we’ll discuss them in great length on this blog and in other forums. Today, I’d like to talk to you about the basics—the process of how you take an Access database to the web. Let’s start with the “Publish” operation.

You can watch Ryan and Clint’s demo on Channel 9 to see some of what we’re talking about in this post.

Web Objects and Client Objects

Any Access database is comprised of numerous objects, such as forms, reports, queries, macros and tables. In Access 2010, each of the objects in the database — with the exception of tables, which we’ll get to in a minute — has the additional designation of being a Web object or a client object. Let’s look at the differences:

Web Objects:

The overall goal of web objects is to provide a design environment that allows developers of applications to work effectively build objects that are both client and server compatible. Not everything you can do with the rich client can translate to the web. Here are come characteristics of Web objects:

Can only be created in Access 2010
Have a limited subset of full client object functionality.
Can be referenced by other web objects
Cannot reference client objects (unless you use IsClient—more about that later)
Are visible in the browser when the application is published
Are limited to expressions that are supported on the server

In the Navigation pane and Create ribbons, web objects are indicated by a small globe indicator on the icon:

Client Objects:

All existing objects in all ACCDBs made with Access 2007 and earlier
Can be created in Access 2010 for use in Access client
Encompass the full set of Access 2010 client functionality including VBA
Can reference web objects

Forms, reports, queries, and macros can all be either web or client objects. Objects cannot be converted from client to web type, nor from web to client. It is, however, possible to save a web object as a new client object.

To ensure data integrity after publish, a given database can only contain either web tables or client tables—not both. In Access 2010, a database that contains web tables is called a Web database. A database that contains client tables is generally called a Client database, or just a standard/traditional Access database. Both web and client databases are stored in the standard ACCDB format.

It’s worth pointing out that since web objects can only reference other web objects, it only makes sense to restrict web objects to a database that is composed strictly of web tables, a.k.a. a Web database.

It is possible to take an existing Access database and try to turn it into a Web database—we will cover that in a different blog post.

Design Web Objects

As we've covered, Web objects do not fully represent all the functionality of client objects. This is due to the fact that our server rendering is not yet as powerful as the full Access client.

Because of this, we have introduced a restricted design experience for Web objects. If you're working on a Web object, you will only see those options and design mechanisms which are valid for Web objects. On a high-level, this means the following:

Web tables do not support design view. These must be designed using the ribbon in the datasheet.
Web queries can’t be opened in SQL view—the query design view restricts the user to settings that are valid on the web.
Web forms and reports cannot be opened in design view and do not support absolute positioning.

To compensate for some of these changes, we've made additional design surface investments:

Datasheet ribbon design experience has been significantly expanded. All Web Table properties can now be accessed through the ribbon UI.
Form and report layout designers have expanded table layout tools, with property sheet and events showing all web-legal settings.
Macro designer for Web tables is filtered down to only expose those macros which will function correctly on the server.

To reiterate--client objects can take advantage of the new layout design experiences, but they also have the traditional design surfaces available (table design mode, form and report design view, etc.).

Publish

Once you’ve used Access 2010 to build your Web database, replete with Web forms, web queries, etc., you’ll want to publish that application to a SharePoint server to create an Access Web database.

Tip: Before you do this, you’ll likely want to set your default startup form in Access Options | Current Database).

To publish your application, you’ll need to enter the new Backstage.

You’ll notice the publish button at the top of your menu when you have a Web Database open.

Clicking publish will take you to the Save & Publish place. From there, you can fill in the server and application name for your published app:

Then simply click “Publish to Access Services” and you’re good to go. You’ll see a small progress dialog

And then a publish success dialog:

You’ll also notice that as part of publish, Access made a backup of your old ACCDB in the same place you had it saved before. This is your old pre-publish database, which you can use for a backup. It is not connected to your new web database. Here an app running in the client:

And the same app running in the browser:

In our next post we’ll talk about errors you may encounter during publish and how to maintain your new Access Web database. Enjoy your new Access Web database!

Access Services overview and install information

Clint Covington — Thu, 19 Nov 2009 18:22:00 GMT

Recently on The Access Show Ryan and I introduced Access Services and created a donations application that ran in the browser. I thought it would be helpful to provide some background to the vision and direction.

Years ago I came across a post on UtterAccess that articulately described what we hope to accomplish with Access 2010. Stormin on UtterAccess says he is:

… looking for clues to how I could create an Access application that would run from within an Access database, as well as from the web (from a single point of maintenance, of course!).

Reading between the lines a little—Stormin wants to keep all the goodness of the Access as a RAD tool but reap the deployment benefits of the web browser.

As we looked at the long term direction of the product and Office—it was clear that Access 2010 needed to allow users to create databases run in the browser that could live in the cloud. There are so many interesting scenarios for how people need to collaborate in the new global economy—making it easy to share databases is a critical step.

As we spoke with leaders in IT organizations it became clear they were equally interested in a single point of maintenance. In most large organizations it is very difficult to get IT to provide Access users with a SQL Server and ASP.Net web server for small team applications. They are primarily turning to SharePoint as the tool for business users to store all types of information including documents, Wikis, blogs, and lists. From an operational perspective, there continues to be heavy investments in infrastructure to run SharePoint as a server or hosted service (such as SharePoint Online).

Access 2007 forged the initial down payment into SharePoint as a platform for Access databases. Access developers told us clearly there were four things that limited adoption of the Access 2007 SharePoint functionality:

Data integrity. Developers needed better control over the integrity of the data. Basic concepts like restrict insert, cascade delete, is unique, required, and validation rules were essential for any well designed database.
Performance. Performance on SharePoint lists was not acceptable for many applications. Once users entered more than a couple thousand records it was not uncommon to run into performance problems.
Web forms and reports. Users wanted easier deployment with forms and reports in the browser.
Distribution. Many people indicated SharePoint wasn’t deployed in their organization.

Install Instructions

How do you get started with Access Services? It is possible to install it on a Vista 64 bit or Windows 7 machine for developer evaluation. First, you will want to download the SharePoint 2010 beta and install the prereqs. Here is an article that walks you through installing SharePoint 2010. Assuming you want to run reports on your machine you will need to install Reporting Services before installing SharePoint 2010 and enable session state after the SharePoint install. Here is the download for SQL Server 2008 R2 November CTP Reporting Services Add-in. I strongly recommend installing RS before SharePoint. FWIW – we are doing some work post Beta 2 to make setup easier… I think that is the information you need to get started—good luck.

Over the next couple of months we will talk about the work that has gone into these four areas. Next up—Ric will introduce you to publish and we have an Access Show that talks about IT manageability.

Download Access 2010 Public Beta today

Clint Covington — Wed, 18 Nov 2009 22:03:29 GMT

Today, we are thrilled to announce the release of the public beta of Access 2010, Access 2010 Runtime, and SharePoint 2010. You can download Office and SharePoint at www.microsoft.com/2010.

My July post Access 2010--The 10,000 ft. View outlined the following advancements:

Get started faster
Better design and customization tools
Centralized business logic
Landing pad for data
SharePoint performance and offline
Browser apps

Last month Ryan and I gave the first public demo on Channel 9. If you haven’t see it—definitely interesting for Access users. See the 2010 Intro Series and Top 10 Benefits for more information about what is new.

Access 2010 Runtime

As many of you know, the Access 2007 Runtime didn’t ship until some time after Access 2007 RTM. This was cause of frustration for many of our developers who had solutions ready for customers. This release, we have a goal to ship the Access Runtime as close to Access 2010 as possible. As a part of this effort, the Access 2010 Runtime Beta is ready for download. You can download the Access 2010 Runtime Beta today.

Here are some of the new features in Access 2010 Runtime:

Published Apps: In Access 2010, users can create applications and publish for sharing it with other users. Access Runtime works great with published Access web applications. Users can open and upload data changes using the Access 2010 Runtime.
Access 2010 caching: In Access 2007 Runtime, “Take Offline” (Access 2007 caching) was not available in the Runtime. In Access 2010 Runtime, customers get to access to the faster and automatic Access 2010 caching. Feature now available to Runtime customers include – reconnect lists, automatic offline when connectivity is lost, and notifications when connectivity is restored.
Backstage: Backstage will be available to allow users to print, close and sign up for Customer Experience Improvement Program. Developers can extend backstage and add custom tabs and buttons for their applications.
New Access features: Runtime users will be able to use the new rich features introduced in Access 2010 such as Data Macros, BCS data, navigation control, web browser control, conditional formatting, and calculated columns.
64-Bit: Access 2010 Runtime will be available in both 32-bit and 64-bit versions.
Languages: Access 2010 Runtime beta is available in 6 languages (en-us, zh-cn, ja-jp, fr-fr, de-de, es-es, ru-ru). The RTM version will be released in as many languages as Access 2010.

Give Feedback

We look forward to your feedback. The best way is the Send a Smile tool that is included again with the Public Beta. This lets you send us comments and a screenshot of what you are doing. Please include your email address if you want us to follow up with you. Members of the team will be looking for your feedback.

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!

Add color formatting to columns in Combo Boxes and List Boxes

cdowns — Tue, 17 Nov 2009 18:18:00 GMT

Today's guest blogger is Pavlo Pedan of ARGO Business Corp. He has 15 years of experience with Access and has a great site of tips at http://sites.google.com/site/msaccesscode/.

As we all know, a List Box control has a Fore Color property. It sets the fore color for column values and headers simultaneously. Also, we know that table and query fields have a Format property, where color formatting can be set. For example, you can format a number field as 0.00[Green].

As stated in Access 97, 2003 and 2007 help, "If you set a field's Format property in table Design view, Microsoft Access uses that format to display data in datasheets. It also applies the field's Format property to new controls on forms and reports."

So when creating a new Text Box control, the Text Box inherits the underlying field's Format property. However, List Boxes and Combo Boxes can also inherit this color formatting. And, it works for existing controls as well as new ones. You can change the Format property for a table field, and the new color will be inherited by an existing control (Text Box, List Box, or Combo Box).

The strange thing is, the List Box control has no Format property, and the Format property for the Combo Box control is not changed by the Format property of the underlying field. See a sample database here for some examples.

Using color formatting for list boxes and combo boxes definitely makes an application more attractive. One can set different columns into different colors, set different colors for header and items, and use a type of conditional formatting for empty values. For example, the Format property for Field2 in the picture above is: [Blue];@;"Empty"[Magenta]. This formatting overrides the Fore Color property of the control.

Such formatting is applicable not only for underlying tables, but for queries as well. Therefore, by choosing different queries for different List Boxes, we can have different sets of colors while referencing the same table.

However, some limitations apply. The above only seems to work for Access 97 and 2007 (and 2010?) but not for 2003. Also, it seems to work only for Text and Memo fields.

Have you experimented with this? If so, please post a comment!

Thank you,
Pavlo

Send your Power Tips to Mike and Chris at accpower@microsoft.com.

Build navigation UI with Access 2010

Clint Covington — Sat, 14 Nov 2009 16:08:00 GMT

Today’s guest writer is Wouter Steenbergen, a PM on the Access team responsible for Access form and report designers.

If you want to build an easy to use application it always starts with a good navigation model that allows users to quickly perform the most common tasks and easily find the less common tasks. Years ago, Access introduced the concept of a switchboard manager which has become a mainstay for many applications in the late 90’s. The hierarchical model and ease of adding new objects into the interface served our community well for many years. However, advancements in web design and user interfaces have developed more intuitive interface models. When was the last time you saw a well-designed web site that worked like a switchboard manager?

Moving Access to the web was a great opportunity for us to re-invent the tools we provide to build navigation. It started with an exhaustive study of many of the top 100 web sites. A few patterns emerged: Web sites usually have top level navigation commands and often expose sub navigation directly below or along the left side. When users navigate the top level color and background images typically highlight to users what top level item is selected. It’s a useful paradigm that gives users sense of direction.

In Access 2010, we have implemented a new way to implement navigation; navigation forms. Navigation controls support the new look and feel functionality that Viki and Steve talked about in an earlier post. This guarantees many opportunities to create a great-looking web interface that is easy to understand and simple to use. Take a look at the Demo of Access 2010 room bookings database, Albert really summarizes the Navigation form well at the start of his video.

How does it work?

Here is a quick demo on how it works:

When you create a navigation form using one of six predefined layouts, it contains a navigation control and a subform control. These two controls are connected by the NavigationTarget property on the navigation control.

When you drag a form or report onto the navigation bar, a new button is added. Selecting the button causes the corresponding form or report to appear in the subform control.

Advanced Access users may notice that this implies that we removed another design limitation. In Access 2010 it is possible to render reports in a subform control on a form. This makes reports a truly integrated part of your web application.

After making your navigation form, you can set the NavigationWhereClause in the button’s property pane, to make the Navigation button automatically apply a filter when the button is selected. This makes it super easy to filter an existing view without creating different forms or queries.

Programmability

The navigation control is accessible by using the object model. It’s not possible to dynamically add or remove tabs, but a lot of other properties are available.

You can show or hide buttons based on the role of the user by setting the visible property in an OnLoad or OnCurrent event. Other properties that are available on navigation buttons are Enabled, Visible, Locked, ForeColor, BackColor and Caption.

Drawing your own buttons

You can replace the look of all your tab buttons by selecting icons instead of typing in the button caption. This allows you to customize the look and feel of your navigation even more. In the example to the right, I used icons borrowed from Excel’s conditional formatting.

Some of the new shapes introduced in Access 2010 are specifically designed for use with navigation and tab controls. They’ll allow you to create a nice tab-like experience when designing your navigation.

Navigation versus Tab controls

Some people may wonder when to use a navigation form versus a tab control. The difference between tab and navigation controls is that the controls in a tab are part of the form. Individual tabs are hidden behind each other. The navigation control unloads and loads a new form (or report) in the sub-form control. This triggers record updates and requeries the data source.

Other Resources

If you are interested in learning more about how to build good navigation UI, I strongly recommend chapter 7 of Steve Krug’s Don’t Make Me Think: A Common Sense Approach to Web Usability.

Sorting a Listbox Using Command Buttons

Mike Stowe — Fri, 13 Nov 2009 23:28:01 GMT

Today’s guest blogger is Daniel Lamarche. Daniel is the Training Director at ComboProjects, which specializes in providing custom training solutions in Microsoft Office products.

I always thought it was cool to be able to sort a list by clicking the column heading once, for ascending order then once more for descending order.

A while ago I decided to tackle this feature in an Access form.

The buttons above the field names are used to sort the list. The triangle pointing down means the column is in descending order.

Clicking on it again will sort that column in ascending order and the triangle will be pointing up. Like you are used to.

This project required a basic understanding of Access SQL and concatenating strings.

When you configure the Listbox using the Row Source property to specify the data that will appear in the list you are in fact creating a SQL statement.

Read the rest of the article and download a sample database here: http://www.comboprojects.com/articles/accSortingList/accSortingListbox.html

Send your Power Tips to Mike and Chris at accpower@microsoft.com.

Why Access works for Blue Link

Clint Covington — Fri, 13 Nov 2009 05:44:41 GMT

Today’s guest blogger is Darren Myher. Darren is the VP Operations of Blue Link Associates Limited, a Gold Certified Microsoft ISV Partner. Blue Link’s flagship product: “Blue Link Elite” is a fully integrated accounting and inventory management system built using Microsoft Access and SQL Server.

Darren has attended several of our developer kitchen events over the last couple of years. I liked his perspective about Access and asked him if he would share his experience with our audience.

-- Clint

Every company has something that makes their business unique – a competitive advantage that needs to be supported and enhanced by the software they choose to run their business. Using Microsoft Access as the front end UI to a SQL Server back-end allows Blue Link to build and customize robust applications that meet the unique requirements of every client – at a cost, and in a timeframe that makes the solutions we develop both feature-rich and affordable.

Building Applications with Microsoft Access & SQL Server = Competitive Advantage

To me, building solutions in Microsoft Access is about giving my company – and my customers a competitive advantage.

I gain competitive advantage because I can offer my clients more functionality at a lower cost and in a shorter timeframe than any of my competitors. In turn, my customers gain competitive advantage by having custom-tailored software solutions that incorporate features that they just wouldn’t be able to afford otherwise.

Rapid Application Prototyping and Development

Access enables both rapid application prototyping and development. When I sit with a customer to build a user interface prototype, the result is a clear vision of what the software will look like and how end users will interact with the software. Having that clear vision reduces the time it takes to build and test the solution, and ensures that the client gets what was discussed during the specification stage.

You don’t realize what you get for “free” with Access until you try to use something that isn’t Access to do the same thing:

Recently, I tried using .net development technologies (because that’s what everyone seems to wants you to do), to create a data-centric application. The project took months of development and went way over budget. What the experience taught me first hand is that you don’t realize just how much functionality you get “for free” with Access until you discover that you have to re-create it all from scratch in .net. Here are just a few of the things that Access includes that you don’t get with .net:

Multi-column combo boxes
Paging of data
Record locking / concordance handling
Different form types: Continuous, datasheet, etc.
Right-click filtering and sorting
Labels that move with controls

To work around the above, you end up either having to write your own controls, or purchase 3^rd party controls. When you go with 3^rd party controls, they come with their own set of problems – memory leaks, design issues, etc. With Access, you get everything right out of the box and can get busy solving the business problem.

Microsoft Access’ support for SQL Server means you can build enterprise-quality applications with rock-solid back-ends and still take advantage of rapid application development for the front-end UI.

Summary

In a matter of days, I can meet with a client, identify the business requirements, and build a prototype of the user-interface elements. Using the prototype I can estimate the time required to complete the project, quote the client based on that time estimate and deliver a working solution at a fixed price and in a very short time frame.

The end result: More features, more functionality, less time, lower cost. That translates to competitive advantage for me – and my customers.

About Blue Link

Blue Link builds ERP software solutions for small (typically owner-managed) companies. Blue Link’s flagship product: Blue Link Elite is a completely integrated accounting system with full CRM, Lead Management, Quoting, Sales Orders, Purchasing, Inventory Management, Work Flow Management, features and more.

Click here to view a demo of Blue Link Elite’s Order Entry system:

To learn more about Blue Link products, visit www.bluelink.ca.

The Access Show: Recap of SharePoint Developer Conference

Clint Covington — Thu, 12 Nov 2009 17:05:00 GMT

This is the second episode of The Access Show with Steve Greenberg & Ryan McMinn. They just came back from the sold-out SharePoint conference in Las Vegas where they launched Access Services and wanted to give you an update as well as introduce some customers that have been using the technical preview and building web databases.

Robert Hogg - Black Marble Consulting
Michael Matloub – Connolly, Inc

Subscribe to The Access Show: RSS, iPod/MP4, WMV (high quality), Zune, MP3