Clint Covington: Software design, Microsoft Office Access : Developer

Silverlight resources post by ScottGu

Clint Covington — Tue, 22 May 2007 08:15:00 GMT

Scott Guthrie has a truly great post on Silverlight. You should be able to find anything you need to start ramping up--very cool, innovative technology! As a developer, it is definitely worth your time to get educated on the possiblities.

Security Considerations and Guidance for Access 2007 - MSDN article

Clint Covington — Sat, 12 May 2007 17:06:00 GMT

There is a new article by Access MVP Garry Robinson.

"Find out how you can use Access 2007 to protect the information in your databases. Learn about encrypting files, administering passwords, converting databases to the new ACCDB and ACCDE formats, and using other security options such as SQL Server. (18 printed pages)"

http://msdn2.microsoft.com/en-us/library/bb421308.aspx

The runtime will ship May 15th

Clint Covington — Wed, 09 May 2007 21:16:00 GMT

I just heard from Erik that the runtime will ship as a free download on May 15th! I will post a URL to the download page when it is available.

Enjoy!

Tip on renamed field names and debugging reports

Clint Covington — Fri, 27 Apr 2007 19:08:00 GMT

Today's Guest Writer: Tony Toews, Microsoft Access MVP

I have a complex report with 5 grouping levels, subtotals, and three subreports for additional details of totals. There are also lots of calculated fields on the report with embedded control names.

I had to rename some fields in the base query as I had to insert some IIF logic in the query.

Well, I couldn't figure out where one particular field was being used. I looked in the usual suspect places by examining the object list. I then looked at the Sorting and Grouping sheet because that has caused me troubles in the past. Not there either.

Access 2003 usually has these nice widgets, or tips, or whatever those little black/navy triangular doodads in the corner of a control when you find a problem. (This feature BTW is the single nicest feature of A2003. IMNSHO and is well worth upgrading from previous versions for the developer or power user.) But these didn't work this time.

So I used the SaveAsText--at the debug/immediate window type: Application.SaveAsText acReport, "MyReport", "c:\report.txt"

I opened the text field and found that that field in the Link Child Fields of a subreport. Whoohoo. Fixed.

Clint here--You can find other useful content from Tony on his web site. If you have a tip that you would like to pass along on this blog, send it my way. I'm always looking for good content to keep you all interested :-).

E4-27 Edited code to export report not form.

Reader question about macros and VBA

Clint Covington — Sat, 21 Apr 2007 14:26:00 GMT

A reader recently asked:

Is there any way on Access 2007 to keep wizards and Switchboard Manager coding in VBA, any way developers "HAVE" to code for most applications.
If a customer is buying an apllication from us, he is not going to trust what he bought?.
Switchboard manager was great in its code handling.

Good question. Let me back-track a little into the annuals of the decision to move the button wizard from VBA to macros. There are a significant percentages of Access databases that are built by information workers that have very little code. One of the many goals for Access 2007 was to expand on this and allow IWs to build better applications without writing code. The new security model allows users to run databases without any VBA code enabled (this is important for many organizations). As you know, trusted locations make it much easier to deploy databases with code. Our wildly popular templates are functional databases that don't have code. Feedback on the templates have been positive.

We started running into scenarios where IWs opened a database and added a switchboard or button that didn't work. Users were confused--they didn't work because the database wasn't enabled. As many of you have complained about over the years, the wizards also wrote out poor examples of VBA (doMenuCmd 97 kind of stuff). To fix the problem we converted the wizards to write out embedded macros that run in untrusted databases. We also spent time cleaning up the code they generate to provide users with better learning examples.

We did consider a flag to write out either VBA or macros but the feature was one of many things we wanted to do that didn't make it into the release. :-( Beta 2 shipped and we got lots of feedback from beta testers (Pat Hartman and John Viescas were particularly vocal) that they wanted a way to convert embedded macros to VBA. As a late change we made it possible to convert embedded macros to VBA. You can find the command on the Database tab under Macro.

Do we think everything should be written in macros? No--they aren't a replacement for VBA. VBA will continue to ship and be supported in the future. Macros are turning out to be useful for simple actions that took a few lines of code. We find that IWs are much more successful making small changes to macros than VBA. I have yet to hear a perf complain on macros verses VBA, so performance shouldn't be an issue. Long-term, we intend to continue to innovate in this area and make macros more useful for broader developer scenarios.

Thanks for your question and hope this explains our logic.

How to pull in Amazon web service data into Access 2007

Clint Covington — Tue, 13 Mar 2007 09:01:00 GMT

Today’s guest writer is Ric Lewis. Several weeks ago he started a general discussion about web services which turned out to be a popular post. This week he is providing the details of the books sample database.

It would be sweet if someone takes this project and details it out a bit further. For example, you could imagine using the title to search for titles and popping up a list of search results to choose from. The ISBN number is a bit awkward. If you do make improvements to the project—send me an email and I will share it with the community.

Clint

Amazon Web Service Code Sample

As a note before you dig in, the code presented in this post consists of excerpts from the full project code. In other words, if you’re going to copy and paste my stuff, do it from the project, not from this post. You can grab the code for this project from here: Code Project.

For those of you who want to compile and run the plugin, here are the steps:

You can grab the code for this project from here: Code Project.
Get a new Amazon Web Service key from the Amazon Developer Center.
Replace the “############” in the DataCollector.cs code file with your new AmazonWS key (the code won't compile until you complete this step).
Build the AmazonDemoAddinSetup project.
Run the setup.exe file generated (this will install the plugin so Access can see it).
Visual Studio will generate an AmazonDemoAddIn.dll.config file in the build directory. Copy this file “\program files\microsoft office\office12” and rename it “msaccess.exe.config”

Also, this post has no pictures. Not one. So if you like pictures, look elsewhere, if you like code snippets, venture on. Okay, with that out of the way, let’s talk about this application.

Form Load

I’m all about flow-of-control discussions, so let’s trek through the app in that manner.

When you load up Access, it determines which, if any, add-ins have been installed and should be loaded. Thereafter you can reference those add-ins by name from your form’s VBA code.

Load up the Book database (from the previous post or the code project above), and you can click on the “New Book” button. This triggers a call to the Form_Load event handler in VBA code. There’s not too much VBA, so let’s step you through the code:

This first bit of code opens the form, checking first to see if it’s a new form, or an existing record.

Private Sub Form_Load()

If (Not IsNull(Me.OpenArgs)) Then

DoCmd.GoToRecord , "", acNewRec

Me.Title = Me.OpenArgs

End If

If this is a new form, or there’s just no name, then set a title for the book. This form requires a title to be set, so it’s nice to get this out of the way upfront.

If (IsNull(Me.Title)) Then

Me.Title = "Untitled"

End If

This just places the cursor in the ISBN field. You probably knew that.

Me.ISBN.SetFocus

This last bit of code is the interesting part. It connects to my addin (AmazonDemoAddIn) and calls the PrepareObject function of my add-in. We won’t go into this function too much, but it warms up the web proxy that we’ll be using later.

With COMAddIns("AmazonDemoAddIn.Connect")

' make sure the COM add-in is loaded

.Connect = True

'warm up the web proxy object--this may take a few seconds

.Object.PrepareObject

End With

End Sub

(This PrepareObject call is why the form is so slow when loading for the first time)

ISBN AfterUpdate

So, now the “New Book” form is up, with an eager cursor, blinking away, waiting for you to enter an ISBN. Type in an ISBN, leave the ISBN text box and it will trigger the ISBN_AfterUpdate code back in our VBA macros

Up to this point, we have a form for a new record, but we have not yet generated a new recordset in the database. The Me.Form.Refresh call will generate an actual recordset in the database, so we have something to pass into our add-in.

Private Sub ISBN_AfterUpdate()

Me.Title = "Retrieving from Amazon..."
Me.Dirty = False

Up to this point, we have a form for a new record, but we have not yet generated a new recordset in the database. The Me.Dirty call will generate an actual recordset in the database, so we have a recordset we can pass into our add-in.

With COMAddIns("AmazonDemoAddIn.Connect")

.Connect = True

' Hook up the desired objects

        If Not .Object.FillInBookForm(Me.ISBN, Me.Recordset) Then
            Me.Title = "Failed to retrieve from Amazon."
        End If

End With

Me.Form.Refresh

End Sub

This bit of code brings up an important point.

There are two ways to manipulate your form from your managed add-in:

Top-down: Pass in a control from your form (e.g. Me.ISBN) and manipulate its properties in your managed add-in.
Bottom-up: Pass in your form’s recordset and manipulate the record set.

For reasons too complex to get into here, if you’re adding complex data (for example, a new attachment) you’ll need to pass in the recordset. However, if your forms only contain textual data, most of that can (and probably should) be handled by manipulation of the controls.

Okay, on to the managed add-in code.

Managed Add-in

Over-simplified data flow of my AddIn.Connect class is as follows:

Grab ISBN control and Recordset passed in from VBA form code
Send ISBN value to a DataCollector object (Amazon, in this case)
DataCollector returns a Book object
Populate Recordset with information from Book object

So let’s, look at how each of those parts happens:

Grab parameters from VBA form code

Remember this call from our form VBA?

.Object.FillInBookForm Me.ISBN, Me.Recordset

This calls the following function in our AddIn:

public void FillInBookForm(Access.TextBoxClass ISBNTextBox,

Access.Dao.Recordset2 FormRS)

Send ISBN to a DataCollector (Amazon, in this case)

From here, we call CollectInfoFromWeb. This function checks if we have a DataCollector setup (we do), makes sure that the ISBN isn’t empty, and sends the ISBN on to the DataCollector.

Note that we’re accessing the .Text property of the ISBNTextBox control. This returns the text that’s currently occupies the ISBN control back in our form.

Book tempBook = CollectBookInfoFromWeb(ISBNTextBox.Text);

DataCollector returns a Book object

This is where lots of magic happens.

The DataCollector always sends back “Book” objects. You should be able to extend the DataCollector class to gather data from any Web Service you’d like (eBay comes to mind), as long as you somehow squeeze all the return data into a “Book” object.

