Welcome to MSDN Blogs Sign in | Join | Help

Outlook Gadgets Now Available

I’m happy to announce that tonight the first two official Office gadgets went live on gallery.microsoft.com!  If you’re running Windows Vista and Outlook 2007 then I encourage you to go out and download the gadgets and get the experience of the Outlook To Do bar from the Windows SideBar.

I take a special interest in these because I was closely involved with the development effort and getting these gadgets out for everyone to use.  Thanks to the efforts of Melissa, Ted, Kent, and Radu for helping make these available.

Links to the gadgets:

Posted by rgregg | 15 Comments

VSTO 2005 SE & Outlook Form Regions

I just noticed that TQ posted a sample VSTO 2005 SE add-in for Outlook 2007 that implements form region handling. I know a number of developers in the Outlook community have been looking for a good sample on how to build a VSTO add-in that uses form regions since simply implementing FormRegionStartup on the ThisAddin class doesn't work. If you are struggling to figure out how to make this work, I'd encourage you to go over and take a look at his sample and implementation notes.

Posted by rgregg | 0 Comments
Filed under: ,

Converting Bitmaps to IPictureDisp

If you're writing your Form Region solution in managed code, and you decide to provide the manifest information as a resource in the add-in, you'll need to return all of your icons for the form region in a format Outlook knows how to parse. Unfortunately, Outlook doesn't handle the managed code types System.Drawing.Bitmap and System.Drawing.Icon so you need to find some way to convert these types into something Outlook does understand. There have been a couple of examples of how to convert a Bitmap or Image to an IPictureDisp, but I haven't found anything on how to make this work for Icon and actually preserve the format as an Icon (without converting to Bitmap first).  Outlook is very picky about the type of IPictureDisp objects it expects.  If you are providing an icon to be used in a view or window, you need to provide an IPictureDisp with a subtype of Icon.  If you are providing an icon for the Ribbon, you should use a Bitmap subtype.

Thomas Quinn on the VSTO team came up with two extremely useful class files that make this super easy: one for C# developers and one for VB.NET developers. Just add the code file to your project, and then call the PictureDispConverter.ToIPictureDisp() and provide the Bitmap, Image, or Icon object and the method returns an IPictureDisp object you can send back to Outlook. The advantage to using this class is that it actually outputs different types of IPictureDisp based on the input format, so you don't need to convert an Icon to a Bitmap type first.

PictureDispConverter.cs
PictureDispConverter.vb

Posted by rgregg | 2 Comments
Filed under: ,

Post B2TR Changes for Form Regions

Shortly after we released Outlook 2007 beta 2 technical refresh to the world, we took a change on the Outlook platform to enable a new method of retrieving manifest and icon information for Outlook form regions. The reason for this change was partially due to customer feedback we received during the beta, that add-in developers didn't like needing to write some files to the disk, while others could be included as resources.

Unfortunately, this change required adding two additional methods to the FormRegionStartup interface defined in the Outlook type library. The end result of this change is that when the final version of Outlook 2007 is released, some solutions that compiled and ran against Outlook 2007 B2TR may need to be updated before they will compile against Outlook 2007 RTM.

While you will need to update any solution that uses form regions in order to compile it against Outlook 2007 RTM, existing solutions that were previously compiled should continue to run successfully on the RTM build even with this change. The additional functions were added to the end of the interface VTable and thus won't interfere with the existing methods provided in B2TR.

Using the New Methods

The two new methods added in the RTM builds are:

  • public object GetFormRegionManifest(string FormRegionName, int LCID)
  • public object GetFormRegionIcon(string FormRegionname, int LCID, Outlook.OlFormRegionIcon Icon)

GetFormRegionManifest expects a string containing the manifest XML to be the return value. If anything else is provided, the form region will not load.

GetFormRegionIcon can return either a byte-array that represents the original bytes of the image file, or an IPictureDisp object. For more information on how to convert a .NET Image or Bitmap over to IPictureDisp, check out this article on the VSTO blog.

Outlook will only call these methods on the interface if we find a the registry entry that previously was required to point to a file path or include inline XML now contains the ProgID of an add-in installed in Outlook, prefixed with an equal sign (=). For example, if your add-in was named "OutlookAddin1.Connect", you could write the following value in the registry: "=OutlookAddin1.Connect" and Outlook would then call these functions to request the manifest information for the form region.

