Context Menu for Trello

I’m on holiday at the moment, back in sunny England. Holiday may not be the right term really, I’m mostly working through charity stuff (for my charity Namaste – Children’s Homes Nepal) and company administration. I’m also starting working on a big new project, which is pretty exciting.

Anyway, I got a nice message from a fellow coder George Hahn who has put together a pretty cool project that lets you send files directly to Trello as an attachment to a card, or even as a new card. Here’s a screenshot of it in action:


It’s a nice project, you can check it out on GitHub:

What’s also cool about this project is that it’s the first project that someone’s told me about that uses SharpShell. Many people have got in touch with me about SharpShell (in fact, the SharpShell Context Menus article on the CodeProject is very popular), but so far this is the first real-world project where the writer got in touch after the project is completed.

Thanks George, I look forward to seeing what else you’re working on!


Creating Info Tip Handlers with .NET

I have just added an article to the CodeProject that discusses how to create Info Tip shell extensions in .NET. These extensions are used by the shell to customise the tooltips shown over shell items.


The article shows how you can use SharpShell to very quickly create these extensions, you can find it at: http://www.codeproject.com/Articles/527058/NET-Shell-Extensions-Shell-Info-Tip-Handlers.

So just how easy does SharpShell make creating Shell Info Tip Handlers? The answer is pretty easy indeed. The code below shows the full implementation of a Shell Info Tip Handler that changes the tooltips for folders to show the name of the folder and the number of items it contains:

/// <summary>
/// The FolderInfoTip handler is an example SharpInfoTipHandler that provides an info tip
/// for folders that shows the number of items in the folder.
/// </summary>
public class FolderInfoTipHandler : SharpInfoTipHandler
    /// <summary>
    /// Gets info for the selected item (SelectedItemPath).
    /// </summary>
    /// <param name="infoType">Type of info to return.</param>
    /// <param name="singleLine">if set to <c>true</c>, put the info in a single line.</param>
    /// <returns>
    /// Specified info for the selected file.
    /// </returns>
    protected override string GetInfo(RequestedInfoType infoType, bool singleLine)
        //  Switch on the tip of info we need to provide.
        switch (infoType)
            case RequestedInfoType.InfoTip:
                //  Format the formatted info tip.
                return string.Format(singleLine
                                       ? "{0} - {1} Items"
                                       : "{0}" + Environment.NewLine + "Contains {1} Items",
                                       Path.GetFileName(SelectedItemPath), Directory.GetFiles(SelectedItemPath).Length);
            case RequestedInfoType.Name:
                //  Return the name of the folder.
                return string.Format("Folder '{0}'", Path.GetFileName(SelectedItemPath));
                //  We won't be asked for anything else, like shortcut paths, for folders, so we 
                //  can return an empty string in the default case.
                return string.Empty;

As you can see, all of the COM interfaces are hidden away and handled for you, there is no ugly pinvoke code and no use of strange structures imported from Win32. SharpShell handles all of the plumbing for you.



SharpShell is a project that I have recently uploaded to CodePlex. This class library, and set of tools and samples, is designed to be a framework to enable rapid development of Shell Extensions using the .NET Framework. In time it may grow to contain some functionality for using Shell entities within managed applications (for example, allowing an Explorer context menu to be built dynamically for a given path).

Anyway, the code is all at sharpshell.codeplex.com. You can also see a nice article on the CodeProject that show’s how to create a Shell Context Menu Extension using C#, the article is at: .NET Shell Extensions – Shell Context Menus.


Above: An example of a Managed Shell Extension. This sample colours the icons for dlls differently, depending on whether they are native dlls or assemblies.

So far, in the repo on CodePlex there are also samples for Shell Icon Handlers (which customise icons in Explorer) and Shell Info Tip Handlers (which customise tooltips). Both of these extension types are fully supported in the current dev version and will be released in the next few days. There’s also a partially functioning Shell Property Sheet implementation which will be delivered in the subsequent version. The Shell Property Sheet introduces some particularly strange code – 32 and 64 bit C++ dlls are embedded as manifest resource streams and extracted as needed to provide access to C++ function pointers – ouch.

More to follow – check out the project and the article.