If you’ve installed the .NET 3.0 extensions for Visual Studio 2005 (here: http://www.microsoft.com/downloads/details.aspx?FamilyId=F54F5537-CC86-4BF5-AE44-F5A1E805680D) from within Visual Studio you can add a reference to any WSDL-based Web Service just by pointing it to the WSDL. Simply right-click on your project, select “Add Service Reference” and type your WSDL into the form and Visual Studio will auto-generate a bunch of code for interacting with the service.

Once you’ve got the Service Reference added to your project, you’ll have a proxy class which you can instantiate to interact with the web service.

AmazonClient = new AWSECommerceServicePortTypeClient();

Note: all the configuration, binding and connection info for this proxy client is put in your project’s app.config file. This becomes the AmazonAddInDemo.dll.config file at build time, and needs to be renamed msaccess.exe.config copied to the directory alongside your MSACCESS.exe.

One of the methods on this proxy is ItemLookup. This call takes an ItemLookupRequest object as a parameter, so you’ll need to generate and fill out the properties of that object:

ItemLookupRequest lookupRequest = new ItemLookupRequest();

lookupRequest.ItemId[0] = myISBNString;

lookupRequest.SearchIndex = "Books";

Then make your call to ClientProxy.ItemLookup, and store the result as an ItemLookupResponse object:

ItemLookupResponse myResponse =

mAmazonClient.ItemLookup(itemLookup);

Then, lastly, we’ll map the properties from the response object into a new Book object.

newBook = new Book(currentItem.ItemAttributes.Title,

Author,

currentItem.ItemAttributes.Genre,

…);

return newBook;

Populate Recordset with information from Book object

We call .Edit() on the recordset we were sent (FormRS), and start plugging values into fields

FormRS.Edit();

FormRS.Fields["Author"].Value = tempBook.author;

FormRS.Fields["Title"].Value = tempBook.title;

…

Then for some real magic, we embed the cover art data into the recordset.

Internally, Access sees Attachments (like our cover art field), as embedded child recordsets (sub-tables). So, we’ll need to create a new record in the “Attachments” child recordset.

Access.Dao.Field2 fld =

Access.Dao.Field2)FormRS.Fields["Attachments"];

Access.Dao.Recordset2 rstChild =

(Access.Dao.Recordset2)fld.Value;

rstChild.AddNew();

And then dump our binary image data into the “FileData” field of this new record (from the URL of the image data), update the “Attachments”sub-recordset, the form’s recordset, and we’re good to go.

Access.Dao.Field2 fldChild =

Access.Dao.Field2)rstChild.Fields["FileData"];

fldChild.LoadFromFile(tempBook.coverImageURL);

rstChild.Update(1, false);

FormRS.Update(1, false);

Of course, everything you just spent 20 minutes reading about happens in less than the blink of an eye, and your when you update your Form’s recordset, the form will have all the data collected from the Web Service and you’re done (or at least I am, if you’re really into this kind of thing, you can now click “Save and New” button on your form and do the whole mess all over again).

Conclusion

Phew, I think that’s about it. Congrats if you actually made it this far. If you skipped ahead to this paragraph, I’m not going to gratify your laziness with some kind of all-summing conclusion. Hopefully, you now understand enough to know how to twist my project to explore your own wildly cool Web Service + Access intentions.

You can grab the Visual Studio project from here: Code Project.

It’s important to mention that I can’t take full credit for the generation of this demo. I leaned heavily on Ken Gatz’s excellent “Managed Add-in in Access 2007” white paper, as well as the debugging and VB skills of my fellow teammates. And frankly, the whole thing was Clint’s idea in the first place, so kudos to him as well.

If you’ve got additional, specific questions, first read Ken Getz’s whitepaper on “Managed Add-in in Access 2007” because his is a great article. If you have additional questions, feel free to post your questions here on the blog.

Cool As Ice uses Office Live and Access 2007 with custom ribbon

Clint Covington — Wed, 07 Mar 2007 08:32:00 GMT

Alan Cossey recently sent me a overview of how Cool As Ice is using Office Live and Access to track process information. He has found a couple bugs we will fix in SP 1 but overall it is working nicely for them. I thought some of you might appreciate seeing what others are doing with Access 2007. If you have an interesting scenario that you would like featured on my blog--feel free to send me an email.

Nice work Alan.

Clint

______

From Alan:

Here is some information about the Access 2007 application that I’ve developed for Cool As Ice, which is a leading Norfolk-based supplier of air conditioning and refrigeration here in the UK. Cool As Ice wanted a bespoke customer contact system that they could use to hold data securely yet allow their workforce to use that data on their laptops, including adding and altering data, i.e. not just a read-only copy. Access 2007’s integration with Sharepoint meant it could provide the basis for a good solution.

The application holds its data in a workspace that is part of my company’s Office Live site. The choice of Office Live to provide the SharePoint part of the solution means that their data is secure and that Cool As Ice do not need to get involved in organising that part of the solution, concentrating instead on the things they do best. Backups of data are done by Office Live and of course, the Office Live Recycle Bin is there in case it is needed. If neither of these needs to be used, everything is handled in Access 2007, i.e. the normal end-user just sees Access 2007 and no web user interface.

The image below shows the main screen of the application, i.e. where the main customer contact information is entered.

The application uses a ribbon, with it shown neatly tucked away in the above screen shot. However, most of the main actions in the database are called from it as can be seen from the next shot where it has been single-clicked to show it in drop-down mode.

Included in those actions is the ability to kick off the synchronization with the back end in Office Live. Clearly, the use of the application on laptops requires the use of offline data, but even in the office the system is run with the data offline and sychronized at an appropriate point, e.g. the end of the day. As you have pointed out already in your blog, using offline data allows for very quick data handling. When it comes to time to do the synchronization, even with about 3000 customer records already in the database the database synchronizes in under a minute on broadband.

A useful part of the Office Live integration is that it allows the use of Windows Live ID to provide the security of the data in the Office Live database. Thus when it comes to time to do the synchronization, clicking the Synchronize Data ribbon icon requires the user to provide their Windows Live ID and password and then off it goes.