These are a few changes worthy of pointing out when using this method:

  • The <name>, <layoutFile>, and <addin> elements of the form region manifest are ignored when provided via GetFormRegionManifest. The form region name is the name of the registry value for the form region, and we already know the ProgID of the add-in.

Child elements of the <icons> element should either be empty elements (like <page/>) or should contain the word "addin" if Outlook should call GetFormRegionIcon for that icon. When the add-in provides the manifest, all icons must be provided via GetFormRegionIcon and cannot be pointers to a file path.

If you have any questions about the behavior of these new methods, please comment on this post. I'd like to make sure that this isn't a big surprise for anyone working in the form region space when we ship Outlook 2007. I'll also be updating our form region samples to implement and use this new method when we release the RTM versions of our sample code.

Posted by rgregg | 24 Comments
Filed under: ,

Beta 2 Technical Refresh

I'm always late on posting these announcements, but as of Sept 9, the B2TR release of Office 2007 is available on the MS download site.  B2TR is available only as a patch to Office 2007 beta 2, so if you already have that installed don't start uninstalling it yet.

If you haven't downloaded Office 2007 beta 2, it's not too late.  You can download the bits still from the Office system preview site, however due to the number of downloads we've seen already, we're charging a small fee for the download (sorry!).  You can also order beta 2 on CD via mail.  Of course, if you do download or order beta 2, make sure you install B2TR right away!

I strongly encourage any and all ISVs to download and try out these bits.  B2TR is extremely close to what will be shipping when Office is released, with only minor changes in situations where major scenarios are blocked or broken.

Posted by rgregg | 4 Comments
Filed under:

Third Party Add-ins and Outlook 2007

While we spend a great deal of time and effort to ensure that the Outlook platform is 100% backwards compatible with previous versions of Outlook, occasionally add-ins do something unexpected, or use the platform in an unexpected or undocumented way.  These add-ins can misbehave and cause problems when running against a new version of Outlook (such as Outlook 2007) where they have not been fully tested by the software developer.

Many beta testers found this out the hard way during the Office beta 2 release when some very popular add-ins caused Outlook to crash unexpectedly while sending mail or performing other common tasks.

I've been working closely with a number of ISVs and software developers to ensure that these problems are fixed correctly.  Sometimes we've broken the way something works and we have to fix it on the Outlook side.  Sometimes the problem lies in the way the add-in works and the add-in needs to be updated.  Often this means that the end user needs to disable the add-in until a new version is available.

Because add-in release cycles are not necessarily tied to Office/Outlook releases, this can cause a problem for some users.  In the interim between when a new version of Outlook is released and add-ins are updated, you may need to disconnect an add-in to continue to use Outlook effectively.

To Disconnect an Misbehaving Add-in:

  1. Start Outlook.  If you cannot start Outlook because an add-in is causing it to crash immediately, you should be prompted to disable the add-in (in B2TR or later builds), otherwise use the command line outlook.exe /safe to boot in safe mode.
  2. From the Outlook window, select the Tools menu, and then Trust Center.
  3. Click on the Add-ins tab, and then click the Go button at the bottom of the page.
  4. Disable one or more third party add-ins listed in the dialog.  If you were directed here from a crash report, you should have seen information on which add-in was responsible for the crash.  Find that add-in and uncheck the box next to the add-in.
  5. Click OK.
  6. Restart Outlook.

To Enable a Disabled Add-in:

If you're a developer working on an add-in, and Outlook has disabled it, or you are a user who wants to try an add-in again that was previously disabled, you need to access the Disabled Items dialog to enable the add-in.  While you can access this from the Trust Center via the Add-ins tab, the easiest way in Outlook is to select the Help menu, then Disabled Items.  Find the add-in on the list of disabled items, select it, and click the Enable button to enable the add-in again.

Keep in mind that if the add-in was disabled, it's likely because Outlook believes the add-in is misbehaving.  There are some add-ins that are disabled immediately when Outlook is installed, and others that are disabled because Outlook detected a problem.  In all cases, you should only enable an add-in again if you are sure that it is not causing any problems in Outlook.

 

Technical Details for Changes in Beta 2 Technical Refresh

If you aren't a developer or a technophile, I suggest you skip this part.

