Anyway, I did do some work in WPF earlier this year, in building a digital signage system for the National Sports Museum. Basically a display of current world records, it needed to be attractive, have interesting transitions, and be very easy to update.

In years gone by I would certainly have built this kind of thing in Flash, possibly under the control of a C# shell program. But it seemed like a good opportunity to get my feet wet with WPF, and so I gave it a go. It was a struggle, but with the aid of a good textbook (Programming WPF by Chris Sells and Ian Griffiths) I managed to achieve a pretty good result, I think. By the way, I do find that when learning something new it’s far more helpful to have a good, hardcopy, text book by my side than any amount of electronic help.

So over the weekend I got the impulse to do some more with WPF, the trigger being some astronomy articles I was reading.

A long time ago I wrote a program called Gravitorium, still available as shareware (though hardly anyone ever buys it now). The purpose was to act as a simple simulator of gravitational interactions between arbitrary stars, planets, asterioids, etc. Build your own solar system and see what happens. Throw a black hole through the middle of our own solar system. That sort of thing.

Now here’s the thing: Gravitorium was written nearly 10 years ago, in Visual Basic 6. Calculating all the interactions in such a system is very slow, and updating the display is even slower. Running on the kind of computers and graphics cards we had 10 years ago, it’s surprising that I was able to get any kind of reasonable result at all. Watching a simulation the motion of the Moon around the Earth, for example, was a bit like watching grass grow, unless you cranked down the accuracy of the simulation a fair bit.

So for some time I’ve been toying with revisiting the program, using modern programming techniques and a much faster computer platform. And I figured that WPF, which gives direct access to the graphics processor, would be just the shot to give a much speedier result.

Well, so far it hasn’t worked out like that. Now do bear in mind that in what follows I’m just going to be exposing my experimentation and learning processes to you. If you already thoroughly understand WPF, this article is not for you!

I can see that there are going to be major benefits from a WPF approach. For example, in the old Gravitorium I was doing some pretty dumb things to draw planets and orbits. Everything happened on a PictureBox control. To create the illusion of a moving object I first drew a colored circle and then on the next phase, ‘erased’ it by drawing a black rectangle over it. All the objects and all of orbital trails were just bitmapped onto a single layer. The orbit trails were just literally painted dots, and each time the display is rescaled, I had to keep track of the dots and repaint them.

In my new version, I’m playing with using a WPF Canvas object, and associating Ellipse, Label and Polyline objects with each body in the system. These get moved around as the calculation proceeds, and WPF takes care of redrawing the display. The Polyline object redraws the orbital trails (admittedly as a series of straight lines rather than curves, but the segments are so small they look smooth).

It’s kind of working, but I’m not there yet! Refreshing the display regularly is a bit of a struggle, which I don’t yet understand. In the old Windows Forms days, I would just repaint things in a loop, invalidating the picture box or doing an Application.DoEvents() call. You can’t do that in WPF, which seems odd. I found a couple of ways around this limitation. The one that works best so far is a ‘fake’ DoEvents() procedure which I found here. I modified it by adding the null object check, which avoids an exception on closing the application.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

using System.Threading;
using System.Windows.Threading;
//....
 
/// <summary>
/// Processes all messages currently in the message queue.
/// </summary>
/// <remarks>
/// This method can potentially cause code re-entrancy problem, so use it with great care.
/// </remarks>  
public static void DoEvents()
{
     if (Application.Current !=null)
    {
       Application.Current.Dispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate { }));
     }
}

I do suspect that having to use a crutch like the above means that I don’t have my head around WPF as yet.

Anyway, the revisited application (which at present is only a proof of concept) is coming along:

This is working fast enough to be able to animate the labels along with the objects (the VB6 version has to pause to show labels) and still get a pretty swift animation. At an equivalent level of accuracy the VB6 version takes 95 seconds to complete an orbit of the Moon. The WPF one, even with the overhead of redrawing labels, only takes 25 seconds. That’s about a four-fold increase in speed, and the results look much nicer.