You may have noticed in the first screen shot that there is a Notes field that enables users to record notes in rich text format rather than the old plain text of previous Access versions. You will also see from the next screen shot that use is made of Access’ ability to use subdatasheets. A bit more planning than usual is required to ensure correct updating and cascading deletions in the application, including with subdatasheets, but it is certainly “doable” as you can see from this solution.

VBA Functions and RunCommand code samples sites

Clint Covington — Tue, 06 Mar 2007 02:14:00 GMT

I recently came across in an internal newsgroup a couple great sites that provide lots of code samples for expressions and runcommands. You might find this useful.

Terry Wickenden's web site has lots of examples of RunCommands:

http://www.accessruncommand.com

Brendan Reynolds has a great blog where he researched what functions can be used outside of the Access environment.

http://brenreyn.blogspot.com/

Lots of good developer content...

Edited on 3-6-2007. Terry provided me with a new URL.

Tips and tricks for designing forms and reports - part 3

Clint Covington — Fri, 23 Feb 2007 14:39:00 GMT

This is the final post of a three part series on Access Tips and Tricks provided by members of the Access team. This article focuses on non-obvious things new to the forms and report designers. The other articles in this series covered useful keyboard commands and a general topic on new databases, the nav pane, import/export, and more. Another previous post that might be interesting to you was my post Ideas about great looking reports.

My next post will likely be a follow up by Ric on the technical details to his previous post on the books database that uses the Amazon web service. I hope you enjoyed this series.

Enjoy!

Clint

Custom AutoFormats

You can create a custom AutoFormat based on the current form. This was useful to me when I was customizing a template and didn’t want it to look exactly like the ones out of the box. With your form or report in Layout or Design views, under the Format contextual tab, drop down the list of AutoFormats and choose AutoFormat Wizard… Then click on Customize and choose “Create a new AutoFormat based on the form ‘Current’.” It requires some effort to get it exactly right, but what I did was make a form that had all the elements I might need (logo, title, labels, text boxes, etc.) and create the AutoFormat based on that, then apply it to all the other forms/reports. –Abigail (form and report developer)

Layouts

I’m a big fan of layouts and anchoring for creating forms that use the available real estate. However, it gets really annoying when a layout tries to suck in a control as it gets close to the layout. Why doesn’t Access read my mind and know that I didn’t intend for that control to go into the layout? Grrr!!! We tried to implement the “read my mind” feature but didn’t get very far!

As you drag controls near stacks, hold the CTRL key to keep fields from being sucked into stacks. This makes it possible to put red stars next to text boxes or move boxes behind controls to provide visual separation.

Another tip—you might notice all buttons in command bars are in stacks. We put them into stacks so that they would resize correctly in localized builds at instantiation time. Feel free to get rid of the stack—it doesn’t provide any functional value once the template is opened.

One last command I found really helpful when designing reports--on the right click menu for a control in layout and design mode there is the Layout | Move Up a Section and Move Down a Section. I have found this more useful than I expected when you are experimenting with different groupings.

Truncated Numbers

Ever had someone make a bad decision because a number was truncated? There is a new property called “Check for truncated number fields.” When this option is enabled, numbers appear as "#####" when the column is too narrow to display the entire value. When this option is not enabled, you see only part of the values in a column.

Transparent Images and Smaller Databases

If you have an existing mdb database, you know that adding images dramatically increase the size of the database. You also know that the images don’t preserve transparency. You set the option in the Access Options | Current Database. Here is what the help file says about preserver image format:

Preserve source image format (smaller file size) When this option is selected, Access stores images in their original format. Select this option to reduce database size.
Convert all picture data to bitmaps (compatible with Access 2003 and earlier) When this option is selected, Access creates a copy of the original image file in either the Windows Bitmap or Device Independent Bitmap formats. Select this option to view images in databases created in Office Access 2003 and earlier.

Binding Images to External Files

It is a royal pain to bind the image control to external files. The code is messy and sometimes the JPG filter doesn’t work correctly. Fortunately, late in the development cycle Brian made it possible to set the control source on image controls to UNC paths. Give it a try—create a text field that contains UNC paths to pictures in your favorite image library. Drop the image control on a form give it a run.

Easy Database Lockdown

I know, the runtime hasn’t shipped yet. If you are looking for a simple way to share a database with co-workers and you don’t want them messing around with things… Try renaming the file to ACCDR. This is the equivalent of running the database with the /runtime switch. Basically the ribbon and nav pane get turned off.

Save Embedded Macros as VBA

Access 2007 introduces a new type of macros called embedded macros. Embedded macros are macros that are stored on an event instead of as a separate object. Embedded macros support name fix-up and are used extensively through-out our templates. They are largely targeted to information workers that don’t write code but useful for developers that are trying to perform some simple actions.

I admit some types of macros are easier to maintain as code for developers. Thanks to a late DCR it is possible to convert all the macros in a form or report to VBA. Open the object in design view and Go to the Database Tools tab. Click on the Convert Form’s Macros to Visual Basic.

Hyperlinks and Hand on Hover for Buttons

Hyperlinks have a new Display as Hyperlink property that doesn’t munge # signs. It also prints hyperlinks as black text instead of blue underlies. Also, buttons have some new cool properties including transparent and a hand on hover property. On February 24th you will see new templates get released that use the new images and text and this property. (Abigail – Form and report developer)

Developer Help

End user and developer help is separated out so that end users don’t get confused with developer topics and developers don’t get bored with end user’s topics. You can easily switch between the two with the search dropdown.