In response to a number of third party problems we've seen during the Beta 2 release of Outlook, we've made a change to the add-in resiliency logic that Outlook uses.  Early in the Outlook 2007 release cycle, we decided to make a change to the way Outlook handles errors from installed add-ins.  Previously Outlook would catch exceptions from add-ins and silently ignore them.  This prevented Outlook from crashing immediately, but Outlook usually would crash later because memory somewhere had become corrupted, and it was just a matter of time before this caused a problem.  For Outlook 2007, we now crash immediately when the add-in throws an error, allowing us to better understand the root cause of the failure.  Instead of crashing later in some random code, we now crash at the actual cause.  However, this change caused Outlook to crash a lot more frequently due to a number of add-ins that expected to be able to throw exceptions without consequence (which is a really bad expectation).

Previously in Outlook 2003, if an add-in caused Outlook to crash while the add-in was being initialized (OnConnection) or disconnected (OnDisconnection), then the add-in could be added to the disabled items list, which prevents the add-in from being loaded or running.  If an add-in crashed later, say in an event handler (the most common place we saw crashes in beta 2), then Outlook would crash, and the add-in would not be disabled.  This meant that it was possible to have a very bad experience in Outlook where every time Outlook boots, it crashes due to a misbehaving add-in.  The only recourse was to use safe mode to disable the add-in, which most users would not immediately discover.

Now, in B2TR Outlook will also perform the same resiliency action if the add-in causes Outlook to crash during an event handler.  Outlook will still crash, but upon the next boot of Outlook, you will be presented with a dialog asking if you want to disable the add-in.  This way, users who are seeing a large number of add-in related crashes in beta 2 should only see a couple of crashes in beta 2 technical refresh because the add-in can be disabled easily by the user (and we default to disable if the user accepts the prompt defaults).

Posted by rgregg | 8 Comments
Filed under: ,

Blog Q&A

A while back while I was taking about forms, I got a number of questions from readers out there in web land who wanted to know more detailed answers to some questions. I haven't been ignoring you, I promise, but we've been super busy getting Office 2007 beta 2 technical refresh ready for public consumption. Now that the B2TR bits are basically done, I've got a few free minutes to get back to answering questions and blogging in general.

Previously I was discussing some of the new forms technologies in Outlook we've dubbed 'form regions'. Form regions are designed to make it easier to do the kinds of UI customizations most developers have been trying to accomplish without the overhead involved in redesigning an entire Outlook form and worrying about how to publish it to Outlook. While I was on that subject, I got a number of questions, which I will now answer.

[Note, some of these questions have been edited to be more concise (or to actually be questions)]

Q: Is there a future for the Outlook view control (OVC)? If there is, include it with Outlook and make it easier to work with.

Well, the short answer here is that the control is of course still shipping in Outlook 2007. However, we did not make any significant investments to the OVC for this release. The OVC has been included as part of the Outlook installation since Outlook XP (for Outlook 2000 it was a web download). We are evaluating the needs of our platform and how we can improve the OVC, so if you have any scenarios you are trying to accomplish today where the OVC is falling short, please let us know.

Q: Have the form controls been improved?

Totally. We realized very early on in the 2007 release that our forms were starting to look dated and we needed to clean up their appearance. As part of the form region effort we created new Outlook controls (Olk* in the type library) that are more modern versions of the form controls previously available for custom forms. We also created a bunch of new controls that provide functionality available in Outlook, like the business card preview, date/time pickers, info bar, category, and page controls. These new controls when used on form regions enable a form designer/developer to really replicate the look and feel of the Outlook interface without needing to clone the interface in your own custom controls.

Q: Is the IDE for form script any better?

While we haven't improved or changed the script editor component that is used for 'legacy' custom forms, form regions are built using a whole new model. Instead of writing code inside Outlook that is embedded as part of the form, form regions rely on an add-in to provide the business logic behind a form region. This means that you can use your favorite programming language and IDE as long as they support building a COM add-in. With form regions you can use whatever language you prefer to back your form. You can read more about how to make this happen in my MSDN article "Building an Outlook 2007 Form Region with a Managed Add-In". We're also working closely with the Visual Studio Tools for Office (VSTO) team to further improve the story for the Orcas release, but details of what may be available in this release are still TBD.

Q: How do you envision people debugging code on forms?

Script debugging has been a painful process for forms developers. Fortunately, since Outlook 2007 form regions no longer use script, but instead use an add-in, the debugging experience is much improved. You can debug a form region in exactly the same way you would debug an Outlook COM add-in, using Visual Studio or another IDE. Just attach to Outlook (or just run your project if you are using a VSTO-based add-in), insert breakpoints, watches, etc, and wait for an error to occur. If you're using Visual Studio 2005 and managed code for your add-in, you can even do edit-and-continue, just like with other managed code.

