Added configuration module to hold persistent configuration data and per-board settings.

Also refactored the GUI module for no other reason than I felt like it.
Snapshot of the configuration module, just sketching.

Not sure how to structure this easily.

Thinking of using glib's KeyFile for the backing store, but not sure about runtime access.
Sketched some GKeyFile-loading code.
Went 100% GKeyFile, implemented loading and saving.

This just feels easier than copying to/from some internal representation.

Configuration queries (pretty much by definition) will never be performance-critical, so why worry.
Formalized default settings based on templates.

Let's try something weird: using GKeyFile's comments for building labels later on.

Hint: it probably won't work, since you can't figure out the type of a GKeyFile key's value. D'oh!
Renamed some internal functions.

It just feels better, now.
More public API, started on implementation.

Still not happy with the internal setting/group/template organization.
Made the settings group expressable through template data, too.

More data-driven code = better.
Minimalistic improvement in get_filename().

A little better is at least ... better.
Implemented templated-backed copy operation.

Might work.
Snapshot: adding Preferences window based on the new config module.

Something's horribly wrong though, when building the GUI for the configuration it hangs and dies horribly.

At the moment I don't understand what's going wrong at all, seems mutex-related inside GObject but I don't see what's unusual about this code at all. :|
Commented out the dangerous GUI-building code.

This at least un-breaks the program as a whole, and let's you experience the thrill of seeing an empty dialog pop up when the Preferences toolbar button is clicked.

Yay, me.
Fixed GUI-building mystery monster magic, that wasn't so hard.

No wonder it behaved so much like an infinite loop, huh? :)
More work on GUI building, connecting signals to update config and so on.

This time, I went with the true and tested signals-based approach, changing the "backing store" (the Config's GKeyFile) when a widget changes.

The alternative is to let the widgets hold the state and then read it all out when the settings have been accepted, but that requires iterating the widgets which felt annoying.
Fixed crash when clicking a config check button.

Ah, the joys of using non-checked strings for binding to data. :)

Still doesn't work for whatever reason, but at least it doesn't segfault just as quickly now.
Implemented gui_set_config() so a newly edited configuration is actually stored.

Still need to decide when to write the new config to disk, to really make it persistent.

Probably best at program exit, for a small tool such as this.
Save configuration on exit.

At the moment, there's no "dirty-flagging" so the config is always saved, which is a bit redundant but on the other hand very (very) fast.

This is the first commit with an actual persistent config system in place, neat!
Implemented the "autodetect on startup" option, so it really does what it says.

Not at all happy with the internals of config_get_autodetect_on_startup(), more magic strings. Yuck.
Refactored internal meta data to be less string-dependent in actual use.

Still not 100% happy, but at least now code referencing templates settings do so by a compiler-verifiable symbol look-up rather than a string.
Renamed the "autoconnect all on first autodetect" option to just "... *first* ...", since that's easier to implement.

Also, implemented the actual logic so the option fully works now. Neat!