My favorite Access keyboard commands - part 2

Clint Covington — Thu, 22 Feb 2007 10:28:00 GMT

I have a confession to make… I started hacking around in computers with Windows 3.1—never learned how to really use the command line. I know—I have fallen from grace for many of you developers. The mouse has been my friend. I’m trying to change and use keyboard shortcuts more often. Here is a list of keyboard commands I’m trying to use more frequently:

To do this	Press
Cycle between windows in SDI	CTRL F6
Open an object from the nav pane in design view	CTRL ENTER
Toggle between panes (nav pane, ribbon, open object)	F6
Expand/collapse the navigation pane	F11
Open a builder or zoom window (when you have focus in a property)	SHIFT + F2
Close an open Window	CRTL + F4
Expand/Collapse the ribbon (You can also double click on the active tab)	CTRL + F1
Set focus to the search box in the nav pane (once it has focus) ENTER while in the nav pane search box opens the top item in the nav pane in browse. CTRL+ENTER while in the nav pane search box opens the top item in the nav pane in design. –Scott (nav pane developer)	CTRL + F
Flip an object into design mode	ALT, H, W, D
Open an object in design view with focus in the navigation pane	SHIFT-F10, D
Refresh a view if the object is in browse view. If a form is in design view it will open in the default view. F9 – Refreshes the list contents of a combo or recalc expressions for the current record. Record focus is not changed. Shift-F9 – Requeries the object. Record focus back to the top with the current data. Combo/List box contents may not be refreshed. F5 should do both or Refresh All. – Shawn (test lead)	F5
Set focus to the search box in record navigation bar If you have the focus in the record navigation bar search box and press ESC, we’ll take the focus to the form/grid in the selection you had. So you can quickly do CTRL+SHIFT+F, search for something, press ESC, edit it, CTRL+SHIFT+F, etc… --Marcus (new look developer)	CTRL + SHIFT + F
Insert the current date	CTRL+SEMICOLON (;)
Insert the current time	CTRL+SHIFT+COLON (:)
Insert the value from the same field in the previous record	CTRL+APOSTROPHE (')
Add a new record	CTRL+PLUS SIGN (+)
In a datasheet, delete the current record	CTRL+MINUS SIGN (-)
Drop down a combo box when it has focus	F4
Save changes to the current record	CTRL S
Switch between Edit mode (with insertion point displayed) and Navigation mode in a datasheet. When using a form or report, press ESC to leave Navigation mode.	F2
Toggle the Field List	ALT + F8
Open the VBE Immediate window	CTRL G
Open VBE	ALT + F11

Here are a couple help article that provides far more references http://office.microsoft.com/en-us/access/HP100913941033.aspx?pid=CH101326501033 and http://office.microsoft.com/en-us/access/HA100919081033.aspx.

Sorry about the lack of grid lines or alternate row color--I will try to fix that when I have more time. Many thanks to all the Access team members that chipped in with comments.

BTW - if you haven't provided feedback about what web data you want in Access on our web service post--please do! This is your chance to provide us feedback about the next version. I can't promise what will make it into the schedule but your feedback on the topic is extemely helpful.

Updated nav pane shortcut 2/26--Clint.

Web service and sample book database that uses Amazon's Web Services

Clint Covington — Tue, 20 Feb 2007 22:33:00 GMT

Today’s guest writer is Access Program Manager Ric Lewis. Ric spent the last couple years with the Indigo team and just took an Access PM job. He is looking for some customer feedback on interesting web services scenarios. To start the conversation—he created an interesting and useful sample book database that uses the Amazon web service.

Clint

Media Players

For a few years now, there has been a slowly developing convergence of databases and Web Services. Perhaps one of the best examples of this is your standard media player.

A media player is a specialized case of asset management (with the assets in this case being digital data). Of course, the biggest barrier to tracking assets in a database is manually entering the information. Remember the first time you ripped a CD and had to manually enter all the album and track info? Now we take for granted that when we rip a CD, our media player will call the Gracenote (or some other) CDDB web service and automatically fill in all the information for us.

Nowadays, most media players will even go the extra mile of calling Amazon or Wal-mart to grab a high quality cover-art pic.

A media player is a great example of a widely used database-as-asset manager. And without you really noticing it, over the last few years, between calls to CDDBs and online-music stores, your media player has increasingly become a web application.

Databases and Web Services

Web services are all about distributing information, and databases are all about organizing and visualizing that data. Internally, we talk about Access databases being a landing pad for data. Using ODBC Access databases connect in rich ways to a number of different data sources.

Access 2007 Sample Books Database

Until then, I’ve thrown together a hack-ish example of a book-asset management system in Access 2007 which calls through the Amazon web service to collect book information when you type in an ISBN number.

Installation instructions:

- Download the zip file file (right click on zip and choose Save Target As).

- Unzip it.

- Run setup.exe (install for “Just Me”)

- Copy the msaccess.exe.config file into \Program Files\Office12

- Open the Books.accdb file

You’ll also want to make sure you’ve got macros fully enabled in Access. Then just hit “New Book” (wait a few seconds if it’s the first time), type in an ISBN (ISBN-10 only, AmazonWS doesn’t like ISBN-13), tab out of the ISBN field, and watch your data get filled in!

In a later post, I’ll talk a bit more about the behind-the-scenes of how this app was developed, and share out the Visual Studio project for the add-in. Download it, play with it, break it (that shouldn’t be too hard) and let your brain start spinning up about the possibilities.

The program should “just work” on Vista, but on WinXP you’d certainly need WCF installed, which is included in the .NET 3.0 runtime.

Moving Forward

As part of investigating many areas for future work we are researching Web Services. The best way is to always start with identifying useful customer scenarios. What scenarios would you find interesting connecting to web data?

Tips and tricks from the Access team - part 1

Clint Covington — Tue, 20 Feb 2007 07:44:00 GMT

I have been working on a three part series of non-obvious tips and tricks for using Access 2007. The other series will be on designing forms and reports and my favorite keyboard shortcuts. I put together a rough draft of this series and sent it around to the Access team. Fortunately, many team members responded with some good additions.

Enjoy and have fun building great applications!

Clint

Open Last Database

Office Button | Access Options | Advanced Tab in the Advances section there’s a new option to have Access automatically open the last opened database on boot. –Scott (developer lead)

New Database Settings

It is possible to customize the default database settings for new databases. Our UA team and Allen Browne have nice write-ups about it—so I won’t repeat it.

http://office.microsoft.com/en-us/access/HA100378371033.aspx?pid=CH100948231033#blanktemplate

http://allenbrowne.com/ser-43.html#dbtemplate

Table and Field Templates

Table and field templates are quick ways to create tables and new fields with a number of property settings already set. The field templates have a number of core field types and fields taken from common schemas. It is possible to override and extend the fields in the field templates task pane and the tables that get created from the Create | Table menu.

The fields and tables are created based on the ACCFL files found in the drive:\Program Files\Microsoft Office\Templates\1033\Access directory. These files are XML files based on the same format if you exported a table as XML and XSD. Any schema files stored in the directory named ACCFL will show up in the fields task pane. Unfortunately, you can’t add additional tables or rename existing tables (painful cut). However, if you are always creating Order tables and never Issues—you might want to change Issues to Orders. Export your Orders table to XML/XSD. Rename the XSD to Issues. ACCFL and save it to the directory. Next time you create an Issues table it will be an Orders table.

Here is a link to a UA article on the subject.

New ADP

However, I frequently see questions about how to create a new ADP. It is a bit buried in the new getting started interface. For the users that need to create new ADP files, here are the steps:

1. Click on the new Database in the Getting Started screen.

2. Click on the folder icon next to the file path.

3. In the files of type choose Access Data Project.

4. Name the file and click Create

Here is a link to a UA article on New ADPs for more information.

Navigation Pane

There is a hidden menu in the navigation pane that is quite useful. Right click on the navigation pane title for this menu:

My two favorite options in this menu is the Search Bar and the Sort | Custom Sort options. The search bar performs a Like *value* filter on the object name. This is really handy if you have a naming convention and want to quickly narrow down the displayed list. The Custom Sort option allows you to sort the objects in a custom order.

Another thing, if you have focus in the navigation pane CTRL F will automatically turn on the search bar. You can use the down arrow to select items and the enter key to open the object. It makes it pretty easy to find and open objects with the keyboard, especially if the object has a unique string in its name.

Filtering and Queries

As a user interactions designer, I’m convinced context will continue to drive UI innovation. Contextual tabs in the ribbon are one example of some great work done in this space. Filtering is another place inside Access that being smart about context really improves the user experience. In the past, text in the context menu was Filter by Selection and Exclude Selection. Access 2007 I clarifies context through vocabulary. Selected next now shows up in the context menu to provide more clarity. Did you know that the right-click context filtering options change based on your selection? Give it a try—look at the right click menu when the first and last character is selected. Now try selecting the whole word. You will also notice the filter options change based on the data type.

The new filtering UI in Access makes it really easy to quickly create complicated WHERE clauses in queries. Save As for queries will flatten the active filter into the where clause. Open your favorite query and filter a date column using the This Month filter. Click on the Office Button | Save As. Give the new query a name.

Copy and Paste From Excel

Many good lists start in Excel and need to transfer into Access. Here is a simple way to get data into Access quickly.

1. Copy the data from Excel.

2. Create a new table inside Access

3. Click on the Add New Field

4. CRTL V – just like that you get a table inside Access. The new Table Tools contextual ribbon allows you to make the most common schema changes without flipping into design.

You should also notice the behavior of copy and paste from Excel to Access has been improved in other areas.

Import From Excel

When importing from Excel files you can now override the data-type for a field. Sorry, I missed setting the data-type on link. Hopefully, the Access team will do that feature in the next version.

Outlook Reminders for Saved Import and Export Operations

You might have noticed at the end of an import or export operation there is a victory dialog. There is an option asking you if you want to save the operation. You might notice at the bottom if you want to create an Outlook reminder.

This feature was designed for people that need to publish a report every couple days. You can use the Outlook reminders feature to remind the user to perform the task on a scheduled basis. The task has a Run Export/Import command that will repeat the recorded operation.

Here is a link to a good UA topic on the subject.

SharePoint Performance

The team spent a bunch of time improving SharePoint performance but it still is influenced by the speed of the connection to the server, server performance, and size of the data. I have found working with SharePoint data offline and using the synchronize command a far better experience. This works much faster unless you are working on data that everyone else is changing. The conflict resolver UI gives you the chance to override server changes or discard your own changes.

In the future, Access should provide the option for merge changes. Oh well, something for vnext.

SharePoint also has a flag called Cache List Data. This stores a copy of the list data in the database file. When the database opens the Access database engine only requests changes from the server. It is a nice performance win for the client and server.

One last thing… If your list on SharePoint is getting really large—you might consider linking to a view and not the list. This works well for scenarios where you have archived data in a table that isn’t necessary for your view. There is a trick—you can’t bind to the view using the UI. Use the TransferSharePointList method to create the link table. It has a property for the view.

Templates

You just created the projects template and think,

“Wow, MS did a pretty good job designing this template. I would really use it if only they had named the tables and fields something different (Projects should be called tblSpecs for my purpose).”

Name fix-up is helpful at renaming objects and field names in templates. I know, I know—-name fix-up has a terrible reputation. In this release we made a significant investment in the name fix-up code base. Why? Early on we made the decision to use name fix-up to create localized templates. Every template we ship has an internal structure of English names. When a localized template is instantiated Access uses the name map to rename all objects from their English name to the localized name.

What does this mean to you instantiating a template? It means that if you instantiate the projects template and rename projects to specs, name fix-up will make sure all references to the project table gets fix-up to specs. Access 2007 fix-up references in embedded macros, labels on field names, and conditional formats. The code was extremely well tested because if name fix-up failed a localized template would be broken. This commitment to use name fix-up dramatically increased the amount of testing and overall reliability of the feature.

Zac’s book on templates The Rational Guide To Microsoft Office Access 2007 Templates is the definitive guide. If you are thinking about building a template—this is the book to get.

Template Internals

Want to see what’s inside a template file, the gory details of what makes up the .accdt file format? Just rename the package to .zip and double click to open. Inside you’ll find all the different parts of the database represented in XML and TXT formats, along with resources like the picture Access displays on the template’s tile in Getting Started. (Zac—form and report program manager)

Macro improvements in Access 2007

Clint Covington — Thu, 15 Feb 2007 11:01:00 GMT

Access 2007 and Macros
One feature that might be surprising to many experienced developers is the re-invigoration of macros in Access 2007. We have done a bunch of work in this area that we think benefits end users and developers in some scenarios. If you are running Access 2007 you will notice macros are used extensively in our templates and the button wizard and switchboard manager creates embedded macros.

History of Macros
Many people think macros were a predecessor to Visual Basic, but it turns out that they were introduced at the same time. However, they have different goals. A large majority of knowledge workers are intimidated and frightened by free-flowing code, but they are more comfortable with using a structured grid such as the macro designer. We found that there are many scenarios where users are very successful "programming" using macros. Macros target a broader audience of Access users that don't have the skills to drop into VBA and write code. Yet, these users are very successful picking an action and setting a couple parameters. This is why many applications built by knowledge workers are loaded with all sorts of macros.

Unfortunately, the Access team has not focused on knowledge workers for a long time. We have traditionally been more developer focused, so our macros have not received much attention. One of our goals for Access 12 has been making the product easier to use by a broader audience (while still delivering features relevant to developers). We think there are many knowledge workers that are tracking information in Excel that could be more appropriately stored in a database. As you can tell from previous posts, Access 2007 has more new knowledge worker features than previous releases. I also think there are some nice enhancements for developers building bigger applications.

There are a number of things we did to improve the macro experience.

Embedded Macros
Just like you can save a SQL Statement in the Row Source or Record Source property, you can now save a macro in any event property. These are called Embedded Macros. Similar to SQL Statements, you can use Save As to create a standalone macro that can be reused. One nice thing about Embedded Macros is that you can copy/paste and "Open Form" button and just change the form name that it opens, and you are done.

When you think about templates and renaming objects--name fix-up becomes really important for users that want to start with one of our templates and modify it to more closely reflect their business. In this case, it is far easier for Access to perform name fix-up operations on macros than try to fix-up code. Think of the scenario of renaming the Contacts table to Employees in the Issues template. Many customers will want to do that—It would be really hard for us to do all the right things if all the logic was expressed in code.

Macro Sandbox
The biggest thing that we added to the macro architecture was the concept of a "sandbox". Certain actions can run even when a database is not trusted. You can think of these macros like expression or formulas in Excel. VBA can never be trusted, so it never runs in an un-trusted database, but you can now use macros to build simple applications that are fully-functional without having to trust the solution. This was our goal for templates. They will leverage these macro that are allowed even when the instantiated template is not trusted.

The Show All Actions button switches the contents of the drop-down list in the Actions column between all actions and only the actions that are allowed in databases that have been trusted. The yellow warning sign in the record selector indicates the action won’t execute unless the database is trusted.

(Click image to enlarge)

Variables and TempVars
We also introduced temporary variable that are accessible via VBA and macros. TempVars are designed to store variant data that is transient in nature. Think of them as global variables that work across the whole product—anywhere there is VBA or an expression. They are exposed as an enumerable collection off the Application object. There are two properties Name and Value and two methods Remove and RemoveAll.

There are four new macro actions associated with TempVars:
(1) TempVars![Name]returns the variant value that was stored.
(2) SetTempVars(Name, Expression) allows macros to set a TempVar to a given value.
(3) RemoveTempVars(Name) removes the TempVar from the store.
(4) RemoveAllTempVars empties the TempVars store.

Here is an example of TempVars in use in a macro:

(Click image to enlarge)

Error Handling
One of the key weaknesses of macros in the past is the inability to handle errors. Well, that is not longer true. We added an OnError action that is similar to the On Error statement in VBA. OnError has three different settings:

(1) 'Next', which is equivalent to "On Error GoTo Next" in VBA, and allows you to keep on running the macro while ignoring AND suppressing all errors.
(2) 'Fail', which is similar to “On Error GoTo 0” in VBA, will revert error handling to the default behavior of having macros fail completely on hitting any errors executing actions.
(3) 'Macro Name' is directly related to the 'Macro name' parameter. This allows you specify a label on the macro to where the macro will jump if any errors are found. This is very similar to the "On Error GoTo " in VBA. You can easily use this to put up your own error messages:

OnError (Macro Name, "Error")
OpenForm (Form, "Form1", …)

Error: MsgBox ("Error: Custom message", …)

Button Wizard
One frequent complain that we hear about Access 2003 is the lousy code the button wizard generates.
For example, if you create a “Record Operations > Print Record” button, this is the VBA it generates:

Private Sub cmdPrintRecord_Click()
On Error GoTo Err_cmdPrintRecord_Click

    DoCmd.DoMenuItem acFormBar, acEditMenu, 8, , acMenuVer70
    DoCmd.PrintOut acSelection

Exit_cmdPrintRecord_Click:
    Exit Sub

Err_cmdPrintRecord_Click:
    MsgBox Err.Description
    Resume Exit_cmdPrintRecord_Click

End Sub

How do you like the DoMenuItem action? Yeah, I have memorized what the 8 means…

Here is the equivalent embedded macro:

RunCommand (SelectRecord)
RunCommand (PrintSelection)

All the commands in the button wizard will now generate safe macros that execute property in un-trusted databases. We even updated the icons in the wizard!

Macros and Developers
One thing I would be sure to emphasize is the fact that macros behind form controls keep their contents even via copy/paste, whereas VBA events are lost.

As a developer, if you write VBA code to do the majority of the interesting work, consider creating a simple embedded RunCode macro on the buttons that call the VBA code as opposed to VBA events directly behind the buttons. The embedded macro acts as the bridge between the UI and the VBA code. That gives the full functionality of the UI designer with copy/paste as well as the robustness of the VBA programming model.

The new Northwind sample was developed this way where many of the simple open form with a filter functionality is stored in embedded macros. When we needed to do the heavy lifting we used VBA. Turns out there is far less code and the code that is there is more interesting.

The runtime and developer extensions will be FREE!

Clint Covington — Tue, 30 Jan 2007 19:35:00 GMT

This morning we are announcing that the developer extensions and runtime will be available for FREE! In the past, Access developers had to purchase the Visual Studio Tools for Microsoft Office System in order to build and deploy runtime solutions. The product was costly at nearly $800 for the full version and $550 for the upgrade. This really is great news for Access developers.

We are still working on the finishing touches--I don't have a definite release date but rest assured the team is working hard to finish the work.

Here are a couple screen shots and the article. Enjoy!

http://msdn2.microsoft.com/en-us/office/bb229700.aspx

Introducing the Access 2007 Developer Extensions and Runtime

Shortly after the release to the general public of Microsoft Office Access 2007, Microsoft will make available the Access 2007 Developer Extensions and the Access 2007 Runtime. For the first time, both programs will be available as FREE downloads.

Access 2007 Developer Extensions

Package Solution
This is a wizard that will create a Windows Installer Package (MSI) to install your database, any supporting files, and optionally include the Access 2007 Runtime or prompt the user to download the Access 2007 Runtime.
Save As Template
This allows creating database templates (ACCDTs) that can be featured in the Access 2007 Getting Started screen.
Source Code Control
Integration with Microsoft Visual Source Safe or other source code control systems to allow check-in/check-out of queries, forms, reports, macros, modules, and data. You can also see the differences that have been made to your checked out objects.

The Access 2007 Developer Extensions will not include the Property Scanner and the Customer Startup Wizard that were included in previous versions.

Microsoft Office Access 2007 Runtime

Access 2007 provides a rich platform for developing database management solutions with easy to use customization tools. If no end user customization is required (including report modifications), you may choose to distribute those Access 2007 solutions so that they run without requiring a full installation of Access 2007. You must package and distribute your application with the Access 2007 Runtime. The Access 2007 Runtime is similar to previous runtimes in that all design-related UI is either removed or disabled. However, there is one major change: we will be offering the Access 2007 Runtime as a free download, just like we have done for the Snapshot Viewer in the past. You will not need to buy any special SKU in order to redistribute the Access 2007 Runtime. You can freely redistribute it or just point people to the download on Microsoft.com.

Download Locations

Links to the download locations will be posted on Office Online and the Access Developer Portal on MSDN, when available.

New SQL editing and versioning tool for Access

Clint Covington — Fri, 26 Jan 2007 21:43:00 GMT

I just got an email from Andrew Wrigley, an member of the UK Access users group, about a new tool he has developed for editing SQL. You all might find this interesting--Access SQL editing tools are so lame. I haven't used it but the screen shots look super interesting.

Wingspan Swift SQL is a SQL Editing and Versioning tool for Microsoft Access. It brings SQL editing out of the dark ages and into the 21st century and makes up for Visual Source Safe's lack of versioning for individual Access queries.

It formats SQL strings to make them readable by humans, Find and Replace, 'intellisense' for table and query field names, you can add comments to SQL, you can test changes without overwriting the current SQL of your query, store multiple versions of each query and much, much, more.

You can review it (video tutorials, etc) at:

http://www.wingspan.info/Products/SwiftSQL/

It works with Access 2K +, and uses com Add-In technology to make itself available directly from Access' interface. (I need to adapt it to the Ribbon, but it works fine in Access 2007).