Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

At work I sometimes run into “evil twin” methods in our codebase. Those are methods that at a glance look almost exactly the same and where one has obviously been copy pasted from the other but then they have gotten out of sync over time. In these cases I try to refactor the two methods into one and add parameters for any behaviour that was different in the two original methods. But it can be hard to tell exactly what has changed between the two methods, especially when they are dozens of lines each. When dealing with this I used to copy each of the methods into their own temp file and then run a diff tool on them. After doing this a few times I got annoyed at the process, and decided to automate it somehow.

I’ve been playing around with Visual Studio extensions a lot lately and so I decided to make one for this problem. The extension is called ClipboardDiff and is now available in the Visual Studio Gallery. The idea is that you copy the first part of text you want to compare, then you select the next part you want to compare and then run the command ‘Diff selection against clipboard’. The command is available by right clicking on the selected text, it’s at the bottom of the context menu, or you can invoke it with they keyboard combination Alt+Shift+J. If you want to bind it to another keyboard combination just go into Tools->Customize->Keyboard and search for ‘ClipboardDiff’, it’ll find the command.

You can self choose which diff tool to use, to configure it go to Tools->ClipboardDiff settings and there you can enter the path to your diff tool of choice, and the arguments you want to pass to it. The placeholder values $FILE1$ and $FILE2$ will be replaced by the temp file names once you invoke the diff command. ClipboardDiff knows the default locations of a few diff programs, so if you have Perforce Merge, Tortoise Diff or WinMerge installed you won’t have to configure anything (Those are just the tools I happened to have installed on my machine). If you haven’t configured which tool to use the Settings window will be opened the first time you try to run a diff.

You can download the extension in the Visual Studio Gallery and the source, as always, is GPL’d and available on Github at https://github.com/einaregilsson/ClipboardDiff. Enjoy!

Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

At work I often work on a solution that has around 25 projects. When one of the projects fails to build, Visual Studio insists on trying to build the rest of the projects, even though at that point I don’t want it to, since I’m never going to run the program when some of the projects have failed. Often the other projects depend on the project that failed, and the error list gets filled with errors from those projects that just obscure the root cause of the problem. So, I figured I could probably do something about it.

I googled around for a solution and found a StopOnFirstFailure property in MSBuild that sounded promising, but I couldn’t find any good way to hook into the VS->MSBuild relationship. I’m sure there is some way to do this, so if anyone knows, please let me know. The next thing I found was a tip from Steve Dunn. It’s a nice little macro that listens for an event that is fired after each project is built, and calls the Cancel Build command if a project has failed to build. You just open the Macro IDE, open the EnvironmentEvents.vb file and paste the following code in at the bottom:

Private Sub BuildEvents_OnBuildProjConfigDone(
                   _ ByVal Project As String,
                   _ ByVal ProjectConfig As String,
                   _ ByVal Platform As String,
                   _ ByVal SolutionConfig As String,
                   _ ByVal Success As Boolean) Handles BuildEvents.OnBuildProjConfigDone
    If Success = False Then 'The build failed...cancel any further builds.
        DTE.ExecuteCommand("Build.Cancel")
    End If
End Sub

This does 95% of what I wanted to do. But still, I’m not a big fan of Visual Studio Macros, I prefer extensions where possible so I can easily see in one place what things I have installed instead of digging through the Macro projects. I also wanted to activate the error window after cancelling the build and be able to turn this on and off easily. So, I made an extension out of it. The main thing in it is still the macro code from Steve Dunn above, but in addition the extension:

• Activates the error list after cancelling the build.
• Prints a message to the Build output window, saying why the build was cancelled.
• Adds a menu item to the Build menu, “Stop Build on first error”, which you can use to turn the functionality on and off easily.
• Is context aware, the menu item and functionality are only available in multi-project solutions, since it would be pretty useless in a single project solution.

And that’s it. You can download the extension in the Visual Studio Gallery, get the GPL’d source code at https://github.com/einaregilsson/StopOnFirstBuildError and follow me on Twitter @einaregilsson to get notified of updates and other new extensions. Enjoy!

Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

The problem

I’ve been annoyed by the eventhandler names generated by Visual Studio for years. No, I don’t really want to name my methods txtName_TextChanged, which does not match any reasonable naming convention and looks ugly. I usually prefer something like OnNameTextChanged or something similar. Another thing that has annoyed me is