Q: Do you see people continuing to use Public folders?

I think it should be clear that public folders will continue to play a role in the short term future. However, if you look at the direction Exchange 12 is moving, you'll see public folders are now an optional component to the Exchange system. For Outlook 2007 we've converted a lot of features that used to rely on public folders over to using web services or found other mechanisms for replacing the functionality of public folders. Custom solutions that depend on public folders will need to start being migrated over to other technologies as well, because public folders are a legacy technology that are on the way out. Using SharePoint may be one good way of migrating a solution, but other alternatives as also available. One of the reasons we developed the form region technology was to allow organizations to have form solutions that didn't depend on the Organizational Forms Library (which uses public folders) and still be able to relatively easily deploy forms across an organization.

Q: Was work put into improving custom forms management/deployment?

Outlook 2007 maintains the functionality provided by Outlook 2003 for custom forms management and deployment via Outlook. However, our form regions are designed to work differently. Instead of using a forms library that needs to managed inside Outlook, form regions are registered via the Windows registry and XML-based manifest files. For deployment, form regions are designed to use any installer technology you might use for an Outlook add-in, such as Windows Installer (MSI) or ClickOnce deployment. Since form regions are tied closely with add-ins, they do not live in the forms cache and are not subject to the issues around forms cache corrupt that occasionally caused issues for our custom forms in the past.

Q: OWA/Mobile. Design once, run everywhere is a definite necessity, will this story be improved?

For Outlook 2007 this story remains unchanged. There are some big issues to face, like how a form that looks good for a desktop client can be useful on a mobile device with a much smaller screen or as a web form. There are also issues around the replication of properties between desktop Outlook and mobile devices. However, I believe these are solvable problems, and for the next release of Outlook I hope we can spend some time in this space and improve the story over what we currently offer.

Q: Is WYSIWYG forms printing supported in Outlook 2007?

Outlook 2007 still maintains the status quo for printing support of custom forms. However, there are a few third party solutions available for Outlook 2003 that provides this support, and it's definitely something that a form developer can implement using a few Windows APIs. I hope for the next release that we can address this concern and improve the support for printing custom forms.

Q: Progress and Excitement. Do you think there is a REAL commitment within the Outlook team for extensibility?

There is a very real commitment on the Outlook team for extensibility. For Outlook 2007 we've actually doubled the number of classes defined in the Outlook type library, flushing out a huge range of new functionality that previously wasn't available. For the next release we're already looking into how we can continue to expand on what we've done in this release and make the platform easier to work with and friendly for developers, and also allow developers to do more with Outlook. For Outlook 2007 we've had two program managers and a team of developers and testers working to improve the object model, so we are definitely committed to improving extensibility. Randy Byrne and I are also working on a new Outlook programmability book which we hope to have available close shortly after Office 2007 is available.

Q: Other questions relating to Exchange extensibility.

Unfortunately I'm rather disconnected from what is going on over in Exchange extensibility. I'll have to follow up in another post on these questions. In the mean time, readers may want to direct those questions to the Exchange team blog, "You had me at EHLO".

 

That's it for the questions I have right now. I've got a few other blog topics I hope to get to shortly, but as usual my time is scarce. I hope to be more prolific with my posts in the near future, especially as the beta 2 technical refresh becomes available. In the mean time, I hope you have a great Labor Day weekend!

Posted by rgregg | 2 Comments
Filed under: ,

Nearly a Month

It's been nearly a month since my previous post about the shutdown fixes for Outlook 2007, and I should appologies for not having anything useful to add to the blog today.  However, I've been busy working on content for a new book on Outlook programmability that will be coming out eventually.

In the mean time though, I've been working on a sample of a managed code preview handler that integrates with Outlook 2007 to show how you can develop one of those, and that will be the topic of a future blog post.  I've also got a couple of other posts planned, but I'm interested in what you, my loyal readers, would like to hear more about.

Do you have anything in the OM today that is confuses you?  Unsure how Ribbon works with Outlook and want to know more?  Want to know more about how form region layout works?  I know there have to be good questions that have gone unanswered out there, and I'd be happy to see what I can do to fill the void in getting these answered.

Of course, don't ask me to write your solution for you.

Posted by rgregg | 1 Comments
Filed under:

Outlook Shutdown and COM Add-ins

