As I said earlier, my problem was that I can't display Images that don't have a URL in the hosted Internet Explorer, but that I wanted to keep HTML-compatible pages. The first approach is to have a local web server that delivers the pages. There is however a second approach, which involves actually having the images in the file system. I could either store them in the database and "extract" them to a temporary directory when SWiki starts, or I could keep them externally and only "register" them in the database.

I think I like that approach as well, because it solves any corporate networking concerns (IT usually isn't too happy with people running their own rogue web servers within a corporate network...).

I'm busy with some other projects and I have to find a new name for SWiki (someone else had the name before ), but I do now have a good idea on what I want to do with it and how to achieve that.

Usage example:

var date1 = new Date(2010, 3, 1, 10, 10, 5, 0);
var date2 = new Date(2010, 3, 1, 10, 10, 10, 0);
var ts = TimeSpan.FromDates(date2, date1);
var ts2 = TimeSpan.FromDates(date2, date1, true);
alert(ts.totalSeconds()); // -5, because we put the later date first
alert(ts2.totalSeconds()); // 5, because we passed true as third parameter

[Section]
Key=Value
SomeOtherKey=SomeOtherValue

[AnotherSection]
Hello=World

Hardly exciting, but it gets the job done very well. Today I wanted to work with INI Files in my C# Application, both for reading and writing. But as I just found out, .net does not have built in functions for working with .ini files. It looks like they want everyone to work with XML Files now. Well, apart from the fact that XML looks like my keyboard puked on my hard drive and that the format is unneccesarily complicated for this purpose, I also found that reading and writing them is rather complicated, especially since the XmlSerializer has some stupid restrictions (one being that the class needs to be public - have they never heard of reflection?).

It's great that the .net Framework is so powerful - I believe I can write a function that downloads an MP3 off the internet and uses it to generate a gradient in an image which then gets encrypted and sent per e-Mail in maybe 5 lines or so, but when it comes to something simple as saving some Key/Value Pairs, I still need a crapton of code. So I binged the internets a bit and found some code that uses P/Invoke to call Kernel functions to handle ini files, but I want to avoid P/Invoke at all costs. So in the end I simply wrote a class to Load/Save Ini Files.

It's a simple class to interact with a simple file format that was created to store Key/Value pairs and that just works. Seriously, don't change what isn't broken. The class is licensed under WTFPL and can be downloaded here.

Also, because SWiki is still under heavy development, I would have to chase translations first before I can release. So for the time being, I moved it to a later version in the road map.

Instead, I have added a feature to 0.12 that I really needed now that I'm actually using SWiki to create some documents, and that is re-parenting of pages. This allows you to move pages within the tree to other pages. You can not turn a page into a root page at the moment (that was an oversight, to be fixed in 0.13).

Additionally, the Page view now allows copying text through CTRL-C or Right Click => Copy, and in the navigation tree on the left, the Main Page will always be the first page. You can download SWiki 0.12 on the CodePlex Download Page.

Unfortunately, Localization support in Visual Studio 2008 left me somewhat unimpressed. So I set the "Localizable" property of my Form to true and then automagically it creates the resources I need and allows me to change any form settings, including Text, Position, Size etc. That is so far a great idea and works very well, but it has several drawbacks:

• One resx file per form and language means exponential growth of files
• The resx files are tied to the form - which means I cannot just put them in a "Localized" Folder
• While it's great that Forms are supported, I still have to find another way for my Exceptions and other Non-Form Code
• Translations are stored in satellite assemblies. The Goal of SWiki is to have as few files as possible, preferably only one.
• No way to share strings between different parts

In short: The built in support is unsuitable for SWiki. I have put my requirements in a StackOverflow question, but the answers were somewhat discouraging. I have looked around a bit and naturally also ended up at GNU Gettext which handles strings, but does not solve the problem of a) non-string content (Images, Location/Sizes of Controls) and b) the actual application of resources to the target.

One of the main issues is that the InitializeComponent() function is somewhat untouchable, as the designer will break if you change it too much and will replace your code with it's own anyway. Visual Studio is certainly not lying when it tells you to not mess with the function.

So anyway, I have just decided to build my own localization framework for use with the SWiki UI. Finding a name was reasonably easy, I just called it "The Wheel". I don't know if it's going to be much use, but just in case, it's going to be licensed under Microsoft Reciprocal License (Ms-RL). Release Date? I don't know, I hope by the end of the week.

Export Wiki into HTML Files
Using the now-functional export button in the button bar, you can export your wiki to HTML files. This will generate one file per page, complete with navigation.

