Today I have found the setting in the Community Server that hosts this blog that sets if the whole post or just a summary is published in the RSS feed. It was configured by default to publish only the summary so you got a “Read more…” at the end of an excerpt of each post when using a RSS reader. I tried to find the setting some months ago to no avail and today in a second try and after some searches on the web I have succeded 🙂

For other bloggers with the same problem, there are actually two settings, quite hidden (at least for me):

• In the Control Panel, “Configure” tab, “Post Options” sub-tab, “Display” sub-sub-tab (no wonder I didn’t found it) there is a setting “Use post summaries in RSS” that by default was set to “Yes”. It needs to be changed to “No”. From this moment, the whole content of new posts is published, rather than a summary. Existing posts remain summarized, but you can change them with a second setting:
• When you edit a post, go to the “Publication Settings” tab and there is a setting “Use post summaries in RSS”. By default it uses the general setting above but you can change it individually for each post. I have changed a few of past posts before getting tired…

So, you can now read whole posts with a RSS reader.

Basically you could use three kind of forms in your add-ins:

• Modal forms: these are regular forms that are shown modally and block the UI until you dismiss them. For example, the Options window of Visual Studio.
• Modeless forms: there are regular forms that are shown non-modally. For example, the Find dialog of the old VB6. AFAIK, VS.NET doesn’t use modeless forms at all.
• Toolwindows: these are special windows that can be docked to edges of the IDE. For example, the Solution Explorer, etc.

It happens that modeless forms are tricky: they had some problems in VB6 (like not being minimized along with the IDE) and if I remember correctly they were unable to get the focus (or keyboard input, not sure) in Visual Studio .NET, so using toolwindows is almost mandatory in VS.NET. But my MZ-Tools add-in for VB6/VB5/VBA used modeless forms for some features, using a hack to be minimized with the IDE rather than staying on the screen. The hack involved some call to the SetParent Windows API and some change in the window style. It seemed to work OK, but this month I discovered by chance that when running on Windows Vista with Aero and transparency activated, the modeless windows appear without border at all! The problem seems to be the SetParent call but I have been unabled to fix it, so I have changed all modeless forms to toolwindows (the fix will be available next month). Curiously the only modeless form that I use in the version of MZ-Tools for VS.NET (a progress form for some operations) appears correctly with border using a similar hack. But the bottom line is that modeless forms should be avoided in add-ins: it is much better to use toolwindows.

Today I received in the e-mail a question about how to create a commandbar popup with an image in a Visual Studio add-in. The short answer is that commandbar popups can’t have images but I will ellaborate it here a bit more.

First, we need to define what a commandbar popup is. A commandbar popup is a special button (on a toolbar) or menu entry (on a menu) that when clicked, rather than performing an action like a regular button, it shows new buttons or menu entries. For that reason commandbar popups show an arrow to the right of its caption (>). Examples of commandbar popups in Visual Studio are:

• The File, New menu item
• The Tools, Macros menu item.
• Etc.

None of those commandbar popups have (or can have) an image. You can create commandbar popups as explained in my articles:

HOWTO: Adding buttons, commandbars and toolbars to Visual Studio .NET from an add-in.

HOWTO: Add a popup command bar to the context menu of a code window of Visual Studio .NET.

Now, there are other kind of “popups” and “dropdowns” in Visual Studio:

• The “dropdown combo”. For example, the Configuration Manager combobox in the Standard toolbar, which allows you to select the active configuration (“Debug”, “Release”). Although not very useful for most add-ins, the good news is that you can actually create them with an add-in as Craig Skibo (formerly in the MS VS extensibility team) explained long time ago here: Command Bar Types – Part 2
• The “split dropdown” (I am not 100% sure about whether this is the correct name, but I think it is). This is a special button that appears on toolbars (not on menus) and has two (splitted) zones: a button with an image that when clicked performs some action, and an arrow than when clicked drops down new buttons. An example of this control is the New Project button on the Standard toolbar. If you click the button, you create a new project. If you click the arrow, it shows buttons to create a project, web site, team project, etc. Notice that the image of the button and its associated action reflects the last used button, so this is also a kind of MRU control which wouldn’t be desirable in some scenarios for add-ins (that is, it is not actually like a commandbar popup). AFAIK, you can’t create this kind of control using an add-in although apparently there was some intention from Microsoft to support it (see my comment in the Craig’s post).