Depending on how familiar you are with Outlook development, you may have seen previous versions of Outlook occasionally had a problem shutting down. Often there could be a catch-22 situation, where the add-in was waiting to hear from Outlook that it should clean up its references, and Outlook was waiting for these references to be released before notifying the add-ins that it was shutting down. In previous versions, Outlook only paid attention to the number of references for the OM objects, and not if those references were held by add-ins.

For Outlook 2007, our developers spent time investigating the problem, and came up with a fix that has caused the shutdown issues for Outlook to largely disappear, even when running managed code add-ins. There are, of course, a few limitations to what can be done, so it's important that Outlook add-in developers understand what this work buys them and what they still need to do to ensure an add-in solution doesn't keep Outlook alive.

Outlook now keeps track of references which it knows were handed out to an Outlook add-in. References provided to an add-in and those derived from objects provided to an add-in are tagged as belonging to that particular add-in. When the UI is closed and the only remaining references are tagged as blonging to add-ins, Outlook will shutdown. If a reference tagged for an add-in is marshaled out to another process, these references can be disconnected from under the application when Outlook shuts down.

There are a few scenarios through which Outlook can lose track of an add-in reference on an object. For instance, accessing Outlook objects through non-Outlook libraries, such as returning a reference to the Application object through the command bars OM (accessing properties like Application or Parent), can cause the context to be lost. We've done work to improve the way this works with some new Office APIs to make sure that the context is not lost. For example, when working with the ribbon UI integration, objects provided in ribbon callback methods will still be in the context of the add-in. Likewise, using the new Custom Task Pane OM provided by Office will not get you in trouble either.

Another possible scenario is if the add-in creates a new instance of the Application object (new Application() or calling CoCreateInstance) and then marshal this object (or derived objects) to another process or thread. Outlook will be unable to track these objects as belonging to an Outlook add-in. When the reference is marshaled to become a strong external reference, Outlook will not shut down properly until the reference is cleaned up. Technically speaking, Outlook will remain alive if there are external connections registered through the IExternalConnection interface of COM on any OM objects.

These changes to our shutdown logic apply only to add-ins and internal references. The behavior for COM callers outside of the Outlook process space hasn't changed. Programs that CoCreateInstance the Outlook Application object can expect that Outlook will remain alive, even if the user attempts to quit the process, until those references are released as long as these references appear to be external connections to Outlook.

The benefit of these changes should be pretty clear: COM add-ins will no longer need to implement some kind of shut down workaround which was previously a popular sight in any Outlook add-in code. The change also lowers the bar to writing a COM add-in that doesn't break Outlook. New Outlook developers won't need to know about any sort of hacks or workarounds to make sure Outlook shuts down in the appropriate way. They can rely on seeing the OnBeginShutdown and OnDisconnection methods be called as Outlook prepares to shutdown and actually shuts down.

Final note: Developers shouldn't use this as an opportunity to be lazy though. You should continue to write clean code that properly cleans up and releases your references whenever the add-in has finished using that object. Cleaning up references to Outlook objects is important for memory utilization and performance implications. Each OM object reference kept alive also requires Outlook to keep the internal representation of that item alive, including any server connections required by that object. This can produce exceptions under unexpected conditions that can be avoided by properly releasing these objects when the add-in is finished with the object.

Posted by rgregg | 6 Comments
Filed under:

Updated Developer Help

Are you developing a solution using Outlook 2007 beta 2, but frustrated by the lack of available documentation in the developers reference? I've got a deal for you then. We've recently posted updated developer content for the beta 2 release, with a bunch of help topics that didn't make it into the packaged download. You can download and install this update and get the latest and greatest developer content for the beta 2 release, a large portion of which was not included in the box for beta 2.

I really encourage anyone out there looking at developing with Office 2007 beta 2 to download and install this extra content.

Posted by rgregg | 0 Comments

New articles and more

If you've been watching the Outlook developer portal recently, as of last Friday you noticed some new technical articles went live.

My first MSDN article, "Code Security Changes in Outlook 2007" went live. This document discusses some of the changes around the object model guard and code security that we've made for Outlook 2007. It also includes a list of blocked/guarded members in the object model for 2007.

Also posted last week was the beta 2 version of our sample add-ins. These samples have all been updated to be fully compatible with Office 2007 beta 2, and are a great resource for learning about some of the new extensibility areas in Outlook 2007. Randy and I have both worked hard on getting these add-ins developed, tested, and ready for you to start taking a look at. However, there are a few known issues with some of the add-ins, but these issues will not prevent you from learning a great deal about new Outlook extensibility. These add-ins will be updated again around RTM to be compatible with the RTM version of Outlook 2007.

