diff --git a/meldapp.py b/meldapp.py
index e1770be..3d12c15 100644
--- a/meldapp.py
+++ b/meldapp.py
@@ -440,9 +440,13 @@ class MeldPreferences(prefs.Preferences):
         if self.use_custom_font:
             return self.custom_font
         else:
+            if not self._gconf:
+                return "Monospace 10"
             return self._gconf.get_string('/desktop/gnome/interface/monospace_font_name') or "Monospace 10"
 
     def get_toolbar_style(self):
+        if not self._gconf:
+            return gtk.TOOLBAR_BOTH
         style = self._gconf.get_string('/desktop/gnome/interface/toolbar_style') or "both"
         style = {"both":gtk.TOOLBAR_BOTH, "text":gtk.TOOLBAR_TEXT,
                  "icon":gtk.TOOLBAR_ICONS, "icons":gtk.TOOLBAR_ICONS,
@@ -452,6 +456,8 @@ class MeldPreferences(prefs.Preferences):
         return style
 
     def get_gnome_editor_command(self, files):
+        if not self._gconf:
+            return []
         argv = []
         editor = self._gconf.get_string('/desktop/gnome/applications/editor/exec') or "gedit"
         if self._gconf.get_bool("/desktop/gnome/applications/editor/needs_term"):
diff --git a/prefs.py b/prefs.py
index 0593fa2..d05cd1a 100644
--- a/prefs.py
+++ b/prefs.py
@@ -48,9 +48,6 @@ class Value(object):
         self.default = d
         self.current = d
 
-# maybe fall back to ConfigParser if gconf is unavailable.
-import gconf
-
 # types of values allowed
 BOOL = "bool"
 INT = "int"
@@ -61,8 +58,8 @@ FLOAT = "float"
 
 ##
 
-class Preferences(object):
-    """Persistent preferences object.
+class GConfPreferences(object):
+    """Persistent preferences object that handles preferences via gconf.
 
     Example:
     import prefs
@@ -140,3 +137,122 @@ class Preferences(object):
         for k,v in self._prefs.items():
             print k, v.type, v.current
 
+
+class ConfigParserPreferences(object):
+    """Persistent preferences object that handles preferences via ConfigParser.
+
+    This preferences implementation is a fallback for people who dislike gconf
+    or do not have gnome readily available (i.e., other platforms). As the
+    ConfigParser library is included in Python, it should be available
+    everywhere.
+
+    The biggest drawback to this preferences object is the lack of
+    change notification, which means that in order for any preference changes
+    to take effect, Meld must be restarted.
+    """
+
+    def __init__(self, rootkey, initial):
+        """Create a preferences object.
+
+        Settings are initialised with 'initial' and then overriden
+        from values in the ConfigParser database if available.
+
+        rootkey : the root gconf key where the values will be stored
+        initial : a dictionary of string to Value objects.
+        """
+
+        self.__dict__['_parser'] = ConfigParser.SafeConfigParser()
+        dirty = False
+
+        try:
+            config_file = open(self.__getrcfile__(), 'r')
+            self._parser.readfp(config_file)
+        finally:
+            config_file.close()
+
+        self.__dict__['_listeners'] = []
+        self.__dict__['_root'] = []
+        self.__dict__['_initial'] = []
+        self.__dict__["_prefs"] = initial
+
+        self.__dict__['_type_mappings'] = {
+            BOOL : self._parser.getboolean,
+            INT : self._parser.getint,
+            STRING : self._parser.get,
+            FLOAT : self._parser.getfloat
+        }
+
+        #self._gconf.add_dir(rootkey, gconf.CLIENT_PRELOAD_NONE)
+        # TODO: The only way to get this to work would be to do something like
+        # inotify on the file
+        #self._gconf.notify_add(rootkey, self._on_preference_changed)
+
+        for key, value in self._prefs.items():
+            if self._parser.has_option('DEFAULT', key):
+                value.current = self._type_mappings[value.type]('DEFAULT', key)
+
+    def __getrcfile__(self):
+
+        user_home = os.path.expanduser("~")
+        file_path = None;
+        if sys.platform == 'win32':
+            file_path = os.path.join(user_home, '_meld')
+        else:
+            file_path = os.path.join(user_home, '.meld')
+
+        # Touch the config file if it does not exist
+        if not os.path.isfile(file_path):
+            open(file_path, 'a').close()
+
+        assert file_path, "Should have a config file"
+        return file_path
+
+    def __getattr__(self, attr):
+        return self._prefs[attr].current
+
+    def get_default(self, attr):
+        return self._prefs[attr].default
+
+    def __setattr__(self, attr, val):
+        value = self._prefs[attr]
+        if value.current != val:
+            value.current = val
+            self._parser.set(None, attr, str(val))
+
+            try:
+                fp = open(self.__getrcfile__(), 'w')
+                self._parser.write(fp)
+            finally:
+                fp.close()
+
+            try:
+                for l in self._listeners:
+                    l(attr,val)
+            except StopIteration:
+                pass
+
+    def notify_add(self, callback):
+        """Register a callback to be called when a preference changes.
+
+        callback : a callable object which take two parameters, 'attr' the
+                   name of the attribute changed and 'val' the new value.
+        """
+        self._listeners.append(callback)
+
+    def dump(self):
+        """Print all preferences.
+        """
+        for k,v in self._prefs.items():
+            print k, v.type, v.current
+
+# Try to use gconf, and fall back to ConfigParser
+Preferences = None
+try:
+    import gconf
+    Preferences = GConfPreferences
+except ImportError:
+    import ConfigParser
+    import os, sys
+    Preferences = ConfigParserPreferences
+
+assert Preferences is not None, "Could not load a preference parser"
diff --git a/vc/monotone.py b/vc/monotone.py
index 937dbc9..5360216 100644
--- a/vc/monotone.py
+++ b/vc/monotone.py
@@ -34,28 +34,21 @@ class Vc(_vc.Vc):
 
     def __init__(self, location):
         self._tree_cache = None
-        location = os.path.normpath(location)
 
         # for monotone >= 0.26
-        mtn = self.find_repo_root(location, "_MTN", raiseError = False)
-        if mtn:
-            self.root = mtn
-
+        try :
+            self.root = self.find_repo_root(location, "_MTN", raiseError=True)
             self.interface_version = float(os.popen("mtn" + " automate interface_version").read())
             if self.interface_version > 6.0:
                 print "WARNING: Unsupported interface version (please report any problems to the meld mailing list)"
 
             return
-
-        # for monotone <= 0.25 (different metadata directory, different executable)
-        mt = self.find_repo_root(location, "MT", raiseError = False)
-        if mt:
-            self.root = mt
+        except ValueError:
+            # for monotone <= 0.25 (different metadata directory, different executable)
+            self.root = self.find_repo_root(location, "MT", raiseError=True)
             self.CMD = "monotone"
             return
 
-        raise ValueError
-
     def commit_command(self, message):
         return [self.CMD,"commit","-m",message]
     def diff_command(self):