Anyway, this is a WPF Work in Progress, so I’ll return to it as I continue my learning process.

I must say that Flash’s Action Script 3 is a much better way to do this kind of work than the old days of AS2 (yeah, I know that is a long while ago now, but I’m old and I’ve been working in Flash since Flash 4, so I still think of AS3 as new).

But I do find the problem with moving between all of these C-like languages is keeping them all straight in my head, they are all so similar these days. So similar that it’s really easy to forget the differences until you are brought up short by something going wrong. With luck, this will occur at compile time. If you’re not so lucky, it will happen at run time, in certain circumstances only.

The languages I’m thinking of are:

• C#
• Action Script 3
• Javascript
• PHP
• Objective C

I program in these languages pretty much all the time (though mostly in C#, and with Objective C very much the newcomer to my experience).

You could also add:

• Java
• …and probably several other languages

They all have essentially the same structures – a switch statement, a for statement or an if-then-else is pretty much identical in them all. It’s as though the whole world had converted to speaking English – but with various regional dialects. And you have to keep straight in your head which country you are in at the moment so you get the dialect right.

So changing from C# back to AS3 requires a fair bit of concentration.

Where they don’t compare, though, is in their respective IDEs (Integrated Development Environments). I should probably be using Flex, rather than Flash, and the Eclipse IDE, which isn’t bad, as the tools inside Flash itself are absolute rubbish. I actually find myself using Dreamweaver as a better AS3 code editor than what is available inside Flash CS3.

The Objective-C IDE on the Mac (XCode) is pretty good, in comparison, but still not a patch on Microsoft’s Visual Studio, in my humble opinion.

Microsoft do a lot of things very poorly, but developer tools they still do extremely well. If only they would stop fiddling with C# and not keep issuing new versions of it, each new version requiring a yet bigger .NET Framework to be downloaded by my end-users. I have to say that I’m yet to spend much coding time using the additional features in C# version 3, such as LINQ, let alone the new features which are planned for C# version 4, out real soon now. Most of the time I still target the .NET Framework 2, which is nice and small. Well, 20 MB is small by today’s standards.

Updating Chapter Master

At the moment, my main challenge is trying to get out another version of my shareware software Chapter Master.

It’s going on for a year since the last release, and at that stage the software, while working well for most people, was still in my mind a little experimental. Certainly time to consolidate what I have learned since the last release, add some requested features, and some ideas of my own.

The purpose of the software is to create or manipulate ‘chapter stops’ and optionally ‘chapter images’ in AAC files (*.m4b or *.mp4 extension). These are the files treated as audiobooks or ‘enhanced podcasts’ by Apple’s iTunes and the iPod. Chapter stops create points within the file to which the user can easily navigate. Ideally, of course, one would position these chapter stops at the exact times in the audiobook where the narrator says “Chapter Five” or “Book Three” or “Part Two”. The software will let you do that manually, but no way can I imagine what artificial intelligence would be required for the software to automatically find such points, though it has been requested.

My companion software MarkAble will allow you to merge together a bunch of source files and insert chapter stops at the beginning of each new file. Sometimes the source files are such that these points are at the logical breaks in the book. Chapter Master lets you edit these existing chapter stops to your heart’s content.

Most of my programming struggles over the last week, though, have been to do with trying to pull out – or create – the ‘cover art’ which iTunes can associate with any audio file.

There are two types of image which can be embedded in an AAC file which has been through, or is going to be used by, iTunes and the iPod. The first is the above-mentioned ‘cover art’, which is what shows up in the cover flow mode of iTunes, or in its grid view. The second type of image is embedded along with the audio data. These images can change at different times as the audio is played, and are what gives ‘enhanced podcasts’ some of their charm.

Chapter Master originally only handled the latter type of image, and some users found it puzzling that the ‘cover art’ didn’t turn up in Chapter Master. So most of my efforts over the last week or so have been to alter the program so that it can manipulate either kind of image. In the case of cover art, this meant that I had to parse and unpack the iTunes meta data, which includes the cover art images.

The AAC file structure is based on the structure Apple originally developed for QuickTime, and consists of ‘atoms’ which can be nested (that is, atoms can contain other atoms). Each atom starts with a data length (a 32-bit unsigned integer) and an atom type indicator which can be read as a 4-character ASCII string.

The iTunes meta data is stored in a ‘user data atom’, type-string ‘udta’. Now this type of atom can contain anything the encoder software desires – which means one has to be careful to check that it contains data structured in the iTunes manner. Apple structure their udta atom with yet another atom hierarchy containing the meta data and any images.

I managed to decode all this without too much trouble if the meta data atom already existed. But I also wanted to allow people to add a new cover art image in Chapter Master, and fill in any meta data, if it didn’t already exist. This meant that I had to create my own ‘fake’ meta data atom and trick iTunes into recognizing it. This proved considerably trickier than I had anticipated, but I think I have managed it. It took a lot of careful working with a hexadecimal editor (I use the excellent Hex Workshop), lots of trial and error, and lots of thinking. Anyway, it looks like I got there.

One trick I will pass on to others is that it seems that iTunes expects the udta meta data atom to be the LAST atom inside the ‘moov’ (or ‘movie’) atom. If it’s not in that location, it’s ignored.

Other features I’ve added include the ability to add titles to an image, the ability to do sophisticated search/replace on chapter text, and multi-selection ability in the chapter list.

I’ll be releasing the new version of Chapter Master (1.2.0) as a beta for a while, as so much has changed.

Here one can neither stand nor lie nor sit…
– T.S.Elliot, The Wasteland

Mediaeval dungeons often had a cell called the “little-ease”, devilishly designed so that the prisoner was unable to find any comfortable position in which to rest.

I feel like I’m in such a place now. I’ve “done my back” – the penalty of years of sitting badly while I program, I fear. I’ve damaged something in my lower back and for the last four weeks I’ve been in some pain and often find myself in a situation where I can “neither stand nor lie nor sit”. Which makes it hard to write software or to blog, or … well, do most things. It’s a nuisance.

Anyway, my physiotherapist and doctor are both working on the problem for me. The key, it seems, is to keep moving at all costs. And regularly do targeted exercises to build up both abdominal and back muscles.

The moral of this lesson to younger programmers (I’m nearly 58) is – be very careful how you sit at the computer.

If you slouch and don’t pay attention to how straight your back is, you may not suffer now, but in years to come you may well be as broken as I am. Get a good chair and sit properly. When your teachers told you to “sit up straight” they had your best interests at heart!

Assume the worst, think of all the possible ways things could go wrong. Be paranoid. The question is not whether you are paranoid, but whether you are paranoid enough.

These days, everyone has valuable data, and it’s taking up more and more room. Documents, spreadsheets and databases; emails, photographs and even video. Game players have many save files capturing their progress in various games. In my case and that of most programmers I also have many files and folders comprising highly valuable program source code. We’re all working hard generating digital files of one form or another, almost every day.

So, think about how you would feel if you lost that data. Bad? It could be worse than bad.

About ten years ago the young programmers in my office were having fun replaying an audio file garnered off the Internet, from some computer company’s help-line. It was a call from some guy who had been writing a book on his computer, maybe a novel. Something went wrong with the machine and he sent it in for repair. The computer company had (for whatever reason) wiped the hard disk. The young guys in my office thought it was hugely amusing to hear this guy raging in despair about the loss of all of his data, almost literally foaming at the mouth. Personally, I found it very painful to listen to. I could feel his pain.

Losing data, particularly creative work you have labored over, is tragic. This is why I am paranoid about backups.

Here are my paranoid rules:

• If there’s only one copy of something, it might as well not exist at all, you’re going to lose it. Make an immediate copy of any irreplaceable item (such as photographs of a wedding, which can’t be replaced at all).
   
• If you only have two copies of something, each copy must be kept in a different physical location. The house or office could burn down (or, as happened to my daughter and her husband, the backup drive can be stolen along with the laptop it was backing up).
   
• Two copies is not enough. Your hard drive could crash AND the backup copy could be lost or prove corrupt. I’ve had it happen.
   
• How do you know your backup files aren’t corrupt? Check them regularly.
   
• Are you backing up everything you might want? I regularly (say once very 18 months) reformat my desktop computer. That’s when I remember all the things I should have backed up but could easily forget to: fonts, passwords, email archives, application settings.
   
• What about backups of material not on your desktop computer? Like on-line blogs, forum posts, etc. A colleague of mine forgot to renew his domain name and hosting package and lost a valuable travel blog and photographs.
   
• Think about how much time you would be prepared to put in to re-create your work if it was lost. In other words, how much work could you bear to lose? A day’s worth? A week’s worth? Backup more often than that.
   
• There’s no such thing as too many copies if the data is really valuable.

So here’s my backup strategy. Personally, I don’t yet think it’s paranoid enough.

• For program source code, I use a version control system (Subversion) to save progressive versions, each time I do significant work on any programming project. The commit happens via a VPN, to a server in a different physical location to my desktop – in fact, to an office some 20 km away. This generally happens once or twice a day on a current project. As Jeff Attwood says, source control is the absolute bedrock of software engineering.
   
• I have an external network drive (a 500GB LaCie Ethernet Mini). I use Acronis to schedule weekly backups of ‘My Documents’ and source code folders, on an incremental basis (this means I can backtrack, à la Mac Time Machine, to previous versions of things).
   
• I copy the Acronis backup files from the LaCie to one of two identical external USB drives (Western Digital MyBooks). Only one of these is kept at my house. On an approximately weekly basis, I take the current MyBook drive with me to another physical location, and swap it with the identical drive already there. Even in my house, the MyBook drive doesn’t live on my desk, but somewhere else in the house where a thief won’t find it.
   
• When I’m feeling particularly vulnerable, I burn DVD-ROMs of really critical files and keep them somewhere else.

You might quite reasonably ask why I don’t use ‘cloud storage’ to backup files to a location on the Internet, like Amazon’s S3. The answer is that in Australia our broadband upload speeds are still so feeble that it would take weeks to backup any significant volume of data this way.

So am I paranoid enough? I guess I’ll only find out when things go wrong.

“Even paranoids have enemies”
— Golda Meir to Henry Kissinger

Progress isn’t made by early risers. It’s made by lazy men trying to find easier ways to do something.

-Robert Heinlein

This came up today on the ‘Quote of the Day’ box on my iGoogle page.

It strikes me as being very true, and very applicable to many software developers. It’s not that we don’t work very hard; but it’s that that we’re so lazy that we will often work very hard to save ourselves the effort of having to work on stuff we hate doing.

Someone, like me, who is a compulsive programmer, would much rather spend an hour writing code to automate a boring task than spend half an hour actually doing the task manually. Even if we’re only ever going to have to perform the task once!

There’s some great stuff about compulsive programmers in Computer Power and Human Reason by Joseph Weizenbaum, written way back in 1976, but full of very useful insights into today’s world even so.

Note that you can use settings for both simple values like bool and string, and for more complex values like colors.

These settings get persisted in a file called [your program name].exe.config.

And you can refer to them in code like this:

    private void GetBackgroundColor()
   {
         this.BackColor = Properties.Settings.Default.BackgroundColor;
    }
 
    private void SetBackgroundColor(Color backcolor)
    {
          Properties.Settings.Default.BackgroundColor = backcolor;
          Properties.Settings.Default.Save();
    }

Well, that’s all very well, simple, and very useful. But it gets messy if you want to set up a lot of options and particularly if you need options using your own enums, in various categories or for different states or objects in your application – the Settings dialog is just a very simple, line by line set of options with no structure.

My own preference* is to create one or more Options classes, and to use the nifty Xml Serialization stuff which I talked about previously on this blog to load and save the class.

Here’s a considerably cut-down version of my Options class from my software Chapter Master:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

public class Options
{
	public enum ImageGrabOptions
	{
	    None,
	    CropFromTop,
	    CropFromLeft,
	    CropFromRight,
	    CropFromBottom,
	    CropFromCentre,
	    Pad
	}
 
	public enum SaveOptions
	{
	    None,
	    RenameOriginal,
	    PromptForNew
	}
 
	[System.Xml.Serialization.XmlElement()]
	public ImageGrabOptions ImageGrab = ImageGrabOptions.CropFromTop;
 
	[System.Xml.Serialization.XmlElement()]
	public SaveOptions SaveOption = SaveOptions.PromptForNew;
 
	[System.Xml.Serialization.XmlElement()]
	public int PadColorAsInt = Color.White.ToArgb();
 
	[System.Xml.Serialization.XmlIgnore]
	public Color PadColor
	{
	    get {
	        return Color.FromArgb(PadColorAsInt);
	        }
 
	    set {
	        PadColorAsInt = value.ToArgb();
	    }
	}
 
	public Options()
	{
	}
 
	public bool Save(string filename)
	{
	    return Seralize.ToXmlFile(filename, this);
	}
 
	public static Options Load(string filename)
	{
	    return opts = (Options) Seralize.FromXmlFile(filename, typeof(Options));
	}
}

Where Serialize is a class containing just the Xml serialization routines I wrote based on this Code Project article.

Note the way that the Color is serialized in lines 27-40, the same sort of workaround as is needed for TimeSpan values.

I like this approach because among other things, it allows different sets of preferences to saved and loaded as required.

Accessing these option values is very simple (this code is a fudge written just to demonstrate my general approach):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

private readonly string MySettingsFolder = 
      System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
      + @"\ProgramName";
 
private OptionClass MyOptions;
 
private void GetOptions()
{
     MyOptions = Options.Load(MySettingsFolder  + @"\Default Options.xml");
}
 
//....and thus code like:
 
picCover.BackColor = MyOptions.PadColor;
if (MyOptions.ImageGrab.CropFromBottom)
{
     //........
}
 
private bool SaveSpecialOptions()
{
    return MyOptions.Save(MySettingsFolder  + @"\Special Options.xml");
}

* I’m happy to have others tell me why there are better ways. As always, I certainly don’t claim to be any kind of expert. This is just the way I like to do it. If you think it’s dumb, tell me so.

Jeff’s complaints seem to be all about the difficulty that humans (well, programmers, anyway) have in reading all those angle brackets. To me, this seems to be beside the point, since humans aren’t really supposed to be reading XML anyway – computers are. It’s just a nice side-benefit that we programmers can look at XML files with a text editor and generally get a pretty good sense of what is going on.

Anyway, what I love about serializing to XML is the way that in C# you can build up a very complex object, with nested lists of diverse objects and such, and yet just blatt it all out to a file, or send it by MSMQ, and just magically read it back and have that fully complex object back again, without any need to spend time coding to parse it all in or out.

For example, in one of the applications I built for Kaleidio, we are simulating electronic transactions between companies. So I have a class called ‘Company’, name, address, etc, as you would expect it; but among other complexities, the company class also includes an array of storage locations. Each storage location has a list of products being stored, each with its own information about price, unit size, bar-code, etc. Obviously, these are ‘toy’ companies with far less complexity than the real thing; but nevertheless, they are complex objects.

With serialization, I can just set up and save an entire company object to disk, or pick it up and despatch it to another computer via MSMQ (or SOAP, or whatever).

There’s a great article with some really good utility routines for reading and writing serialized XML here at Code Project. If you base your code on these routines, you can write code like this:

	var myCompany = new Company();
 
	//fill in company details, add storage locations, 
	//fill locations with products, etc.
 
	ToXMLfile(@"C:\temp\company.xml", myCompany);
 
	//then, later:
 
	var loadedCompany = (Company)FromXMLfile(@"C:\temp\company.xml", 
						typeof(Company);
 
	//now work with the company again.

To make this all work well you generally have to assign attributes to members of your classes to give the serializer hints as to how you want the XML to work.

	public class Company
	{
		[System.Xml.Serialization.XmlAttribute()]
		public string Name = "MyBusiness";
 
		[System.Xml.Serialization.XmlElement()]
		public string Address= "41 Smith Street, Collingwood, Vic 3066";
	//....

This creates XML like:

	<Company Name="MyBusiness">
	<Address>41 Smith Street, Collingwood, Vic 3066</Address>
		....
	</Company>

 
I have used this a lot in the last 6 or 7 years, but I have to admit that it’s a feature of Visual Studio that I have basically taken for granted, and only rarely had to worry about the implementation. In other words, I haven’t really researched it and thought about it in any detail, just used it at a basic level. I’m guessing that most practicing programmers use many such language features in the same way.

But it’s when what you have taken for granted suddenly causes you grief that you have to start hitting the F1 key (or, more usefully, googling) to get some answers.

For example, there are some kinds of data type which you can’t serialize directly, such as TimeSpan. So you have to use a workaround like this:

        [System.Xml.Serialization.XmlElement]
        public long DurationTicks;
 
        [System.Xml.Serialization.XmlIgnore]
        public TimeSpan Duration
        {
            get { return new TimeSpan(DurationTicks); }
            set
            {
                DurationTicks = value.Ticks;
            }
        }

Note that one of the disadvantages of serialization is that any value to be serialized must be marked as public, so DurationTicks above is visible as a member of the class to which it belongs, even though you don’t really want it messed with directly.

Where I have gotten myself into difficulties in the past is where you want a class to be able to have a member which may be of various different kinds of object. They are different, but they do all inherit from a base class.

You can use a construct like this, which uses an additional class member to indicate to the serializer the type of object being included:

        [System.Xml.Serialization.XmlChoiceIdentifier("ControlType")]
        [System.Xml.Serialization.XmlElement(Type = typeof(VideoControl))]
        [System.Xml.Serialization.XmlElement(Type = typeof(ImageControl))]
        [System.Xml.Serialization.XmlElement(Type = typeof(FlashControl))]
 
        public Control ControlObj = null;
 
        /// <summary>
        /// Identifies the type of control being sent.
        /// </summary>
        [System.Xml.Serialization.XmlIgnore]
        public ControlTypes ControlType = ControlTypes.None;

Note the XmlIgnore tag, which tells the serializer not to explictly include this property in the XML.

But I struggled for a while to figure out what to do when the class I was trying to serialize had a member which was a list of such variable objects.

For example in one of my shareware projects, I have an object which includes such a list (a List<FileRecord>, to be specific). Mostly this list contains plain FileRecord objects, but I also have a class called CDTrackRecord which inherits from FileRecord. For quite a while I couldn’t figure out how to correctly serialize a class with a list which included one or more such inherited objects.

I’m still not sure if this is the best solution, but I discovered that you can use an XmlInclude attribute on the base class of list members, like this, to show it also includes the possibility of the inherited object:

        [System.Xml.Serialization.XmlInclude(typeof(CDTrackRecord))]
        public class FileRecord
        {
                //class members
        }

The class including a List<FileRecord> now serializes nicely.

Disclaimer: I don’t claim to be any kind of programming expert, just a dumb old programmer with a passion for coding. Bear this in mind if you comment!