In other news last week, a new version of Visual Studio Tools for Office (VSTO) was announced. The Cypress release, which should be available around the same time as the Office 2007 RTM, provides support for developing managed-code add-ins for some Office 2007 applications.

Also thanks to everyone who stopped by the VSTO booth in the green technical learning center last week at TechEd in Boston. It was great getting to talk with you about VSTO and your Outlook integrations, and learning more about your solutions!

Posted by rgregg | 4 Comments
Filed under:

What’s New for Developers

Randy’s article, “What’s New for Developers in Microsoft Office Outlook 2007” was just published over on MSDN. The article includes our first downloadable sample code for beta 2, which includes the “what’s new” add-in, a collection of sample code snippets that will help developers get up to speed with some of the changes in Outlook 2007.

More articles are coming soon, including updates of the samples we’ve released previously to operate with Outlook 2007 beta 2.

Posted by rgregg | 4 Comments

Office 2007 Beta 2

So I’m a little late to the party here, but as you may have noticed a few weeks ago Office Beta 2 was released. The bits are available for download or on CD by registering on the Office 2007 Preview website. I would strongly encourage all the ISVs and developers who work with Outlook to register and try out your solutions on the Beta 2 bits and send me feedback. We’ve heard only a few issues with programmability so far in beta 2, so the extra coverage from the Outlook development community would be great.

You should also check out the recently updated Outlook Developer Portal page, which we will be updating with the latest information, tips, sample code, and more. We’re working to craft the portal into the first place any Outlook developer needs to go to find out more about developing Outlook solutions, so if you have any suggestions please shoot me a comment.

We’re also working on updated add-in samples that will work with the beta 2 release. While our code samples were previously only available to beta users on BetaPlace, for beta 2 we will be providing the samples via MSDN, and you should expect to see those go live over the month of June, with the first drop of Outlook 2007 focused MSDN articles coming online next week. I’ll be sure to post links to the various articles and samples as they are made available.

If you’ve been waiting to try out Outlook 2007 with Visual Studio Tools for Office, you’ll need to pick up the June CTP of VSTO and give it a whirl. There still isn’t much new for Outlook development, but we’re working closely with the VSTO team to make sure they deliver a great value add on top of our platform.

The whole programmability team has been hard at work and we are all really proud of what we have accomplished. Beta 2 has some rough edges we’ve already been working on, but I think you’ll agree that what we have in Outlook 2007 is a significant step up for developers who wish to integrate with Outlook in a rich and deep way.

One last tidbit: both Randy Byrne and I will be at TechEd 2006 in Boston in a little more than a week. Randy will be presenting more about developing solutions with a consolidated Outlook object model, and we will both be around on the show floor, during “Ask the Experts” and other events for you to pick our brains and find out more about what’s new in the Outlook 2007 platform. We’d also really like to see what types of solutions you are developing for Outlook and what types of pain points and other issues you have with the Outlook platform, so don’t feel like you just need to ask us questions when you see us.

Posted by rgregg | 3 Comments

Outlook on MSDN TV

A couple of weeks ago Randy and I were filmed discussing what’s new in the Outlook object model and extensibility for MSDN TV. Aside from a high level introduction to new features in Outlook 2007, we also drill down into our demo applications and show some source code.

You can watch the video presentation from MSDN TV. Don’t forget you’ll need to turn off your popup blocker to make the transition to the source code demo.

The samples we show in the demo along with a few others will be available on MSDN in the very near future. Unfortunately due to some last minute hold ups, these samples are not yet available. I’ll post again with a link directly to the samples when it is available.

Edit: Fixed an error in the link. Should work now.

Posted by rgregg | 1 Comments

Outlook & MIX06

If you didn't get a chance to see it live, the MIX06 sessions are all available online now.  Christin Boyd presented an excellent demo to an EBay add-in built on top of Outlook using form regions.  The add-in provides a pretty rich Outlook integration that shows all of the auctions you are watching and bidding on directly in a folder in Outlook without just resorting to a folder home page.

BTB015 - Extending Your Experience to the Office

And just incase you were wondering, no, MS employees don't really dress like that on their down time.

Posted by rgregg | 0 Comments
More Posts Next page »