this.Load +=new EventHandler(OnLoad);

instead of just

this.Load += OnLoad;

So, I figured I could probably hack something together to fix these problems fairly easily. As it turns out, some of it was easy, some of it was hard and some of it was impossible.

How do you use it?

In the Tools menu there is a new menu item, EventHandler Naming. That will give you the options window shown here. The “Pattern” is what is used to create the eventhandler names, you can use two macros there, $(EventName) and $(SiteName). EventName is pretty self explanatory, but the SiteName can be the name of the variable/component that owns the event being subscribed to, the typename of the type that owns the event (in the case of static events) or again the typename if you are subscribing to events within the class that owns the event. For both $(SiteName) and $(EventName) you can specify simple transforms like changing the case to camelCase, PascalCase, UPPERCASE or lowercase.

The “Omit $(SiteName) for own events” is for the case where you are subscribing to your own, or a base class event. At least for me, if I’m in a form and am subscribing to its Load event I don’t want the handler to be named OnForm1Load, I just want it to be named OnLoad. Whereas if I’m subscribing to an event from some variable then I want the variable name (sitename) to be a part of the event handler name.

The “Use delegate inference” does what is says. Instead of getting += new EventHandler(someName) you will get += someName.

Implementation: WinForms and WebForms

Luckily the Win and WebForms designers have a fairly nice API that you can hook into. I just created my own implementation of IEventBindingService and implemented the CreateUniqueMethodName method. For all other methods I just delegated to the real event binding service. The code to hook that up is as follows:

    internal class DesignerCreationListener
    {
        internal DesignerCreationListener(IDesignerEventService designerEvents) {
            designerEvents.DesignerCreated += (s, e) => e.Designer.LoadComplete += OnDesignerLoaded;
        }

        private void OnDesignerLoaded(object sender, EventArgs e)
        {
            IDesignerHost host = sender as IDesignerHost;
            if (host == null)
            {
                return;
            }
            host.LoadComplete -= OnDesignerLoaded;

            Type type = typeof(IEventBindingService);
            IEventBindingService originalService = (IEventBindingService) host.GetService(type);
            if (originalService == null)
            {
                return;
            }

            host.RemoveService(type);
            host.AddService(type, new DesignerEventBindingService(originalService, new PatternNameProvider()));
        }
    }

DesignerEventBindingService is my class, which takes the originalService in its constructor and delegates to it as necessary.

Implementation: Code Window

The code window implementation is basically a big hack. It’s the C# language service that takes care of inserting event handlers there and it basically has no hooks or extension points at all. (I would love it if someone proves me wrong on this). So, here I’m basically listening to two events, BeforeKeyPress and AfterKeyPress. I’m just checking whether the keypress is a tab key, doing some heuristics to make sure that we’re actually creating eventhandlers and not just pressing tab in some arbitrary place.

This is the reason why you get the old eventhandler name in the tooltip first after you press +=, the new name only comes after the delegate constructor is created. I tried everything I could think of to fix that, but the language service itself is responsible for showing that tooltip and drawing text on it and I can’t hook into that.

The language service is also the reason I have to show the delegate constructor while we are creating the name and only remove the explicit constructor afterwards for delegate inference. If I mess with the delegate constructor before the method is created then the language service just aborts the operation and the next tab key stroke won’t do anything.

So, overall it’s missing some things, but for the most part it does what you’d want.

Implementation: WPF / XAML

And this is the impossible part. The XAML designer doesn’t use the IDesignerHost interface at all, and as far as I could tell from looking at the VSX forum there is just no way to really extend the XAML editor in any meaningful way. It’s disappointing that they didn’t use the excellent IEventBindingService there, if someone knows a way that I could hook in here then please let me know.

Conclusion

I hope you find the extension useful, the source is GPL and available at https://github.com/einaregilsson/EventHandlerNaming . If you have any tips, suggestions, or bug requests send me an email or a tweet at @einaregilsson.  And please tweet and share this if you like it