Diff between Revisions
There is now a new "Diff" Tab on the main screen. This allows you to pick any two revisions of a page and quickly compare them.

Other changes
Apart from these two big points, there are some other changes. In the doc folder, you will find a more elaborate user manual in .swk format. The navigation menu on the left has a context menu now to add new pages. The Syntax Help window should no longer open outside of the screen if the SWiki window is too close to the edge.

Download SWiki for free on http://swiki.codeplex.com/

You can give a Title to each database now. To do that, simply click on the settings button (the cogwheel in the lower left button bar) and type in a title. The new Title will be reflected on the title bar as well, which is useful if you have multiple SWiki instances open.

There is a new Macro that you can use in your wiki pages to change the color of text: [color:ff0000|Your Text] will display the text in red. You can of course combine this with other format specifiers, for example *[color:0000ff|Your Text]* for bold blue text.

Also, there are a few UI Bug Fixes. The tab order should make sense in every window, and you can actually press return in the "New Page" dialog. Users of Version 0.9 will have to convert their database into the new format, as 0.10 changed the schema. To do that, there is an Upgrade tool included.

Download it for free from CodePlex now

    this.browser.ObjectForScripting = this;

The next step was to create a function in my Form that can be called:

    public void BrowserInternalLink(int targetPageId)
    {
        ChangePage(targetPageId,null);
    }

I've created some code for testing that illustrates how to call it:

    sb.Append("<a href=\"javascript:window.external.BrowserInternalLink(1)\">Test</a>");

So this would call my BrowserInternalLink Function with the Parameter 1. Pretty neat, but still useless as it's hardcoded

The next step is to add support to the [wiki:PageId|Description] syntax to WikiPlex. Here, two articles are really important: Extending WikiPlex with Custom Macros and Extending WikiPlex with Custom Renderers.

If you want to add your own Tags to WikiPlex, you may need both usually. A Macro is some RegEx that tells WikiPlex to search for certain tokens and how to interpret them (For example, you can tell WikiPlex that you want to discard a part of the token, but pass other parts into a renderer). A renderer takes the Input and outputs some HTML. As said, your Macro is split into multiple parts (depending on your RegEx) and in theory you can pass every part into a different Renderer.

Have a look at WikiPlexExtensions.cs in the SWiki Source Code to see my implementation. The main downside of this whole approach is that it requires FullTrust, but so far I don't know a better alternative. There is a GDI+ HtmlRenderer on CodeProject, but that sadly renders out images, which means: No links, no Copy/Paste, just look but don't touch. The Mono Project seems to have a very interesting approach, but "Replacing the Browser" is currently low priority, especially since Windows 7 E will not happen (By the Way: SWiki is of course compatible with Windows 7)

I really like WikiPlex so far, as it is a very clean and extensible Wiki Parser, and I think I will have a lot of fun with it

SWiki 0.9 also allows you to print out pages now, simply click the new Printer-Button on the lower left toolbar.

Grab it from CodePlex now

So ideally I want something like a Wiki: Rudimentary but solid and easy formatting, no black auto-correction magic that gets in my way, and a nice document outline. The problem with MediaWiki is that it requires a webserver and MySQL database, which is a bit heavyweight. I looked at alternatives and found ScrewTurn Wiki Desktop Edition which sadly requires installation, and TiddlyWiki which looks great at first, but somehow I've lost my data twice, possibly by not saving even though AutoSave is ticked. I don't know, maybe I am just not smart enough to use it, but I did not like it.

At the end, I decided to roll my own thing, called SWiki. SWiki is a simple, standalone wiki. At it's core, it's a SQLite database, using WikiPlex as it's WikiParser and the C# WebBrowser Control as an integrated Browser. No installation required, only .net Framework 3.5 SP1 needs to be installed. It's Open Source and Version 0.8 can be downloaded on CodePlex.

It may not be the most impressive software ever written, but hey, I've written this for me after all

SWiki 0.8

Changes in this Version:

Version 1.0.5 (2009-05-09)
cmdhashgen

• Supports CRC32 hash
• Gracefully handling error if you try to hash a file you don't have access to

cmdnetsendmail

• Ability to embed text files instead of attaching them

It has improved. But not that much. Software like WordPress is still miles ahead, and I am not even talking that much about functionality here. I'm talking about some fundamental things like ease of installation. Or about the fact that Settings in the WordPress Control Panel are actually *explained*. Or the fact that I can put in RAW HTML into my postings WITHOUT WordPress destroying it. Sure, if I switch between WYSIWYG and HTML View, there may be a breaking conversations when using funky HTML, but if I stay in HTML, it just works. If I put in Garbage, then WP will output garbage.

