Jeremy Kuhne's Blog : All Things Acrylic

Interop with Office

jkuhne — Wed, 25 Jan 2006 06:15:00 GMT

Before I dive in, I've put together a simple doc showing how you can liven up the clip art in Office using Graphic Designer that you might find of interest.

The other "feature" that was included in the current CTP of Expression Graphic Designer (EGD) is better interop with Office apps. EGD now has vastly better support for importing WMF/EMF files and clipboard data. In addition, if you want to pull out the original source image for a graphic in Office you can do so through the "Office Image" selection in the Paste Special menu item.

These were both done by me a few months ago as I grew frustrated with trying to get content back and forth between Office. There is a lot of strangeness that occurs that makes the experience less than stellar. To help shed some light on the situation I'll run through exactly what happens in the rest of this post.

When you copy from EGD a BMP, PNG, GIF, and JPG are put on the clipboard at the current resolution of the document. PNG is particularly useful with Office applications as it supports transparency. The first strangeness is that if you paste into Office you get a different default paste depending on the application you are in. In the case of Word you do not get PNG by default and as such you must paste special to get the PNG. In PowerPoint, however, you do get the PNG by default.

Where things get particularly ugly is when you copy out of Office. Office will always render graphics at your screen resolution (typically 96dpi). For me, at least, this usually ends up looking horrible. A great example is taking a screenshot out of a PowerPoint presentation.

To get the original image out of Office you hit the second strangeness... In Word it isn't possible (afaik). If you want to get the image out you must first copy from Word and then into PowerPoint where you can save the original. (There are more differences with the other Office apps. I'll only detail Word/PowerPoint here for now.) In PowerPoint if you right click on a graphic and select "Save As Picture". Depending on the source you may get a drop-down arrow on the "Save" button that will let you "Save Original Picture".

Since Office obviously keeps the original PNG I thought it would be much better to grab that if it were at all possible, which fortunately it is. If you copy an image out of Office you will get the new paste special selection of "Office Image" as previously described. The image will be inserted as an image object that will be sized the same as the object in Office with the full DPI of the backing image. (Rotation is something we might support later. Some other special features such as drop shadows might be added if there is enough interest.)

If you take things back into Office again you'll rasterize at the doc DPI as stated earlier. It is best, of course, to keep XPR files around for any content you send to Office.

Office drawings (AutoShapes, WordArt, etc.) are put on the clipboard as EMF, so you're best off pasting special in EGD as this format. (Same goes with WMF/EMF clipart.)