In my last post about the new Managed Extensibility Framework (MEF) I mentioned this PDC 2008 session about VS 2010 extensibility whose video is now available:

TL32 Microsoft Visual Studio: Customizing and Extending the Development Environment” by Tim Wagner

I have watched today the video and overall I have liked a lot what I have seen:

• The IDE is moving slowly towards a managed .NET application (it will take several releases, but in this one the shell UI and the code editor is now .NET based using WPF).
• There is a new Drop-In, Light-Up (DILU) deployment approach for extensions where you just drop a component in a special monitored folder so your extension just appears in the IDE. This is very cool.
• 3rd party extensions can now contribute more easily to intellisense/auto completion/tooltips/smart tags stuff and can colorize (or any other WPF effect) the code.
• There will be a new extensions manager to download extensions directly from the VS gallery, with auto-update / disable / uninstall capabilities.
• Internally the extensions are built using the MEF approach.

All that said, it seems that the current CTP doesn’t offer any of that yet (at least mine). We will have to wait until Beta 1. Update: the current CTP offers some funcionality about the new editor (c:\Users\public\documents\CTPWalkthroughs\Visual Studio\Samples).

There are only a couple of things that scare me:

• How well the internal changes in the IDE to handle all this new stuff are going to coexist with current technologies (add-ins, packages). I guess that there will be backwards compatibility, but, you know, changing internal things without breaking something is difficult. I mean, if you change the code editor technology (even if only the presentation layer, not the internal buffering stuff), there are add-ins and packages out there (not my case) that colorize, add smart tags, etc. The new code editor even allows you to use different font families and sizes for different parts of the code…
• The other thing is the WPF stuff, or more precisely, when WPF designers rather than Windows developers start to create Windows applications (instead of, say, web sites where they can use their creativity to the max) because, simply put, I don’t think they know or care about Windows design guidelines. I am currenly learning Microsoft Expression Design 2, a WPF Windows application to create designs and it is a horrible Windows application:
  • It doesn’t honor the Windows look and feel (menu fonts, colors, etc). You can only choose between light or dark user interface. OK, Microsoft Office 2007 also started to violate Windows design principles using its own Segoe font rather than the Windows font (whatever the user has selected in the Control Panel), and many users have discovered in the forums that it is impossible to remove it.
  • It uses weird menu to change preferences: “Edit”, “Options” rather than the usual “Tools”, “Options” that every other Microsoft application uses. I guess there was some people influenced by Adobe applications which use “Edit”, “Preferences…”. I hope no people influenced by Apple starts switching the OK and Cancel buttons 😉
  • The toolbox is not the more user-friendly thing in the world. It uses multi-tool buttons and it changes their icons to the last used one. The toolbox of Visual Studio is much better (you can show all tools at the same time, with or without text)
  • The Layers panel doesn’t use a context menu to add or remove layers or other things, you have to use some weird artifact at the bottom of the panel to show a menu.
  • OK, this one is not arguable: the objects that you design in the canvas can’t be copied and pasted using a context menu! You have to use the ones under the “Edit” main menu. I can’t think about a Windows application that doesn’t offer a context menu to copy/paste selected objects…

So, while it is true that developers are not good designers, I think that it is also true that designers can’t create good applications (maybe web sites or video games, but not Windows applications).

Since I didn’t attend the PDC 2008, I have started to watch some recorded sessions. While the most interesting one for people extending Visual Studio (“TL32 Microsoft Visual Studio: Customizing and Extending the Development Environment” by Tim Wagner) that I mentioned in my last post is not available yet (I guess it will be posted in a few days), today I have watched the one about the new Managed Extensibility Framework (MEF) by Glenn Block:

Managed Extensibility Framework: Overview
http://channel9.msdn.com/pdc2008/TL33/

which is the foundation of a new approach to extensibility in VS 2010.