I'm not even talking about the Theme and Plugin momentum that WordPress has. I am really just talking about a Software that is easy to install, runs on my hosted server and allows pushing of some Content. Is that asked too much? Sadly, yes. I don't want to be too harsh, hence I will not name the tools I've tried (there were 4). I don't want to blame developers who are really trying to do something for issues that lie within the framework. The ASP.net infrastructure has a lot of advantages over PHP, but as good as stuff like Web.config, Medium Trust and SQL Connection Strings is, it's adding more complexity that developers seem to not try to take away from the end user.

I don't know if this is the fault of the ASP.net Webforms model or if the .net OSS Community is smaller or whatever. I've now decided to tackle something that I have on my ToDo-List since writing that post in November 2007, I've decided to write my own blog software. I want to encounter the problems that the people who are creating it have, I want to run it in a production environment (Dogfooding, so to say). The recent release of ASP.net MVC was the final bit that removed all excuses for not doing it.

I will run into a lot of issues. I want to learn and use TDD, DI and ORM, and I have experience in none. I will do a lot of refactoring, and a lot of breaking changes and braindead mistakes. But I don't want to be a complainer anymore when I have the opportunity to change it.

I don't want to announce too much because it's still in the early stages, but it will be open source (Ms-PL) and hosted on Codeplex.

In Version 02 of Rick, I have added a custom ActionResult to perform a HTTP 301 redirect instead of the default HTTP 302 one. You can get the Source Code on http://www.codeplex.com/rick, and you can watch the tutorial video on Vimeo. Topics include a short overview of HTTP 301 vs. 302 and how to actually create a custom ActionResult.

Rick Version 02 - Building a custom ActionResult to perform a HTTP 301 redirect from Michael Stum on Vimeo.

I wanted to kill three birds with one stone, so I decided to make this a standalone project. The three birds are 1. the actual URL shortening Service, 2. a project where I can play with all the newest technologies, 3. a project that allows me to create some tutorial videos.

The name of the Project is "Rick", and it's source code is hosted on CodePlex, at http://www.codeplex.com/rick

Version 01 was just released, and it actually fully works already: You can put in a long URL, get a short URL back, put that short URL in a browser, and get redirected to the original URL. And the best of all: I have created a Tutorial video for that, which you can watch online or download (download requires free registration with Vimeo). Granted, Version 01 is ugly, has no error handling and lacks a lot of features, but I am actually going to improve it over the next few weeks, making it more robust and I also plan to add more technologies to it, for example Windows Azure or Silverlight.

For your convenience, here is the video:

Rick Version 01 - Building a URL Shortening Service in ASP.net MVC from Michael Stum on Vimeo.

Please let me know what you think and what you would like to see in the future.

So here is my little PermanentRedirectResult:

public class PermanentRedirectResult : ActionResult
{
    public string Url { get; set; }

    public PermanentRedirectResult(string url)
    {
        if (string.IsNullOrEmpty(url))
        {
            throw new ArgumentException("url is null or empty", "url");
        }
        this.Url = url;
    }

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }
        context.HttpContext.Response.StatusCode = 301;
        context.HttpContext.Response.RedirectLocation = Url;
    }
}

If you have a look at the sidebar, you will find a "Recently Played Songs" near the bottom. Achieving this is the ultimate goal of this small article series, and I'll walk you through the steps needed to achieve this automatically.

The Series of Articles will include:

1. Grab the contents of a Playlist from iTunes
2. Making the Songlist sortable by using IComparer and IComparable
3. Create a XML File
4. Upload this file via FTP to this Server
5. Write a PHP Script that performs an XSL Transformation (XSLT) on the Xml File and Call this file from Sidebar.php within WordPress

Of course, the last step applies to PHP and WordPress, but if you have an ASP.net, a Ruby on Rails, a Python or whatever Web Server, you can still follow the base concepts if you'd like.

Let's get started. Yesterday, we created a Class called "Song" which essentially represents all the data about a song that we're interested in and a custom Comparator to be able to sort it. Now, we extend this class a little:

[Serializable()]
public class Song : IComparable<Song>
{
    public string Title { get; set; }
    public string Artist { get; set; }
    public string Album { get; set; }
    public int Year { get; set; }
    public int Length { get; set; }
    public int PlayCount { get; set; }
    public DateTime LastPlayed { get; set; }