Now, why did I need this? Well, I was loading my other assemblies from an unusual place and I wanted to subscribe to the AppDomain.AssemblyResolve event before any types in my assembly were initialized. This feature is clearly not something you’re going to need every day, (actually I can’t think of a single other use case where I’d need it) but if you do, here’s how I solved it.

I used the excellent Mono.Cecil library to create a small program that injects a module initializer into an existing assembly. Cecil is a fantastic library that makes it incredibly easy to manipulate assemblies and can do pretty much anything that you could possibly want to do with IL code. Using it I wrote a small program that simply takes in an assembly filename and the name of a parameterless static void method that exists in the assembly, and injects a module initializer that does nothing but call that method. The original code I wrote, the interesting part without all the error checking and stuff, is shown below:

string assemblyName = "Test.dll";
string typeName = "Foo.Bar.ModuleInit";
string methodName = "Run";

AssemblyDefinition assembly = AssemblyFactory.GetAssembly (assemblyName);
TypeReference voidRef = assembly.MainModule.Import(typeof(void));
var attributes = MethodAttributes.Static
                | MethodAttributes.SpecialName
                | MethodAttributes.RTSpecialName;
var cctor = new MethodDefinition( ".cctor", attributes, voidRef);

TypeDefinition type = assembly.MainModule.Types[typeName];
MethodReference methodRef = type.Methods.GetMethod(methodName,new Type[]{});
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Call, methodRef));
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Ret));
assembly.MainModule.Inject(cctor, assembly.MainModule.Types["<Module>"]);
AssemblyFactory.SaveAssembly(assembly, assemblyName);

I then added all the neccessary error handling, unit testing etc. and the resulting program can be downloaded here. The program is just a single executable since I embedded the Cecil assemblies as resources and load them by handling the AppDomain.Current.AssemblyResolve event. You can run it from the command line and give it the filename of your assembly and optionally specify the method to call and a key file to strong name sign the assembly after the injection. If no method is explicitly specified then the program looks for a type named ModuleInitializer (may be in any namespace) and looks for a method named Run in that type and calls that method in the module initializer.

Run without specifying the method, looks for ModuleInitializer::Run in any namespace.

InjectModuleInitializer.exe Test.dll

Run and specify the method as Foo.Bar.SomeClass::SomeMethod

InjectModuleInitializer.exe /m:Foo.Bar.SomeClass::SomeMethod Test.dll

Run and specify a keyfile to use for strong name signing

InjectModuleInitializer.exe /k:mykeyfile.snk Test.dll

Realistically though, if you want to do this you probably want to do it right after building your assembly.  The best way to do that is to use the <Exec/> command in MSBuild in the AfterBuild target. To do that you can have the following in your .csproj file:

<Target Name="AfterBuild">
    <Exec Command='InjectModuleInitializer.exe "$(TargetPath)"' />
</Target>

Or, if you want to explicitly specify the method to run:

<Target Name="AfterBuild">
    <Exec Command='InjectModuleInitializer.exe /m:MyNameSpace.MyClassName::MyMethodName "$(TargetPath)"' />
</Target>

If you have set up your project to sign your assembly you will have the name of the strong name file in the $(AssemblyOriginatorKeyFile) variable. You can sign the assembly after the injection with:

<Target Name="AfterBuild">
    <Exec Command="InjectModuleInitializer.exe /k:"$(AssemblyOriginatorKeyFile)" /m:MyNameSpace.MyClassName::MyMethodName "$(TargetPath)" />
</Target>

And there you have it. You can download the console program or get the source on GitHub and build it yourself (You can download a zip file there if you don’t want to mess with Git). Enjoy.

There are a couple of other articles out there that approach the problem in a different way. Roy Osherove has an article where he shows how you can add icons without having satellite assemblies for them, but that has > 350 lines of code for loading the images yourself including P/Invokes and all sorts of stuff, and I didn’t really need such a heavyweight solution. To be fair, his solution does give you the ability to use .ico files as well, and offers transparency, but transparency can be achieved in an easier way.

I also found another article that shows how you can get transparency by using a special color that, as far as I know, is not documented anywhere officially. It also shows you how you can build a satellite assembly from Visual Studio without resorting to Notepad and the command line tools, but this approach uses a special project for the satellite assembly, which is completely unneccessary.

