Jelle Druyts

On a related note to releasing the much improved v2.0 of Flickr Schedulr, I just noticed that the previous release got mentioned in the BBC's Webscape reviews.

How awesome is that?!

It shows a quick tour of what the application does and how it works. And note that the part where they set up the Windows scheduled task is no longer necessary in v2.0 since that's now baked in

Hot off the press and might I add, finally! I just got around to packaging up and publishing the completely rewritten v2.0 of Flickr Schedulr.

Flickr Schedulr is a Windows desktop application that automatically uploads pictures to Flickr based on a schedule (e.g. to post a new picture every day at a certain time). It allows you to create a queue of pictures to be uploaded, along with their titles, descriptions, tags, and the photoset into which they should end up. This effectively takes the hassle of uploading pictures at regular intervals away, and allows you to go out and have fun shooting pictures (or drinking beer) while your photoblog is maintained for you.

What's new in this version?

• The application was completely rewritten in Windows Presentation Foundation (WPF), which makes for a much nicer user experience.
• You can now create a Windows scheduled task directly from the application.
• You can now assign a content type and license to pictures.
• You can now configure more than one Flickr account and maintain upload queues for each account separately from within the same application.
• You can now add pictures to the queue from the command line using the "/add" and "/addbatch" switches.

As always, you can find all information, screenshots and downloads on the dedicated site at http://schedulr.codeplex.com

Happy Flickring!

Ok maybe it's not just released but still I'm happy to finally put the word out that you can now install Mayando v1.2 directly from the Microsoft Web Application Gallery!

Mayando is a full-featured photo blogging application that you can use to showcase your photos online.

What's new in this release:

• Dates on photos are now hyperlinks to other photos taken or published on the same date.
• The Flickr photo provider no longer synchronizes machine tags (because they are not intended to be displayed).
• You can now configure the photo provider to synchronize automatically at regular intervals (e.g. every 60 minutes).
• You can also use a command-line client application (or if you're a developer, a client API) to remotely trigger a photo provider synchronization through the use of a new Service API.
• You can now filter the event log by severity.
• Mayando is now compatible with ASP.NET "medium trust" hosting providers.
• You can now disable distributed transactions (in the AppSettings.config file) if your hosting provider does not allow them. Note that this can cause data loss and/or corruption so only change this if you accept the risks associated with disabling transactions.

If you want to see it running: check out the Mayando Demo Site or of course my own photo blog.

Since it’s been almost two years since my last blog post, I figured I owed the remaining 3 subscribers of my blog a short update on what I have been up to...

#1 – Maya

There have indeed been a couple of interesting things going on, and first and foremost, that would include the birth of our amazingly beautiful and unbelievably cute daughter Maya in June last year

She just turned one year old this week, so time flies indeed! If you would be interested in seeing some more pictures, then I’m sure you can figure out where her own website would be located if you studied the incredibly complicated naming pattern I used to locate my own website

#2 - Mayando

Because Project #1 called for a way to keep the family up to date and to regularly show off exactly how cute Maya is, and (almost equally importantly) because I was looking for an excuse to learn ASP.NET MVC, I decided to write a photo blogging web application. “What, another photo gallery site”, you might ask? Eh, yeah, exactly. But in my defense: I looked hard at the existing ones and couldn’t find one that covered my requirements so this is one I built to fit my needs

Nonetheless, I didn’t just want to build a one-off “baby web site for Maya”, but really a generic application that I could also use later on use as the engine for my own photo blog – and that you, dear reader, might also want to use if you want to publish a collection of photos in a nice and user-friendly way. (For example, I have an architect friend who is interested in using it as a portfolio site for the houses he designed.)

And so, Mayando was born: a full-featured photo blogging application that you can use to showcase your photos online.

Now I did not want to reinvent solutions to the problem of globally storing and serving images on the web, so I figured that I should only build a rich front-end on top of existing photo storage services such as Flickr. So I built a provider model where the URL’s of the photos and their details (and comments) just get “sucked in” from a photo sharing site and you can work with them from your own website. So basically, the photos get pulled in from a service such as Flickr and then displayed through Mayando, using a lot of navigation possibilities (by creating static pages and dynamic galleries, by browsing through photos, comments, tags, dates, ...).

It also allows visitors to post new comments and obviously I needed to handle comment spam so again I implemented a provider model for anti-spam services (such as Mollom).

And finally, the whole thing had to be easily customizable so I made sure to allow different themes for the photo blog’s look and feel, with customization options ranging from simple (e.g. simply changing the CSS stylesheet) to advanced (completely changing the entire site layout and/or individual pages). Thankfully, by now I know that the ASP.NET MVC framework is so flexible it easily let me do all this with surprisingly little effort. Anyway, I won’t go into the many details – if you’re interested in how it works: it’s open source so feel free to look at the Mayando source code and let me know if you want to contribute!

If you just want to see it running: check out the Mayando Demo Site or of course my own photo blog

#3 – Flickr Schedulr v1.4 & v2.0

Because Project #1 and Project #2 meant I would be using Flickr more, I figured it was also time to give my Flickr Schedulr application an update to incorporate feedback from a number of users.

In case you’re wondering what it is: Flickr Schedulr is a Windows desktop application that automatically uploads pictures to Flickr based on a schedule (e.g. to post a new picture every day at a certain time). It allows you to create a queue of pictures to be uploaded, along with their titles, descriptions, tags, and the photosets and groups into which they should end up.

I published v1.4 last January; new features include the possibility to upload multiple pictures at a time in batch, better handling of multiple selected files and overall UI improvements.

I’ve also been working really hard on v2.0 which is a complete rewrite of the application in Windows Presentation Foundation (WPF), and as such looks and feels so much nicer in many ways than the previous version. It will also have a few new features of course. I’m still polishing some things but you can expect to see a release in the next few weeks.

Since I’ve been very happy with CodePlex for my other projects, I decided to move the source code and work items there and lo and behold: here is the new Flickr Schedulr homepage on CodePlex!

#4 – Proxy Monitor

Last October, the trend continued: another release around a year after the last one. This time, I got the help from David Huntley, who was kind enough to finally get something off my list I’ve been planning to do for a while now: properly setting the proxy via the Win32 API’s instead of just writing to the registry. This more robust way of setting the proxy came for free with the new feature he implemented, which is support for multiple connections. This allows you to specify proxy servers for other connections than the default LAN (such as dial-up or VPN connections).

To make it easier to work together, I decided to move this project to CodePlex as well. So for all information, downloads, forums, etc. go to the new Proxy Monitor homepage at CodePlex!

#5 – The NOT Part

So after a small list of things that I have been up to the last two years or so, it’s quite clear what I have not been up to: blogging. And that’s probably going to stay that way. I either have too little to say (which is increasingly the case), or too much (which would take too much time to write down). So honestly, I expect this would be the last entry on my blog for quite a while – if not eternity.

In case it becomes the latter: thanks for having followed my random thoughts for the last 7 years, and if you want to keep up with what I’m doing on the technical side of life, follow my projects on CodePlex:

• Mayando
• Flickr Schedulr
• Proxy Monitor
• BuildCop
• Configuration Section Designer
• Mollom for .NET

If you want to keep up with the non-technical side, check out my photography site - <plug>based on Mayando of course, and updated with the help of Flickr Schedulr</plug>

Interestingly, I seem to have a near-yearly rhythm of releasing new versions of Proxy Monitor. This minor release adds the "skipAutoDetect" attribute to support proxies that are only set manually, and I also (think I) fixed the bug where Interet Explorer would override the proxy settings again (at random) to their previous values.

Proxy Monitor is a small application that monitors the network and auto-detects the internet proxy server to use. It can be started as a regular application, which will make it run as an icon in the system notification area. When started, it will auto-detect the proxy server to use. It will also automatically re-detect the proxy server when the computer’s network address has changed. The application can also be run from the command-line with the /detect flag to auto-detect the proxy and exit immediately (e.g. when the computer starts up).

You can download the tool below. Don't hesitate to contact me for suggestions or bug reports!

The ProxyMonitor 1.2 executable (103 KB)

The ProxyMonitor 1.2 source code (104 KB)

You can also view the Readme file online.

I've just published another update to my guide on Setting up Source Server for TFS Builds, since the Debugging Tools for Windows now has built-in support for Team Foundation Server. So that means: no more third party downloads and an even simpler installation procedure! I've also updated the document to reflect all applicable versions of the tools you'll be using: Visual Studio 2005 and 2008, as well as Team Foundation Server 2005 and 2008.

Because I have been troubleshooting Source Server issues a few times as well, I also added a chapter on how to find out what's going on inside the Source Server indexing and what might be going wrong. Note that there is some Perl going on in there, so avert your eyes if you can't handle the look and feel of it (I know I can't)

For the full setup instructions, please refer to the original post on Setting up Source Server for TFS Builds.

Oh, and finally, my homie Pieter also posted a more detailed guide on how to set Source Server support up inside the Team Build script - and what's more important, what the invaluable benefit is of having a central reusable build script. Great job Pieter!

While it seemed a simple requirement, saving all attachments from emails in Outlook to disk proved to be challenging - to say the least. Using the Outlook Object Model, it's quite easy to enumerate all emails in a folder, look at their attachments and call the SaveAsFile method on them. However, for OLE-type attachments (typically images), this throws a COMException saying: "Outlook cannot do this action on this type of attachment". While looking for alternatives or workarounds, I found nothing but confirmation that this is indeed not an easy task - even from Dmitry Streblechenko, Outlook MVP and creator of the excellent and very affordable Outlook Redemption library: "If you mean embedded graphics objects in the RTF messages, there is not much you can do [...] You can look at the storage itself to figure that out, but I've never tried that".

Ultimately, after lots of trial and error, I did manage to find a fairly easy way to save these OLE embedded images by (mis)using the clipboard. Basically, I retrieve the attachment’s IStorage OLE interface (available through Redemption) and call OleLoad on it to have OLE load the contents and retrieve an IDataObject. The magic trick is to place that IDataObject on the clipboard and retrieve the actual image from the clipboard (so that the clipboard itself handles the nasty OLE details).

Great success! At least for a moment. That already worked for Device Independent Bitmaps, but Outlook also uses Enhanced Metafiles (wmf) and apparently there is a problem with the .NET Framework when it comes to handling Enhanced Metafiles from the clipboard. So I needed some additional COM interop to handle these Enhanced Metafiles as well, which made the code slightly more difficult to read but fortunately still effective. The trick here is to make sure you have a valid handle to pass to OpenClipboard. Because I didn't have access to a form or other type of existing control, I just created a dummy button and used its handle.

Finally, be aware that to access OLE functionality, you need a Single Threaded Apartment (STA) model. Of course I was in an MTA context, so from there I launched a new thread which I put to STA - after that, everything was golden.

Below is the full code using Redemption Data Objects (RDO), hopefully this will save other people a few hours in trying to achieve the same thing...

public static class Program
{
  public static void Main()
  {
    // Calling code should always ensure to be in STA.
    Thread staThread = new Thread(new ThreadStart(SaveOutlookAttachments));
    staThread.SetApartmentState(ApartmentState.STA);
    staThread.Start();
  }

  private static void SaveOutlookAttachments()
  {
    RDOSession session = new RDOSessionClass();
    RDOFolder inbox = session.GetDefaultFolder(rdoDefaultFolders.olFolderInbox);
    string attachmentRootPath = AppDomain.CurrentDomain.BaseDirectory;
    foreach (RDOMail mail in inbox.Items)
    {
      foreach (RDOAttachment attachment in mail.Attachments)
      {
        if (attachment.Type == rdoAttachmentType.olOLE)
        {
          // We don't have a filename for this type of attachment, create a unique one.
          string filename = Guid.NewGuid().ToString() + ".png";
          string attachmentPath = Path.Combine(attachmentRootPath, filename);
          // We assume here that only images will be stored as OLE attachments.
          // We save them as PNG to keep the file size small.
          SaveOleImageAttachment(attachment, attachmentPath, ImageFormat.Png);
        }
        else
        {
          string attachmentPath = Path.Combine(attachmentRootPath, attachment.FileName);
          attachment.SaveAsFile(attachmentPath);
        }
      }
    }
  }

  private static void SaveOleImageAttachment(RDOAttachment attachment, string filePath, ImageFormat format)
  {
    // Use the OLE storage interface to load the OLE document into a DataObject.
    IStorage oleStorage = (IStorage)attachment.OleStorage;
    object oleDataObject;
    OleLoad(oleStorage, ref IDataObjectGuid, null, out oleDataObject);

    // Copy the OLE DataObject to the clipboard so it can handle the internals.
    Clipboard.SetDataObject(oleDataObject, false);

    // Try to retrieve an image back from the clipboard.
    if (Clipboard.ContainsData(DataFormats.EnhancedMetafile))
    {
      // Enhanced Metafiles cannot be handled natively from .NET.
      // Use the Clipboard directly to retrieve the data.

      // We need a valid handle, otherwise this won't work.
      Button dummy = new Button();
      if (OpenClipboard(dummy.Handle))
      {
        try
        {
          if (IsClipboardFormatAvailable(CF_ENHMETAFILE))
          {
            IntPtr metafileData = GetClipboardData(CF_ENHMETAFILE);
            if (metafileData != IntPtr.Zero)
            {
              using (Metafile metafile = new Metafile(metafileData, true))
              {
                metafile.Save(filePath, format);
              }
            }
          }
        }
        finally
        {
          EmptyClipboard();
          CloseClipboard();
        }
      }
    }
    else if (Clipboard.ContainsImage())
    {
      using (Image image = Clipboard.GetImage())
      {
        if (image != null)
        {
          image.Save(filePath, format);
        }
      }
    }
  }

  [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
  private static extern bool OpenClipboard(IntPtr hWndNewOwner);
  [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
  private static extern bool CloseClipboard();
  [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
  private static extern IntPtr GetClipboardData(uint format);
  [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
  private static extern bool IsClipboardFormatAvailable(uint format);
  [DllImport("user32.dll")]
  private static extern bool EmptyClipboard();
  [DllImport("ole32.dll")]
  private static extern int OleLoad(IStorage pStg, [In] ref Guid riid, IOleClientSite pClientSite, [MarshalAs(UnmanagedType.IUnknown)] out object ppvObj);

  private static Guid IDataObjectGuid = new Guid("0000010E00000000C000000000000046");
  private const uint CF_ENHMETAFILE = 14;
}

My friend Dries Buytaert - known all around the world for creating Drupal (the wildly popular open source content management system) and Axl (the incredibly cute kid he co-created with my even better friend Karlijn) - asked me a few months ago if I had any trouble with spam on my blog... It turned out he was building Mollom, a solution for fighting spam and automating content monitoring, and was looking for beta testers. I immediately jumped aboard and implemented a .NET client API for his service and integrated it into dasBlog, the blog engine I'm using.

Now that Mollom and its API and developer documentation have finally been released (in public beta), I've packaged my client library as well and published it on CodePlex: see the Mollom for .NET homepage.

Mollom's purpose is to dramatically reduce the effort of keeping your websites clean and the quality of their user-generated content high. Currently, Mollom is a spam-killing, one-two punch combination of a state-of-the-art spam filter and CAPTCHA server.

I have to say it's working really well for me, I don't get any spam at all anymore through my blog, and the XML-RPC API that Mollom provides is easy and straight-forward to use. And, of course, if you develop on .NET then it's even easier to talk to Mollom using my client API. As a very basic sample, this should give you an idea of how easy it is to have Mollom classify a piece of content:

MollomClient client = new MollomClient(privateKey, publicKey);
ContentCheck result = client.CheckContent(postTitle, postBody, authorName, authorMail, authorUrl, authorIPAddress);
if (result.Classification == ContentClassification.Spam)
{     // Handle spam here...
}

All information, downloads and documentation is available on the Mollom for .NET homepage on CodePlex, so rush out and let me know what you think!

Just a quick note to let you know that I've updated my guide on Setting up Source Server for TFS Builds, since I just found out that there is an issue with Build Definitions that contain spaces. The fix is fairly easy though:

• In TFIndex.cmd (on the build server), remove the quotes around the %1 argument for SYMBOLS:

@call "%~dp0SSIndex.cmd" -SYSTEM=TF -SYMBOLS="%1" %*
@call "%~dp0SSIndex.cmd" -SYSTEM=TF -SYMBOLS=%1 %*

• In the Team Build Script (in Source Control), add XML-escaped quotes around the $(BinariesRoot) argument:

<Exec Command="&quot;C:\Program Files\Debugging Tools for Windows\sdk\srcsrv\TFIndex.cmd&quot; $(BinariesRoot)"
      WorkingDirectory="$(SolutionRoot)" />
<Exec Command="&quot;C:\Program Files\Debugging Tools for Windows\sdk\srcsrv\TFIndex.cmd&quot; &quot;$(BinariesRoot)&quot;"
      WorkingDirectory="$(SolutionRoot)" />

For the full setup instructions, please refer to the original post on Setting up Source Server for TFS Builds.