    public string LengthAsString
    {
        get
        {
            TimeSpan ts = TimeSpan.FromSeconds(this.Length);
            if (ts.Hours > 0)
            {
                return string.Format("{0}:{1:00}:{2:00}", ts.Hours,
                                              ts.Minutes, ts.Seconds);
            }
            else
            {
                return string.Format("{0:00}:{1:00}", ts.Minutes, ts.Seconds);
            }
        }
    }

    public override string ToString()
    {
        return
        string.Format("{0} - {1} ({2}, {3}) [{4}] {{Last Played: {5:dd/MM/yyyy HH:mm}, Total: {6}}}"
        , Artist, Title, Album, Year, LengthAsString,LastPlayed,PlayCount);
    }

    #region IComparable<Song> Members

    public int CompareTo(Song other)
    {
        return this.LastPlayed.CompareTo(other.LastPlayed);
    }
    #endregion

    public int CompareTo(Song other, SongComparer.SortField field, bool sortDescending)
    {
        int result = 0;
        switch (field)
        {
            case SongComparer.SortField.Album:
                result = this.Album.CompareTo(other.Album);
                break;
            case SongComparer.SortField.Artist:
                result = this.Album.CompareTo(other.Artist);
                break;
            case SongComparer.SortField.Title:
                result = this.Title.CompareTo(other.Title);
                break;
            case SongComparer.SortField.Year:
                result = this.Year.CompareTo(other.Year);
                break;
            case SongComparer.SortField.PlayCount:
                result = this.PlayCount.CompareTo(other.PlayCount);
                break;
            case SongComparer.SortField.Length:
                result = this.Length.CompareTo(other.Length);
                break;
            case SongComparer.SortField.LastPlayed:
                result = this.LastPlayed.CompareTo(other.LastPlayed);
                break;
        }
        if (sortDescending) result = result * -1;
        return result;
    }
}

Compared to yesterfay, the CompareTo function was modified and overloaded. Yesterday, the function was always trying to sort by LastPlayed date, descending. Now, I have added an Overload which takes two additional parameters to determine a field to sort by and whether or not to sort in descending order. Also note that we are not coding the actual comparison logic ourselfes. Yesterday i've done it to illustrate the 3 return values, but here we are just calling the CompareTo-function that many .net Types already implement, hence no need for extra logic on our side.

For our Overload to work, we need to create a class that implements IComparer. Notice the difference between IComparable and IComparer. IComparable indicates that the Object which implements it can be compared to other objects of it's type, whereas IComparer is a "stand-alone" class that can be used against different objects. Also have a look at two blog articles about IComparable and IComparer. So here is a new class, the SongComparer:

public class SongComparer : IComparer<Song>
{
    public enum SortField
    {
        Title,
        Artist,
        Album,
        Year,
        Length,
        PlayCount,
        LastPlayed
    }

    public SortField Field { get; set; }
    public bool SortDescending { get; set; }

    public SongComparer()
    {
        SortDescending = true;
        Field = SortField.LastPlayed;
    }

    #region IComparer<Song> Members

    public int Compare(Song x, Song y)
    {
        return x.CompareTo(y, Field, SortDescending);
    }

    #endregion
}

This class starts out with an enum that defines the various fields that one can sort by. Now, using an enum is simple but if you add a field to the Song class, you have to extend the enum as well. There are other solutions to that (i.e. using Reflections), but again, for the sake of simplicity an enum works. We have then defined a class property to hold the selected field, and a boolean that indicates whether or not we want to sort descending. Our constructor just sets some default values (LastPlayed, descending). The important function is the Compare function. This takes two objects, and is then supposed to return one of the 3 return values that IComparable.CompareTo also returns. So in this case, it calls our overloaded Song.CompareTo() function. If you have a look at this function again, you see that it will now just look at the field and if the sort should be descending, it will just invert the result (through * -1).

The concept of IComparable and IComparer is quite simple, yet a bit tricky to grasp at first. The biggest issue is the compare order: You always compare the first object to the second object (first.CompareTo(second) or this.CompareTo(other)), otherwise the result will be in the wrong order.

So now that we have our custom IComparer, how do we use it? You can create an instance of the SortComparer class and then just pass it into List.Sort():

comparer = new SongComparer();
comparer.Field = SongComparer.SortField.PlayCount;
comparer.SortDescending = true;
List<Song> result = new List<Song>();
// fill the List...
result.Sort(comparer);

The List will now be sorted descending by PlayCount instead of LastPlayed. So now that we have made the Song class generic enough to sort by whatever field we like, the next step is to turn it into Xml. We will tackle that in an upcoming blog post.