Make ApiFactory non-static

Add config manager and related classes
Move database to config directory
Change title to "No character selected" from "initialising"

src/com/dmdirc/util/ConfigFile.java

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Reads and writes a standard DMDirc config file.
+ *
+ * @author chris
+ */
+public class ConfigFile extends TextFile {
+
+    /** A list of domains in this config file. */
+    private final List<String> domains = new ArrayList<String>();
+
+    /** The values associated with each flat domain. */
+    private final MapList<String, String> flatdomains = new MapList<String, String>();
+
+    /** The key/value sets associated with each key domain. */
+    private final Map<String, Map<String, String>> keydomains
+            = new HashMap<String, Map<String, String>>();
+    
+    /** Whether or not we should automatically create domains. */
+    private boolean automake;
+
+    /**
+     * Creates a new read-only Config File from the specified input stream.
+     * 
+     * @param is The input stream to read
+     */
+    public ConfigFile(final InputStream is) {
+        super(is);
+    }
+
+    /**
+     * Creates a new Config File from the specified file.
+     * 
+     * @param file The file to read/write
+     */
+    public ConfigFile(final File file) {
+        super(file);
+    }
+
+    /**
+     * Creates a new Config File from the specified file.
+     * 
+     * @param filename The name of the file to read/write
+     */
+    public ConfigFile(final String filename) {
+        super(filename);
+    }
+
+
+    /**
+     * Sets the "automake" value of this config file. If automake is set to
+     * true, any calls to getKeyDomain will automatically create the domain
+     * if it did not previously exist.
+     * 
+     * @param automake The new value of the automake setting of this file
+     */
+    public void setAutomake(final boolean automake) {
+        this.automake = automake;
+    }
+
+    /**
+     * Reads the data from the file.
+     * 
+     * @throws FileNotFoundException if the file is not found
+     * @throws IOException if an i/o exception occured when reading
+     * @throws InvalidConfigFileException if the config file isn't valid
+     */
+    public void read() throws FileNotFoundException, IOException, InvalidConfigFileException {
+        String domain = null;
+        boolean keydomain = false;
+        int offset;
+        
+        keydomains.clear();
+        flatdomains.clear();
+        domains.clear();
+        
+        readLines();
+
+        for (String line : getLines()) {
+            String tline = line;
+            
+            while (!tline.isEmpty() && (tline.charAt(0) == '\t' || 
+                    tline.charAt(0) == ' ')) {
+                tline = tline.substring(1);
+            }
+
+            if (tline.indexOf('#') == 0 || tline.isEmpty()) {
+                continue;
+            } else if (
+                    (tline.endsWith(":") && !tline.endsWith("\\:"))
+                    && findEquals(tline) == -1) {
+                domain = unescape(tline.substring(0, tline.length() - 1));
+
+                domains.add(domain);
+
+                keydomain = keydomains.containsKey(domain)
+                        || flatdomains.containsValue("keysections", domain);
+                
+                if (keydomain && !keydomains.containsKey(domain)) {
+                    keydomains.put(domain, new HashMap<String, String>());
+                } else if (!keydomain && !flatdomains.containsKey(domain)) {
+                    flatdomains.add(domain);
+                }
+            } else if (domain != null && keydomain
+                    && (offset = findEquals(tline)) != -1) {
+                final String key = unescape(tline.substring(0, offset));
+                final String value = unescape(tline.substring(offset + 1));
+
+                keydomains.get(domain).put(key, value);
+            } else if (domain != null && !keydomain) {
+                flatdomains.add(domain, unescape(tline));
+            } else {
+                throw new InvalidConfigFileException("Unknown or unexpected" +
+                        " line encountered: " + tline);
+            }
+        }
+    }
+
+    /**
+     * Writes the contents of this ConfigFile to disk.
+     * 
+     * @throws IOException if the write operation fails
+     */
+    public void write() throws IOException {
+        if (!isWritable()) {
+            throw new UnsupportedOperationException("Cannot write to a file "
+                    + "that isn't writable");
+        }
+        
+        final List<String> lines = new ArrayList<String>();
+
+        lines.add("# This is a DMDirc configuration file.");
+        lines.add("# Written on: " + new GregorianCalendar().getTime().toString());
+
+        writeMeta(lines);
+
+        for (String domain : domains) {
+            if ("keysections".equals(domain)) {
+                continue;
+            }
+
+            lines.add("");
+
+            lines.add(escape(domain) + ':');
+
+            if (flatdomains.containsKey(domain)) {
+                for (String entry : flatdomains.get(domain)) {
+                    lines.add("  " + escape(entry));
+                }
+            } else {
+                for (Map.Entry<String, String> entry : keydomains.get(domain).entrySet()) {
+                    lines.add("  " + escape(entry.getKey()) + "="
+                            + escape(entry.getValue()));
+                }
+            }
+        }
+
+        writeLines(lines);
+    }
+    
+    /**
+     * Appends the meta-data (keysections) to the specified list of lines.
+     * 
+     * @param lines The set of lines to be appended to
+     */
+    private void writeMeta(final List<String> lines) {
+        lines.add("");
+        lines.add("# This section indicates which sections below take key/value");
+        lines.add("# pairs, rather than a simple list. It should be placed above");
+        lines.add("# any sections that take key/values.");
+        lines.add("keysections:");
+
+        for (String domain : domains) {
+            if ("keysections".equals(domain)) {
+                continue;
+            } else if (keydomains.containsKey(domain)) {
+                lines.add("  " + domain);
+            }
+        }
+    }
+    
+    /**
+     * Retrieves all the key domains for this config file.
+     * 
+     * @return This config file's key domains
+     */
+    public Map<String, Map<String, String>> getKeyDomains() {
+        return keydomains;
+    }
+    
+    /**
+     * Retrieves the key/values of the specified key domain.
+     * 
+     * @param domain The domain to be retrieved
+     * @return A map of keys to values in the specified domain
+     */
+    public Map<String, String> getKeyDomain(final String domain) {
+        if (automake && !isKeyDomain(domain)) {
+            domains.add(domain);
+            keydomains.put(domain, new HashMap<String, String>());
+        }
+        
+        return keydomains.get(domain);
+    }
+    
+    /**
+     * Retrieves the content of the specified flat domain.
+     * 
+     * @param domain The domain to be retrieved
+     * @return A list of lines in the specified domain
+     */
+    public List<String> getFlatDomain(final String domain) {
+        return flatdomains.get(domain);
+    }
+    
+    /**
+     * Determines if this config file has the specified domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known, false otherwise
+     */
+    public boolean hasDomain(final String domain) {
+        return keydomains.containsKey(domain) || flatdomains.containsKey(domain);
+    }
+
+    /**
+     * Determines if this config file has the specified domain, and the domain
+     * is a key domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known and keyed, false otherwise
+     */
+    public boolean isKeyDomain(final String domain) {
+        return keydomains.containsKey(domain);
+    }
+
+    /**
+     * Determines if this config file has the specified domain, and the domain
+     * is a flat domain.
+     * 
+     * @param domain The domain to check for
+     * @return True if the domain is known and flat, false otherwise
+     */
+    public boolean isFlatDomain(final String domain) {
+        return flatdomains.containsKey(domain);
+    }
+    
+    /**
+     * Adds a new flat domain to this config file.
+     * 
+     * @param name The name of the domain to be added
+     * @param data The content of the domain
+     */
+    public void addDomain(final String name, final List<String> data) {
+        domains.add(name);
+        flatdomains.add(name, data);
+    }
+
+    /**
+     * Adds a new key domain to this config file.
+     * 
+     * @param name The name of the domain to be added
+     * @param data The content of the domain
+     */    
+    public void addDomain(final String name, final Map<String, String> data) {
+        domains.add(name);
+        keydomains.put(name, data);
+    }
+    
+    /**
+     * Unescapes any escaped characters in the specified input string.
+     * 
+     * @param input The string to unescape
+     * @return The string with all escape chars (\) resolved
+     */
+    protected static String unescape(final String input) {
+        boolean escaped = false;
+        final StringBuilder temp = new StringBuilder();
+
+        for (int i = 0; i < input.length(); i++) {
+            final char ch = input.charAt(i);
+
+            if (escaped) {
+                if (ch == 'n') {
+                    temp.append('\n');
+                } else if (ch == 'r') {
+                    temp.append('\r');
+                } else {
+                    temp.append(ch);
+                }
+                
+                escaped = false;
+            } else if (ch == '\\') {
+                escaped = true;
+            } else {
+                temp.append(ch);
+            }
+        }
+        
+        return temp.toString();
+    }
+    
+    /**
+     * Escapes the specified input string by prefixing all occurances of
+     * \, \n, \r, =, # and : with backslashes.
+     * 
+     * @param input The string to be escaped
+     * @return A backslash-armoured version of the string
+     */
+    protected static String escape(final String input) {
+        return input.replaceAll("\\\\", "\\\\\\\\").replaceAll("\n", "\\\\n")
+                .replaceAll("\r", "\\\\r").replaceAll("=", "\\\\=")
+                .replaceAll(":", "\\\\:").replaceAll("#", "\\\\#");
+    }
+    
+    /**
+     * Finds the first non-escaped instance of '=' in the specified string.
+     * 
+     * @param input The string to be searched
+     * @return The offset of the first non-escaped instance of '=', or -1.
+     */
+    protected static int findEquals(final String input) {
+        boolean escaped = false;
+        
+        for (int i = 0; i < input.length(); i++) {
+            if (escaped) {
+                escaped = false;
+            } else if (input.charAt(i) == '\\') {
+                escaped = true;
+            } else if (input.charAt(i) == '=') {
+                return i;
+            }
+        }
+        
+        return -1;
+    }
+}