(This brings up an interesting little side effect that you can take advantage of in Office. If you copy an Office object that normally doesn't antialias such as a chart you can get antialiasing by making a few in-app conversions. Take a chart, copy, and then paste as EMF back into the Office app. After pasting as EMF right click and select "Edit Picture". You now have an antialiased copy of the original!)

I intend to make the experience a little more transparent in the future if at all possible. I'll be looking for any and all feedback on what would make life easier for you. In addition, if you have any WMF/EMF content that you can't get into EGD, please let me know and I'll take a look. A metafile is simply a collection of Win32 drawing commands, which makes it pretty broad in theory. In practice, however, not many calls are supported by apps that output metafiles. Your input will help me prioritize.

New versions of Expression Graphic Designer and Interactive Designer available!

jkuhne — Tue, 24 Jan 2006 23:07:00 GMT

Our January 2006 CTPs are available! http://www.microsoft.com/products/expression/en/default.mspx

What's new??

We've got official names now. (Acrylic => Graphic Designer; Sparkle => Interactive Designer)
Interactive Designer is publicly available for the first time!
Exporting to XAML from Graphic Designer (EGD) has been greatly improved.

The XAML exporter is the only real new feature for this CTP for EGD.

[There is, however, something important buried in there if you do any sort of interop with Office apps. I'll post about it later today, so keep an eye out. ;)]

New version of Acrylic available for download!

jkuhne — Mon, 17 Oct 2005 06:35:00 GMT

I encourage you to take a look. We've done a lot to tighten things up since the last release. We're still hard at work, so any and all feedback is greatly appreciated. (Links to the newsgroup can be found on the site.) http://www.microsoft.com/expression.

Expression on Channel9

jkuhne — Wed, 14 Sep 2005 22:42:00 GMT

A nice video that will give you a bit of what's going on with Expression.

http://channel9.msdn.com/Showpost.aspx?postid=115387

How suite it is: Expression!

jkuhne — Wed, 14 Sep 2005 19:44:00 GMT

http://www.microsoft.com/expression

It's a great relief to finally have this out in the open. There's a suite on the way, folks, and we're working hard every day to pack as much cool functionality in as we can for you.

Take a look at the web site, download the Acrylic preview! We're eager for feedback!

[Modified 2/17/2008: removed dead picture link]

New Version of Acrylic Available!

jkuhne — Tue, 16 Aug 2005 00:38:00 GMT

I'm happy to report that the August 2005 Community Technology Preview is live on http://www.microsoft.com/products/expression!

There are a number of videos and feature details at http://www.microsoft.com/products/expression/features.aspx.

Have fun!

[Edited 2/17/2008: Removed dead picture link.]

Acrylic Automation: Crossing the Barrier

jkuhne — Sat, 11 Jun 2005 17:10:00 GMT

Ok, so I really was chomping at the bit to blog. Now that we've gone beta I can get a lot of things off of my chest. Just too awkward to blog much before the product was announced, you know? In this post I'm going to give a bit of info on how to write a managed dll that interops with unmanaged code. (FYI: I can't really give the explicit details on how to access the Acrylic automation interfaces at this point.

This is going to be in Managed C++ in 2005. I've mentioned before that it blows P/Invoking out of the water. The syntax is radically different than the Managed Extensions for C++ that was in VS.Net and is really remarkably easy to read and use for those who know C#, so be strong! ;)

Making a project managed in C++ is simply a matter of setting the /clr switch, which you can get to in the project properties panel under "Configuration Properties: General: Project Defaults: Common Language Runtime support". There are some variations of this switch that are pretty well documented and I won't go into them here. Our configuration type is "Dynamic Library (.dll)", of course. (This is in the same properties area.)

We include the standard <windows.h> header and windows version pound defines as we need access to the Win32 api in a number of places. Here's a simplified code snippet that shows you how things work:

// Plugin.h

// You need to include the relevant headers for the interfaces you're trying to hit.
// This would be defined by the App you're trying to interact with.
#include "AppPlugginInterfaceHeaders.h"

extern "C" // Or "C++" whatever your application uses
{
   //
   // The application plugin entry point.
   // The __declspec(dllexport) specifies that this function should be exported.
   // IApplicationPluginHost is defined in the header provided by the app and included above.
   //
   __declspec(dllexport) bool PluginEntry(IApplicationPluginHost *hostAPIs);
}

// Plugin.cpp

// Or wherever else you have your windows includes if you do.. #include "Stdafx.h" #include "Plugin.h"
__declspec(dllexport) bool PluginEntry(IApplicationPluginHost *hostAPIs) { // Code to check and save the interface passed back from the application. }

That's pretty much the sum of it. From there it's using the host api pointer to grab other interfaces and access functions through those interfaces. So something like hostAPIs->SomeFunction(). We do also have a DllMain (which must be unmanaged according to the SDK) to do some thread initialization that is very app specific in our case. (This would be DLL_THREAD_ATTACH and DLL_THREAD_DETACH message processing.)

In case you're curious, putting completely unmanaged code in your /clr app requires a #pragma managed(push, off) statement before said code and a #pragma managed(pop) afterwords.

Automating Acrylic

jkuhne — Thu, 09 Jun 2005 23:30:00 GMT

Here's the first of many posts to come out of what I've learned and experienced attempting to automate Acrylic.

As mentioned before and elsewhere, Microsoft acquired Creature House a few years ago. With this acquisition came the creative design toolset Creature House Expression. We've been working on a new version of the application and one of the challenges I faced in testing the application was finding a way to automate it.

Acrylic is a pretty large unmanaged codebase (the executable is about 10mb) with a wide variety of features. When I started working on it the application did not have automated tests running against it or an api to write tests against. We intended to change this, but the route to take took some effort to discern. Acrylic has a number of custom controls that aren't actual Windows controls (no HWND of their own). It also has standard Windows controls (in dialogs, mostly). To complicate matters, the application swallows modifier keys in mouse and keyboard messages. We really couldn't use any "off the shelf" solutions.

An api was added to the application to load & run automation dlls and expose internal state (through interface classes) and provide a method to send modifier keys with input messages. The question as to whether to write unmanaged C++ code directly against this api or put some sort of wrapper layer in to let most of our test code be written in managed code.

I pushed very hard to write as much of the test automation as possible in managed code. Why? Well, reliable code would be easier to write with the managed safety net. I didn't want to be spending too much time worrying about things like pointer "accidents" in the test code. In addition, there is a great deal of effort and experience being built up with managed tools that take advantage of things like reflection, generics, etc. Another very important thing to me was to be able to easily utilize help from others that could whenever the opportunity arose.

We did ultimately go with pushing towards mostly managed code. Visual Studio 2005 made this very possible. Here's how we did it:

We wrote a Managed C++ dll to interface with the internal test interfaces and expose those interfaces in a managed way. Our test libraries and test cases are in seperate dlls (C# mostly, some VB.Net tools). A managed harness kicks off the application with automation enabled (standard shell execute pretty much). The application loads the managed C++ dll (not knowing it is managed) and tells it to kick off tests. The dll tells the test harness to kick off tests. The test harness then starts executing attributed test methods as specified in a configuration file.

Works like a charm. Writing the interop code in the new managed C++ is incredibly straight forward. It's so straight-forward that once I learned how to really use it I threw out some 14,000 lines of Win32 interop code I had written in C# and rewrote the entire thing in managed C++ (made it much better and it took about a week and a half or so). P/Invoke is just way too painful by comparison once you've seen how well the new C++ interops.

I plan to spend some time here writing about utilizing the new C++ with a particular bent towards interoping with Win32. I'll also talk about other things that I've had to deal with that don't seem too particularly well documented yet (such as the new generic collections and anonymous delegates). If there is anything you're aching to see I'm open to feedback and will direct my efforts towards hitting the things people are interested in.

Acrylic has gone live!

jkuhne — Thu, 09 Jun 2005 20:29:00 GMT

[updated 1/31/06 to use new blog photo gallery]

Greetings from within Microsoft! I'm excited to let you know that we've just released the beta for Acrylic, an application for professional graphic designers. Please go take a look, download, and send in your feedback! (http://www.microsoft.com/expression)

(To see some art generated with the application, download and install. You can also see some examples by following the link to previous versions.)

I've been working hard trying to get automated testing running for this application and you can expect to see some posts from me regarding the issues I've faced trying to automate an unmanaged application with VS 2005 (Whidbey). I'll also be posting information about the Acrylic application itself. If there are any specific topics feel free to suggest them.