You know what is happening here: once the core .NET Framework is good and stable (.NET 2.0) we are getting lots of Microsoft “foundations” and “frameworks” built on top of it: Windows Communication Foundation, Windows Workflow Foundation, Microsoft Sync Framework, Microsoft ADO.NET Entity Framework, etc. While I am not fan of using whatever Microsoft (or anyone else) ships in version v1 because it will require some time to get stable and really good (and even fun!), once they reach that point this is great because of two reasons:

1. You get a lot of plumbing architecture done for free and you concentrate on your business.
2. Microsoft is going to use them in their own products. For example, I think that Microsoft Sync Framework will be used in SQL Server, Windows Mobile, etc., Windows Workflow Foundation is / will be used in SharePoint, Biztalk workflows, etc. This guarantees a bigger level of commitment to some framework which otherwise has a much bigger chance of becoming “disposable” creations.

The session from the PDC is great to get introduced to MEF, which I was not familiar with (BTW, you can start at minute 20 to skip old approaches to extensibility). I was familiar with the problem of extensibility, discovery and catalog of extensions, and plumbing code for menus and toolwindows, because starting with the first the version (4.0) of my MZ-Tools add-in for Visual Studio .NET, despite being an extension for the Visual Studio host with about 40 features, it was in turn extensible. That is, you can build DLLs with classes extending some base class provided by the MZ-Tools SDK and implementing some methods, and you get in the MZ-Tools toolbar new operations (actions performed over the files of your solution, either to review them or to modify them):

MZ-Tools SDK
http://www.mztools.com/v6/sdk.aspx