src/com/dmdirc/util/InvalidConfigFileException.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+/**
+ * Thrown to indicate that a config file is invalid.
+ * @author chris
+ */
+public class InvalidConfigFileException extends Exception {
+    
+    /**
+     * A version number for this class. It should be changed whenever the class
+     * structure is changed (or anything else that would prevent serialized
+     * objects being unserialized with the new class).
+     */    
+    private static final long serialVersionUID = 1;
+
+    /**
+     * Creates a new InvalidConfigFileException.
+     * 
+     * @param string A description of the exception that occured.
+     */
+    public InvalidConfigFileException(String string) {
+        super(string);
+    }
+
+}

src/com/dmdirc/util/MapList.java

@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Wraps a Map<S, List<T>> with various convenience methods for
+ * accessing the data. Implements a Map-like interface for easier transition.
+ * 
+ * @param <S> the type of keys maintained by this map
+ * @param <T> the type of mapped values
+ * @author chris
+ */
+public class MapList<S,T> {
+    
+    /** Our internal map. */
+    protected final Map<S, List<T>> map;
+
+    /**
+     * Creates a new, empty MapList.
+     */
+    public MapList() {
+        map = new HashMap<S, List<T>>();
+    }
+
+    /**
+     * Creates a new MapList with the values from the specified list.
+     * 
+     * @param list The MapList whose values should be used
+     */
+    public MapList(final MapList<S,T> list) {
+        map = list.getMap();
+    }
+
+    /**
+     * Determines if this MapList is empty. An empty MapList is one that either
+     * contains no keys, or contains only keys which have no associated values.
+     * 
+     * @return True if this MapList is empty, false otherwise
+     */
+    public boolean isEmpty() {
+        for (List<T> list : map.values()) {
+            if (!list.isEmpty()) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+
+    /**
+     * Determines if this MapList contains the specified key.
+     * 
+     * @param key The key to look for
+     * @return True if this MapList contains the specified key, false otherwise
+     */
+    public boolean containsKey(final S key) {
+        return map.containsKey(key);
+    }
+
+    /**
+     * Determines if this MapList contains the specified value as a child of
+     * the specified key.
+     * 
+     * @param key The key to search under
+     * @param value The value to look for
+     * @return True if this MapList contains the specified key/value pair, 
+     * false otherwise
+     */
+    public boolean containsValue(final S key, final T value) {
+        return map.containsKey(key) && map.get(key).contains(value);
+    }
+
+    /**
+     * Retrieves the list of values associated with the specified key.
+     * 
+     * @param key The key whose values are being retrieved
+     * @return The values belonging to the specified key
+     */
+    public List<T> get(final S key) {
+        return map.get(key);
+    }
+    
+    /**
+     * Retrieves the value at the specified offset of the specified key.
+     * 
+     * @param key The key whose values are being retrieved
+     * @param index The index of the value to retrieve
+     * @return The specified value of the key
+     */    
+    public T get(final S key, final int index) {
+        return map.get(key).get(index);
+    }    
+    
+    /**
+     * Retrieves the list of values associated with the specified key, creating
+     * the key if neccessary.
+     * 
+     * @param key The key to retrieve
+     * @return A list of the specified key's values
+     */
+    public List<T> safeGet(final S key) {
+        if (!map.containsKey(key)) {
+            map.put(key, new ArrayList<T>());
+        }
+        
+        return map.get(key);
+    }
+    
+    /**
+     * Adds the specified key to the MapList.
+     * 
+     * @param key The key to be added
+     */
+    public void add(final S key) {
+        safeGet(key);
+    }    
+
+    /**
+     * Adds the specified value as a child of the specified key. If the key
+     * didn't previous exist, it is created.
+     * 
+     * @param key The key to which the value is being added
+     * @param value The value to be added
+     */
+    public void add(final S key, final T value) {
+        safeGet(key).add(value);
+    }
+
+    /**
+     * Adds the specified set of values to the specified key. If the key
+     * didn't previous exist, it is created.
+     * 
+     * @param key The key to which the value is being added
+     * @param values The values to be added
+     */    
+    public void add(final S key, final Collection<T> values) {
+        safeGet(key).addAll(values);
+    }    
+
+    /**
+     * Removes the specified key and all of its values.
+     * 
+     * @param key The key to remove
+     */    
+    public void remove(final S key) {
+        map.remove(key);
+    }
+    
+    /**
+     * Removes the specified value from all keys.
+     * 
+     * @param value The value to remove
+     */
+    public void removeFromAll(final T value) {
+        for (List<T> list : map.values()) {
+            list.remove(value);
+        }
+    }
+
+    /**
+     * Removes the specified value from the specified key.
+     * 
+     * @param key The key whose value is being removed
+     * @param value The value to be removed
+     */
+    public void remove(final S key, final T value) {
+        if (map.containsKey(key)) {
+            map.get(key).remove(value);
+        }
+    }    
+
+    /**
+     * Entirely clears this MapList.
+     */
+    public void clear() {
+        map.clear();
+    }
+    
+    /**
+     * Clears all values of the specified key.
+     * 
+     * @param key The key to be cleared
+     */
+    public void clear(final S key) {
+        safeGet(key).clear();
+    }    
+
+    /**
+     * Returns the set of all keys belonging to this MapList.
+     * 
+     * @return This MapList's keyset
+     */
+    public Set<S> keySet() {
+        return map.keySet();
+    }
+
+    /**
+     * Returns a collection of all values belonging to the specified key.
+     * 
+     * @param key The key whose values are being sought
+     * @return A collection of values belonging to the key
+     */
+    public Collection<T> values(final S key) {
+        return map.get(key);
+    }
+    
+    /**
+     * Retrieves the entry set for this MapList.
+     * 
+     * @return This MapList's entry set
+     */
+    public Set<Map.Entry<S, List<T>>> entrySet() {
+        return map.entrySet();
+    }
+    
+    /**
+     * Retrieves the map behind this maplist.
+     * 
+     * @return This MapList's map.
+     */
+    public Map<S, List<T>> getMap() {
+        return new HashMap<S, List<T>>(map);
+    }
+
+}

src/com/dmdirc/util/TextFile.java

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2006-2009 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.util;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Allows reading and writing to a plain text file via a list of lines.
+ * 
+ * @author chris
+ */
+public class TextFile {
+    
+    /** The file we're dealing with. */
+    private File file;
+    
+    /** The input stream we're dealing with. */
+    private InputStream is;
+    
+    /** The lines we've read from the file. */
+    private List<String> lines;
+    
+    /**
+     * Creates a new instance of TextFile for the specified file.
+     * 
+     * @param filename The file to be read/written
+     */
+    public TextFile(final String filename) {
+        file = new File(filename);
+    }
+
+    /**
+     * Creates a new instance of TextFile for the specified File.
+     * 
+     * @param file The file to read
+     */
+    public TextFile(final File file) {
+        this.file = file;
+    }
+    
+    /**
+     * Creates a new instance of TextFile for an input stream.
+     * 
+     * @param is The input stream to read from
+     */
+    public TextFile(final InputStream is) {
+        this.is = is;
+    }
+    
+    /**
+     * Retrieves the contents of the file as a list of lines. If getLines() or
+     * readLines() has previously been called, a cached version is returned.
+     * 
+     * @return A list of lines in the file
+     * @throws IOException if an I/O exception occurs
+     */
+    public List<String> getLines() throws IOException {
+        if (lines == null) {
+            readLines();
+        }
+        
+        return lines;
+    }
+    
+    /**
+     * Reads the contents of the file into this TextFile's line cache.
+     * 
+     * @throws IOException If an I/O exception occurs
+     */
+    public void readLines() throws IOException {
+        final BufferedReader reader = new BufferedReader(
+                file == null ? new InputStreamReader(is) : new FileReader(file));
+        lines = new ArrayList<String>();
+        
+        String line;
+        
+        while ((line = reader.readLine()) != null) {
+            lines.add(line);
+        }
+        
+        reader.close();
+    }
+    
+    /**
+     * Determines if this file is writable or not.
+     * 
+     * @return True if the file is writable, false otherwise
+     */
+    public boolean isWritable() {
+        return file != null;
+    }
+    
+    /**
+     * Writes the specified list of lines to the file.
+     * 
+     * @param lines The lines to be written
+     * @throws IOException if an I/O exception occurs
+     */
+    public void writeLines(final List<String> lines) throws IOException {
+        if (file == null) {
+            throw new UnsupportedOperationException("Cannot write to TextFile "
+                    + "opened with an InputStream");
+        }
+        
+        final BufferedWriter writer = new BufferedWriter(new FileWriter(file));
+        
+        for (String line : lines) {
+            writer.write(line);
+            writer.newLine();
+        }
+        
+        writer.close();
+    }
+
+    /**
+     * Retrieves the File for this TextFile, if there is one.
+     * 
+     * @return This TextFile's file, or null
+     */
+    public File getFile() {
+        return file;
+    }
+    
+    /**
+     * Deletes the file associated with this textfile, if there is one.
+     */
+    public void delete() {
+        if (file == null) {
+            throw new UnsupportedOperationException("Cannot delete TextFile "
+                    + "opened with an InputStream");
+        }
+        
+        file.delete();
+    }
+
+}

src/uk/co/md87/evetool/ApiFactory.java

@@ -34,22 +34,31 @@ import uk.co.md87.evetool.api.EveApi;
  * Factory class to create instances of the {@link EveApi} class. Uses an
  * embedded Derby database server by default.
  *
- * TODO: Make non-static
  * @author chris
  */
 public class ApiFactory {
 
     /** The URL of the database. */
-    private static String dbURL = "jdbc:derby:db/eveApi;create=true";
+    private final String dbURL;
 
+    /** The cached connection. */
     private static Connection dbConn;
 
+    /**
+     * Creates a new API Factory which will use the specified config manager.
+     *
+     * @param manager The config manager to use
+     */
+    public ApiFactory(final ConfigManager manager) {
+        dbURL = "jdbc:derby:" + manager.getConfigDir() + "/db;create=true";
+    }
+
     /**
      * Creates a database connection for use by the API.
      *
      * @return A Database Connection
      */
-    public static synchronized Connection getConnection() {
+    public synchronized Connection getConnection() {
         try {
             return dbConn == null ? dbConn = DriverManager.getConnection(dbURL) : dbConn;
         } catch (SQLException ex) {
@@ -64,7 +73,7 @@ public class ApiFactory {
      *
      * @return An instance of the EVE API.
      */
-    public static EveApi getApi() {
+    public EveApi getApi() {
         return new EveApi(getConnection());
     }
 

src/uk/co/md87/evetool/ConfigManager.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2009 Chris Smith
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package uk.co.md87.evetool;
+
+import com.dmdirc.util.ConfigFile;
+import com.dmdirc.util.InvalidConfigFileException;
+import java.io.File;
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * TODO: Document ConfigManager
+ * @author chris
+ */
+public class ConfigManager {
+
+    /** Logger to use for this class. */
+    private static final Logger LOGGER = Logger.getLogger(ConfigManager.class.getName());
+
+    private final ConfigFile configFile;
+ 
+    public ConfigManager() {
+        final File dir = new File(getConfigDir());
+
+        if (!dir.exists()) {
+            dir.mkdirs();
+        }
+
+        configFile = new ConfigFile(new File(dir, "evetool.config"));
+        configFile.setAutomake(true);
+        
+        try {
+            configFile.read();
+        } catch (IOException ex) {
+            LOGGER.log(Level.WARNING, "Error reading config file", ex);
+        } catch (InvalidConfigFileException ex) {
+            LOGGER.log(Level.WARNING, "Error parsing config file", ex);
+        }
+
+        Runtime.getRuntime().addShutdownHook(new Thread(new ShutdownHook()));
+    }
+
+    public String getGeneralSetting(final String key) {
+        return configFile.getKeyDomain("general").get(key);
+    }
+
+    public void save() {
+        try {
+            configFile.write();
+        } catch (IOException ex) {
+            LOGGER.log(Level.SEVERE, "Error writing config file", ex);
+        }
+    }
+
+    /**
+     * Returns the application's config directory.
+     *
+     * @return configuration directory
+     */
+    public String getConfigDir() {
+        final String fs = System.getProperty("file.separator");
+        final String osName = System.getProperty("os.name");
+        if (osName.startsWith("Mac OS")) {
+            return System.getProperty("user.home") + fs + "Library" + fs
+                    + "Preferences" + fs + "evetool" + fs;
+        } else if (osName.startsWith("Windows")) {
+            if (System.getenv("APPDATA") == null) {
+                return System.getProperty("user.home") + fs + "evetool" + fs;
+            } else {
+                return System.getenv("APPDATA") + fs + "evetool" + fs;
+            }
+        } else {
+            return System.getProperty("user.home") + fs + ".evetool" + fs;
+        }
+    }
+
+    private class ShutdownHook implements Runnable {
+
+        /** {@inheritDoc} */
+        @Override
+        public void run() {
+            save();
+        }
+
+    }
+}

src/uk/co/md87/evetool/Main.java

@@ -54,12 +54,16 @@ public class Main {
      */
     public static void main(final String[] args) {
         initLogging();
+
+        final ConfigManager config = new ConfigManager();
+        final ApiFactory factory = new ApiFactory(config);
+
         readVersion();
-        initTables();
+        initTables(factory);
 
-        final AccountManager manager = new AccountManager(ApiFactory.getConnection());
+        final AccountManager manager = new AccountManager(factory.getConnection());
 
-        new MainWindow(manager, new ApiFactory()).setVisible(true);
+        new MainWindow(manager, new ApiFactory(config)).setVisible(true);
     }
 
     /**
@@ -75,9 +79,11 @@ public class Main {
 
     /**
      * Initialises tables used by the program.
+     *
+     * @param factory The ApiFactory to use for the database connection
      */
-    protected static void initTables() {
-        new TableCreator(ApiFactory.getConnection(), "/uk/co/md87/evetool/sql/",
+    protected static void initTables(final ApiFactory factory) {
+        new TableCreator(factory.getConnection(), "/uk/co/md87/evetool/sql/",
                 TABLES).checkTables();
     }
 

src/uk/co/md87/evetool/ui/MainWindow.java

@@ -70,7 +70,7 @@ public class MainWindow extends JFrame {
     private final Map<String, ContentPanel.Page> pages;
 
     public MainWindow(final AccountManager manager, final ApiFactory factory) {
-        super("EVE Tool - Initialising...");
+        super("EVE Tool - No character selected");
 
         UIManager.put("swing.boldMetal", false);