So, finally, my approach, which is really a refinement of the last article I mentioned. If your add-in is meant for only VS2008 then you can get away with having no satellite assembly, VS2008 falls back to looking in your main assembly for the resources if it doesn’t find a satellite assembly. If you want to support VS2005 you must have a satellite assembly for it to work.

So, assume we have a project named MyProject which will compile to an assembly called MyProject.dll. Here’s what you do:

1. Add a new ‘resources’ item to the project and give it the name “MyProject.en.resx”.
2. Go the properties for the item and set the “Custom Tool” field to nothing. This will remove the auto-generated code for the .resx file
3. Double click on the .resx file, this opens up the resource editor. There you can add an existing image (Add Resource->Add existing file). The image should be a 16×16 pixel bitmap image. It must be in True Color format. True Color is the same as a 24-bit bitmap.
4. If you want transparency in your image then use the special color: Red:0 , Green:254, Blue:0 . Note that it really is 254, NOT 255.
5. In the resource editor, give your image a name that is a number, e.g. 1. Note that you did not have to change the filename of your image file, just its name in the resource file.
6. Now add your command in your add-in file like so:

   commands.AddNamedCommand2(_addInInstance, "MyProject",
         "MyProject", "Executes the command for MyProject",
         false,
         1,
         ref contextGUIDS,
         (int)vsCommandStatus.vsCommandStatusSupported +
         (int)vsCommandStatus.vsCommandStatusEnabled,
         (int)vsCommandStyle.vsCommandStylePictAndText,
         vsCommandControlType.vsCommandControlTypeButton);
   

   There you must send in false and then the number you gave the icon in your .resx file, e.g. 1.

Now when you compile your solution, a satellite assembly with the name MyProject.resources.dll will automatically be created and put in a “en” subfolder of your output folder. If you only want to support VS2008 and don’t want satellite assemblies then you can name the .resx file just MyProject.resx instead, then no satellite assemblies will be created and the resources will be embedded in the main assembly.

And that’s it. Add more resources in Visual Studio, have things compile automatically and don’t touch command line tools, notepad, hundreds of lines of custom code or anything like that. I *think* it is enough to just have the “en” resources dll even if you use another locale, I’m pretty sure Visual Studio falls back to that if it doesn’t find a satellite assembly in your current culture. At least I have my Windows set up for Danish, but my “en” satellite assembly works just fine for me. Although, there doesn’t exist a Danish version of Visual Studio, maybe this works differently for localized Visual Studio, e.g. the German version. If someone has one of those and can test I’d love to know whether it falls back to “en” if nothing else is available. If it doesn’t then just create a few more MyProject.de.resx, MyProject.es.resx etc. to get more satellite assemblies. But like I said before, VS2008 and later doesn’t need this, so for that case just have the one MyProject.resx file.

I’ve made the small MyProject example and it can be downloaded here. Let me know if this works (or doesn’t) for you. Enjoy!

The original blog post about the architecture of the addin is now completely out of date as 90% of the addin is now written in IronPython with just a tiny shim layer of C# to instantiate the IronPython classes. I’ll probably write a blog post about that architecture seperately (or generally about how to write addins for VS in IronPython). Those interested in the architecture can download the source and look at it.

A nice tutorial with screenshots on how to setup the keyboard mappings and use the addin has just been posted at http://www.netsi.dk/wordpress/index.php/2009/12/02/zen-coding-a-very-fast-way-of-generating-html-elements-in-your-editor/ so go there for your setup instructions. And there is now a dedicated rss feed for updates at http://einaregilsson.com/zcupdates.aspx so subscribe to that to be notified of new versions. Eventually I’ll put an update check in the addin itself.

ZenCoding.VisualStudio v1.1.0.333

DOWNLOAD ADD-IN || DOWNLOAD SOURCE

RELEASE NOTES:

Version 1.1.0.333, 02.12.2009:

This release adds the following features

• Uses latest version of zencoding python library
• Wrap with abbreviation command
• Use, create, edit, delete custom snippets (Tools->Options->ZenCoding)
• Icons for commands
• Some bug fixes

Also a total rewrite with everything now written in IronPython

Version 1.0, 12.11.2009:

Initial release, features:

• Expand abbreviation

Original blog post follows:

Earlier this week, while reading Leon Bambrick’s blog I learned about a set of plugins, named “zen-coding”, which expand snippets of css-selector like code into full blown html and/or css elements. Leon’s article explains it better and there is also some documentation on the official zen-coding page. Anyway, this plugin is available for a number of text editors and IDE’s but not for Visual Studio. I use Visual Studio a lot and wanted zen-coding in there, so I decided to try and whip up a small add-in for it.

The original library is available both as JavaScript and Python. I really didn’t want to port or alter anything in the original code, since for future versions I want to be able to just drop in a couple of files from the original library and rebuild the add-in. The obvious choice then was to see if the library would work with IronPython. Fortunately the zen-coding library is just basic string manipulation and worked perfectly with IronPython right out of the box.

The next challenge was figuring out how to call into that from the add-in, which I wanted to write in C#. The library contained two functions I needed to be able to call. That turned out to be surprisingly easy. I made a wrapper class, ZenCodingEngine, which has two delegates with the correct method signatures, and then in its constructor I ran some custom python import code, and got references to the functions I needed and assigned them to my delegates. I changed that approach in the latest version and moved almost all of the logic into Python instead. Now the C# AddIn is very thin, it basically just receives events from VS and invokes a single exec_command() method that is defined in a python script. The interesting parts of that code are below:

private void ReloadPython()
{
  ScriptEngine engine = Python.CreateEngine();
  ScriptScope scope = engine.CreateScope();
  string folder = Path.GetDirectoryName(new
    Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
  List searchPaths = new List<string>(engine.GetSearchPaths());
  searchPaths.Add(folder);
  engine.SetSearchPaths(searchPaths);
  scope = engine.ExecuteFile(Path.Combine(folder, "vs_zen_coding.py"));
  engine.SetVariable(scope, "App", _applicationObject);
  execCommand = engine.GetVariable<Func<bool>>(scope, "exec_command");
}

public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
{
  handled = false;
  if (!CanExecuteCommand(commandName, executeOption))
  {
    return;
  }

  try
  {
    #if RELOAD_EVERY_TIME
    ReloadPython();
    #else
    if (execCommand == null)
    {
      //Load first time, to avoid making the VS startup slower
      ReloadPython();
    }
    #endif

    execCommand();
  }
  catch (Exception ex)
  {
    DisplayError(ex);
  }
  handled = true;
}

The ReloadPython() method is not called on startup, instead it is called the first time the command is called. IronPython performs well, but there is still some startup cost and I don’t want to add that to the startup time of Visual Studio. Instead you pay the price the first time you actually need it. Then we have the Exec method which is from a VS interface and is called when the command is invoked. There I use a compilation constant, RELOAD_EVERY_TIME, to check if I should reload my python script every time I invoke the command. This has proved to be INCREDIBLY useful, instead of constantly starting VS up again and again I just edit my python script, save it and the next time I execute the command the new code is used. And of course I turn this constant off for release builds.

Another nice trick to play around with the VS API, start up an IronPython shell and type:

This gets you a reference to the running instance of VS2009 which you can then experiment with.

You can download an installer for the add-in or get the source. The add-in is licensed under the GPL v3, the same license the zen-coding library uses. The add-in works for Visual Studio 2005, 2008 and 2010 beta 2.

Now, once you’ve installed the add-in, nothing happens. Well, actually what happens is there’s a new command available in Visual Studio, named ZenCoding.Expand, or ZenCoding.VisualStudio.ZenCodingAddIn.Expand, depending on where you are looking for it. (The keyboard mapping uses the full command id, but when adding it to a toolbar you get a shorter friendly name for it). By default it is not mapped to any keyboard combination. This is because it’s late and I can’t be bothered to figure it out I strongly believe that add-ins should not force a keyboard shortcut on you, possibly overriding something you have set yourself. So, map the command to your preferred keyboard shortcut (mine is Ctrl+E,Ctrl+K). Or you can drag the command onto a toolbar, which is fairly useless, but possible.

Enjoy!

UPDATE 13.11.2009: The main zen-coding developer also told me that I’m using an older version, the latest version has a lot more features, including user defined snippets. I’ll start looking at that when I have time, which won’t be just yet.

After I had written the chord image generating code itself I decided to make a little test app for it, both to teach people the correct format and just to play with. That little application can be found at http://chords.einaregilsson.com/. The chord images can have muted and open strings, finger positions, display the beginning fret for chords higher than the first five frets and display below the image which fingers are used for which string. They can also be generated in ten different sizes.

Lets look at some examples. The format of an url for a chord is:

http://chords.einaregilsson.com/[chordname].png?p=[fretpositions]&f=[fingers]&s=[size]

So, for a normally fingered E chord the url would be:

http://chords.einaregilsson.com/E.png?p=022100&f=-231–&s=2

The name is a simple string. The only thing to remember there is that if you want to use the # symbol you must encode it as %23, because otherwise the browser will not send the rest of the url to the server. If you have two chords with the same name you can differentiate them by naming for example one E5 and the other E5^II. This is done by writing the name as E5_II, with an underscore before the superscript. Below is an example of a C# chord in size 5

http://chords.einaregilsson.com/C%23.png?p=x4666x&f=-1333-&s=5

The fret positions run EAGDBE, use X for muted strings, 0 for open strings and other numbers for fret positions. If you are writing a chord that uses fret positions on and over the 10th fret you must write all the positions with a dash between them. A D bar chord on the 10th fret would then be written as

http://chords.einaregilsson.com/D.png?p=10-12-12-11-10-10&f=134211

The fingering positions also run EAGDBE. Use T for thumb, 1 for index finger, 2 for middle finger, 3 for ring finger and 4 for pinky. Use a dash, -, when no finger is on a particular string. Bar chords are inferred, if you write that you are using the same finger for different strings on the same fret, then a line will be drawn through them to indicate a barred chord. An example of that is the D chord above.

The size is just a number from 1-10. I like size 2 the best myself, and that is the default.

You can cut as much off the back of the url as you want. That is, you can skip the size, fingering positions and even fret positions, and they will use defaults instead. Default size is 2, default fingerings mean that no fingerings are written, and default fret positions are none. So, for example the following four urls are all legal (although the last one is not really a D chord since it contains no fret positions):

	http://chords.einaregilsson.com/D.png?p=xx0232&f=—132&s=2
	http://chords.einaregilsson.com/D.png?p=xx0232&f=—132
	http://chords.einaregilsson.com/D.png?p=xx0232
	http://chords.einaregilsson.com/D.png

You are free to link to images directly on http://chords.einaregilsson.com from your own website, although I make no guarantees about uptime, performance or anything like that. The images are cached for a week, so loading time should be fast after the first time.

The code for this was written in C# and is licensed under the GPL. The main class is called ChordBoxImage and it can save the generated image in a variety of formats to any output stream. The code for the image generator as well as the little test web site is available on GitHub. Enjoy!

The program is ONLY meant for uploading albums for the first time, not for working with albums once they are uploaded. The main features of the program are:

• Create new albums (with descriptions) and upload images (obviously)
• Resize photos before uploading
• Rotate photos
• Order photos in album
• Remove photos from album and optionally delete the file itself
• Save titles and descriptions for photos
• Keyboard shortcuts for almost all actions

The program is very much “me-ware”. I made it to scratch my own itch, it may not fit or feel right to anyone else. It was thrown together and is fixed as I run into bugs while using it. It may well contain errors and might crash horribly. That said, everyone is welcome to use it and improve upon it if they wish. Just know that you are using this at your own risk. I cannot be held liable for any damages or problems this program may cause. It contains commands that you can use to delete photos from your hard disk, use it carefully and think about what you are doing.

Probably my favorite feature of the program is the ability to do everything from the keyboard. The available shortcuts are:

• CTRL+U: Open the upload dialog
• CTRL+UP, CTRL+DOWN: Move to previous/next photo even though the listbox is not selected
• CTRL+SHIFT+UP, CTRL+SHIFT+DOWN: Move a photo higher or lower in the list
• CTRL+T: Give focus to the Title textbox
• CTRL+D: Give focus to the Description textbox
• CTRL+LEFT, CTRL+RIGHT: Rotate the currently selected photo
• DEL: Remove or delete the currently selected photo. There is a confirmation dialog that asks if you want to remove the photo from the album, or delete the photo. Do not choose “delete” unless you really want to delete the photo from your hard disk forever!

You can download the source here, it is licensed under the GPL v3.0. It is written in C# and requires .NET 3.5 to compile. There is a build.bat file in the root folder that can be used to build the program.

Finally, you can DOWNLOAD ZenPhotoUploader here, it is a single executable, no dependencies other than the .NET framework 2.0 or higher. The only version of ZenPhoto I’ve tested it against is v1.2.2, others may not work. Enjoy, and let me know if you have any problems with it.

The only way to get a global keyboard working in .NET is by calling into the Win32 API. To register a global hotkey there is the aptly named function RegisterHotKey. That requires you to have a window handle however, and I wanted to make the application as simple as possible, so I used a lower level API call,
SetWindowsHookEx which lets you get notified of all keyboard activity on the system. I then check what keys are pressed and when the combination Ctrl+Shift+I is pressed the sound is played. There is only one way to exit the app, and that is by pressing the keyboard combination Ctrl+Shift+Alt+I, that cleans up the hook before exiting. So, the code is shown below, you can download the source or just download the program itself. Enjoy!

using System;
using System.IO;
using System.Media;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;

class InstantRimshot {

    const int WH_KEYBOARD_LL = 13;
    const int WM_KEYDOWN = 0x100;

    delegate int Hook(int code, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll")]
    static extern IntPtr SetWindowsHookEx(int code,
                                          Hook func,
                                          IntPtr hInstance,
                                          int threadID);

    [DllImport("user32.dll")]
    static extern int UnhookWindowsHookEx(IntPtr hookHandle);

    [DllImport("user32.dll")]
    static extern int CallNextHookEx(IntPtr hhook,
                                     int code,
                                     IntPtr wParam,
                                     IntPtr lParam);

    static bool IsPressed(Keys check) {
        return ((Control.ModifierKeys & check) == check);
    }

    static void Main() {

        Stream sound = Assembly.GetExecutingAssembly()
            .GetManifestResourceStream("InstantRimshot.rimshot.wav");
        SoundPlayer player = new SoundPlayer(sound);
        player.Load();
        IntPtr hookHandle = IntPtr.Zero;
        hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL,
            delegate(int code, IntPtr wParam, IntPtr lParam) {
                if (code >= 0 && wParam == (IntPtr) WM_KEYDOWN) {
                    Keys vkCode = (Keys)Marshal.ReadInt32(lParam);
                    if (Keys.I == vkCode
                    && IsPressed(Keys.Control)
                    && IsPressed(Keys.Shift)) {
                        if (IsPressed(Keys.Alt)) {
                            UnhookWindowsHookEx(hookHandle);
                            Application.Exit();
                            return CallNextHookEx(hookHandle, code, wParam, lParam);
                        } else {
                            player.Play();
                        }
                    }
                }
                return CallNextHookEx(hookHandle, code, wParam, lParam);
            }, IntPtr.Zero, 0);
        Application.Run();
    }

}

Coco/R is open source and written in C# (at least one version of it) so it was easy to get the source. I then looked at a couple of tutorials on Visual Studio plugins and managed to hack together an plugin that works well enough for my needs. I also made a small change to the way Coco/R generates its parsers and scanners from frame files. Here are the features that are unique to the plugin:

• Works with Visual Studio 2005 and 2008
• When you click ‘Add a new item’ in a C# project, you’ll find a ‘Coco/R Attributed Grammar’ option under My Templates at the bottom of the screen. The .atg file you get has a simple example grammar that just reads numbers or identifiers. I wanted this because everytime I create a new .atg I start by finding an old one and copying the basics from it.
• Every time an .atg file is saved, the parser and scanner are re-generated. If the generated files are open then the AddIn closes them before re-generating, to avoid the dreaded “Files were reloaded” prompt.
• Errors and warnings from Coco show up in Visual Studio’s error list window just like build errors as soon as you save the .atg file.
• Instead of using frame files, the plugin uses partial classes for the parser and scanner. There are four files, Parser.cs, Parser.generated.cs, Scanner.cs and Scanner.generated.cs. This allows you to add stuff to your parser and scanner in an actual .cs file so you get the benefit of the Visual Studio editor, instead of having to write it in the .frame file or the .atg file.

So, that’s it. You can download an MSI installer for it and you can download the source. Enjoy.