And in fact I provided several external operations as samples (C# and VB.NET) of features (not included in the MZ-Tools feature set) in the Community Section of my web site:

Community Place
http://www.mztools.com/community.aspx#ExternalOperations

I tried to do it really simple for my customers:

1. You create a class library with one class for each new operation that you want to add.
2. Classes inherit from a base class provided by the MZ-Tools SDK and implement very few plumbing methods
3. You build the class library and you put the DLL in certain folders (no need for registration files at all)

When loaded, the MZ-Tools host gets the DLLs from those folders, loads them, iterates exported types searching the ones that inherit from the needed base class and then calls its methods to get menu captions, icons, etc.

The Managed Extensibility Framework addresses this kind of scenarios decoupling as much as possible the host and the extensions, using attributes to denote what the extension offers (menus, toolwindows, etc.) and what the extension needs from the host (services). It also discovers extensions, catalogs them and does the needed connections between the host and the extensions. It also addresses the performance problem that can happen with a host with tons of extensions, using delayed loading.

So, a very interesting subject. Even if you are simply creating extensions for Visual Studio, MEF will be used in VS 2010 as a new way to extend it, so it’s good to get started learning it.

Last Thursday October 23 the VSX Team blog announced a VSX Talk at the upcoming PDC that contained this very interesting news:

“The next version of Visual Studio moves beyond add-ins and packages to unleash powerful new ways to customize and extend the environment. Learn about the Visual Studio extension model-built on a common Microsoft .NET extensibility framework–that makes it easy to customize Visual Studio in new ways. See how to create extensions for the new code editor and project system, and hear how to build your own graphical designers and specialized development environments.”

That the automation model (EnvDTE) for add-ins (and macros) was being somewhat de-emphasized was quite obvious in the last Visual Studio 2008 release, where after the great improvements that we saw in the VS 2005 automation model (EnvDTE80) very few was added in the VS 2008 version, and all the work of the VSX Team seemed to be about the Visual Studio SDK. But that there is something in the works to move beyond packages is something entirely new. The Visual Studio extensibility is hindered severely from the begining (2002 version) by the fact that the IDE is a native COM application, not a .NET application (some portions are .NET but the core is COM) and the attempts to hide this fact in the Visual Studio SDK have not been 100% successful. So, it is going to be tremendously interesting if the “Visual Studio extension model-built on a common Microsoft .NET extensibility framework” will solve this problem. I hope so very much.

Anyway, for existing Visual Studio extenders this doesn’t mean that you can forget about add-ins or packages because your product needs to support old versions of Visual Studio. I am still supporting VS.NET 2002/2003 in my MZ-Tools add-in and while I will stop supporting those versions at some point in the future, most vendors will have to support the VS 2005, VS 2008 and VS 2010 in the next few years so leveraging the same existing code base (whether it is an add-in or a package) will be common approach in most cases. But at some point in 4-6 years, when you need to support only from VS 2010 onwards, and when this new extensibility approach is more mature, maybe we can forget that VS is COM-based and automation will be truly simple. The first answers in a week, at the PDC…

I have discovered today by chance that there was a new assembly EnvDTE90a.dll on my machine, whose namespace EnvDTE90a is documented in the MSDN docs:

EnvDTE90a Namespace
http://msdn.microsoft.com/en-us/library/envdte90a.aspx

As you may know, the common automation model is supplied by a set of EnvDTEXX.dll assemblies:

• EnvDTE.dll (provided by VS.NET 2002 and higher)
• EnvDTE80.dll (provided by VS 2005 and higher)
• EnvDTE90.dll (provided by VS 2008)

Each one provides new types and does not replace the old ones. Rather, it adds classes like CodeClass2, HTMLWindow3, etc.

Then you have the VB.NET / C# specific automation model which is supplied by a set of VSLangProjXX.dll assemblies:

• VSLangProj.dll (provided by VS.NET 2002 and higher)
• VSLangProj2.dll (provided by VS.NET 2003 and higher)
• VSLangProj80.dll (provided by VS 2005 and higher)
• VSLangProj90.dll (provided by VS 2008)

Again, each one provides new types and does not replace the old ones.

Finally, you have the Visual C++ specific automation model which is supplied by the following assemblies:

• Microsoft.VisualStudio.VCProject.dll
• Microsoft.VisualStudio.VCProjectEngine.dll
• Microsoft.VisualStudio.VCCodeModel.dll

On the contrary to the other automation assemblies, each Visual Studio version provides a different version and each version completely replaces the old one.

• 7.0.3300.0 (Visual Studio .NET 2002)
• 7.0.5000.0 (Visual Studio .NET 2003)
• 8.0.0.0 (Visual Studio 2005)
• 9.0.0.0 (Visual Studio 2008)

(Don’t get me started about the inconsistencies in the version numbering in Visual Studio)

The new EnvDTE90a.dll assembly is supplied by the SP1 of VS 2008 and it provides new automation capabilities for the debugger. AFAIK, this is the first time that a service pack introduces a new automation assembly but the SP1 of VS 2008 is much more than a service pack that fixes bugs, it introduced much new functionality.

I have updated this article of mine to reflect this:

INFO: Assemblies used in Visual Studio Extensibility
http://www.mztools.com/Articles/2007/MZ2007004.aspx

Microsoft has just post the screencasts of most sessions of the Visual Studio Extensibility (VSX) Developer Conference 2008 back in September. I didn’t attend because it is a long trip (I live in Madrid – Spain-), a flight to Seattle is not direct (you need a stopover in France, England, Netherlands or in the US) and the fare is not what we could say a domestic flight, not to mention the jet lag that you get when returning. Also, I have already been to Seattle three times in the last four years for the MVP Summits, so tourism is no longer an added value for such a trip. But fortunately the videos are available so although the networking and social aspects of such events are missing, we can get the content (the audio and the PowerPoint slides in synch).

Today I have watched the one from the list that attracted me more, which is not technical, but the one of about marketing tools for Visual Studio (How to Market Your Extensions (VSX107) by Joe Marini) and I have enjoyed it a lot although I was familiar with all the topics explained (it happens that I had read all the books and blogs but one mentioned in the last slide). Making the transition from a freeware MZ-Tools 3.0 for VB6/VB5/VBA to a commercial MZ-Tools 6.0 for VS.NET 2002-2008 product has been a challenge for me, not only from the technical point of view (VB6 -> .NET) but for the most part from the marketing point of view for a geek like me. I have read lots of books, articles, blogs, etc. about it so I am now a bit less clueless 😉

The screenshots are available here:

VSX Developer Conference 2008 Sessions overview:
http://msdn.microsoft.com/en-us/vsx/cc676517.aspx