1 Moved the stuff to trunk!

2 files changed, 731 insertions, 0 deletions

diff --git a/sources/prefs/VSDefaultPrefs.java b/sources/prefs/VSDefaultPrefs.java
new file mode 100644
index 0000000..f46c82c
--- /dev/null
+++ b/sources/prefs/VSDefaultPrefs.java
@@ -0,0 +1,178 @@
+package prefs;
+
+import java.awt.Color;
+import java.awt.event.KeyEvent;
+import java.io.*;
+
+public class VSDefaultPrefs extends VSPrefs {
+    public static VSPrefs initialize() {
+        return initialize(VSPrefs.PREFERENCES_FILENAME);
+    }
+
+    public static VSPrefs initialize(String fileName) {
+        File file = new File(fileName);
+        VSPrefs prefs = null;
+
+        if (file.exists()) {
+            prefs = openFile(fileName);
+
+        } else {
+            prefs = new VSDefaultPrefs();
+            prefs.fillWithDefaults();
+        }
+
+        return prefs;
+    }
+
+    public void saveFile() {
+        super.saveFile(VSPrefs.PREFERENCES_FILENAME);
+    }
+
+    public void fillWithDefaults() {
+        super.clear();
+        fillDefaultColors();
+        fillDefaultFloats();
+        fillDefaultIntegers();
+        fillDefaultLongs();
+        fillDefaultStrings();
+        fillDefaultBooleans();
+    }
+
+    public void fillDefaultStrings() {
+        /* Internal prefs */
+        initString("lang.time.lamport", "Lamport");
+        initString("lang.message.sent", "Nachricht versendet");
+        initString("lang.logging.active", "Logging");
+        initString("lang.message", "Nachricht");
+        initString("lang.message.recv", "Nachricht erhalten");
+        initString("lang.about", "About");
+        initString("lang.about.info!", "Dieses Programm wurde von Paul Bütow im Rahmen der Diplomarbeit bei Prof. Dr.-Ing. Oßmann erstellt. Dieses Programm stellt noch keinesfalls eine fertige Version dar, da es sich noch in Entwicklung befindet und die Diplomarbeit erst mitte August abgeschlossen sein wird! Bei Fehlern bitte eine kurze Mail mitsamt Fehlerbeschreibung an paul@buetow.org schicken! Dieser Simulator wird später außerdem unter einer open source Linzenz (wahrscheinlich der GNU General Public License) freigegeben!");
+        initString("lang.cancel", "Abbrechen");
+        initString("lang.close", "Schliessen");
+        initString("lang.requesttime", "Requestzeit");
+        initString("lang.colorchooser", "Farbauswahl");
+        initString("lang.colorchooser2", "Bitte Farbe auswählen");
+        initString("lang.default", "Defaults");
+        initString("lang.remove", "Entfernen");
+        initString("lang.edit", "Editieren");
+        initString("lang.editor", "Editor");
+        initString("lang.activate", "aktivieren");
+        initString("lang.activated", "Aktiviert");
+        initString("lang.server", "Server");
+        initString("lang.client", "Client");
+        initString("lang.type", "Typ");
+        initString("lang.taskmanager", "Taskmanager");
+        initString("lang.protocol", "Protokoll");
+        initString("lang.protocol.editor", "Protokolleditor");
+        initString("lang.protocol.tasks.activation", "Client-/Serverprotokoll Aktivierung");
+        initString("lang.protocol.tasks.client", "Client Task-Manager (Clientanfragen)");
+        //initString("lang.protocol.tasks.server", "Server Task-Manager (onServerStart Schedule)");
+        initString("lang.protocol.client", "Clientseite");
+        initString("lang.protocol.server", "Serverseite");
+        initString("lang.file", "Datei");
+        initString("lang.new", "Neu");
+        initString("lang.ok", "OK");
+        initString("lang.actualize", "Aktualisieren");
+        initString("lang.takeover", "Übernehmen");
+        initString("lang.open", "Öffnen");
+        initString("lang.pause", "Pausieren");
+        initString("lang.prefs", "Einstellungen");
+        initString("lang.prefs.more", "Mehr Einstellungen");
+        initString("lang.prefs.ext", "Erweiterte Einstellungen");
+        initString("lang.prefs.info!", "Prozesseinstellungen können später für jeden Prozess einzelnd eingestellt werden.Die folgenden Werte sind lediglich die globalen Defaultwerte, die für neue Prozesse verwendet werden!");
+        initString("lang.prefs.protocol", "Protokolleinstellungen");
+        initString("lang.prefs.process", "Prozesseinstellungen");
+        initString("lang.prefs.process.ext", "Erweiterte Prozesseinstellungen");
+        initString("lang.prefs.process.info!", "Änderungen werden erst nach Betätigen des \"Übernehmen\" oder \"OK\" Knopfes übernommen!");
+        initString("lang.prefs.protocol.info!", "Änderungen werden erst nach Betätigen des \"Übernehmen\" oder \"OK\" Knopfes übernommen!");
+        initString("lang.process.clock.variance", "Uhrabweichung");
+        initString("lang.process.id", "PID");
+        initString("lang.process.new", "Neuer Prozess");
+        //initString("lang.process.prob.delay", "Verzögerungswahrscheinlichkeit");
+        //initString("lang.process.prob.outage", "Ausfallwahrscheinlichkeit");
+        initString("lang.process.time.local", "Lokale Zeit");
+        initString("lang.quit", "Beenden");
+        initString("lang.replay", "Wiederholen");
+        initString("lang.reset", "Reset");
+        initString("lang.save", "Speichern");
+        initString("lang.saveas", "Speichern unter");
+        initString("lang.process.task", "Prozess-Task");
+        initString("lang.simulation", "Simulation");
+        initString("lang.simulation.finished", "Simulation beendet");
+        initString("lang.simulation.new", "Neue Simulation");
+        initString("lang.simulation.paused", "Simulation pausiert");
+        initString("lang.simulation.resetted", "Simulation zurückgesetzt");
+        initString("lang.simulation.started", "Simulation gestartet");
+        initString("lang.start", "Starten");
+        initString("lang.stop", "Stoppen");
+        initString("name", "Verteilte Systeme v0.1");
+    }
+
+    public void fillDefaultIntegers() {
+        /* Simulation prefs */
+        initInteger("sim.process.num", 3, "Anzahl der Prozesse", 1, 6);
+        initIntegerUnit("sim.message.prob.outage", 5, "W'keit, dass eine Nachricht verloren geht", 0, 100, "%");
+        initIntegerUnit("sim.process.prob.crash", 5, "W'keit, dass der Prozess ausfällt", 0, 100, "%");
+        initIntegerUnit("sim.seconds", 30, "Simulationsdauer", 5, 120, "s");
+
+        /* Internal prefs */
+        initInteger("keyevent.about", KeyEvent.VK_A, null, 0, 100);
+        initInteger("keyevent.cancel", KeyEvent.VK_N, null, 0, 100);
+        initInteger("keyevent.close", KeyEvent.VK_C, null, 0, 100);
+        initInteger("keyevent.default", KeyEvent.VK_F, null, 0, 100);
+        initInteger("keyevent.edit", KeyEvent.VK_E, null, 0, 100);
+        initInteger("keyevent.file", KeyEvent.VK_D, null, 0, 100);
+        initInteger("keyevent.new", KeyEvent.VK_N, null, 0, 100);
+        initInteger("keyevent.actualize", KeyEvent.VK_A, null, 0, 100);
+        initInteger("keyevent.takeover", KeyEvent.VK_B, null, 0, 100);
+        initInteger("keyevent.ok", KeyEvent.VK_O, null, 0, 100);
+        initInteger("keyevent.open", KeyEvent.VK_O, null, 0, 100);
+        initInteger("keyevent.pause", KeyEvent.VK_P, null, 0, 100);
+        initInteger("keyevent.prefs", KeyEvent.VK_P, null, 0, 100);
+        initInteger("keyevent.prefs.ext", KeyEvent.VK_E, null, 0, 100);
+        initInteger("keyevent.quit", KeyEvent.VK_B, null, 0, 100);
+        initInteger("keyevent.replay", KeyEvent.VK_R, null, 0, 100);
+        initInteger("keyevent.reset", KeyEvent.VK_R, null, 0, 100);
+        initInteger("keyevent.save", KeyEvent.VK_S, null, 0, 100);
+        initInteger("keyevent.saveas", KeyEvent.VK_V, null, 0, 100);
+        initInteger("keyevent.simulation", KeyEvent.VK_S, null, 0, 100);
+        initInteger("keyevent.start", KeyEvent.VK_S, null, 0, 100);
+        initInteger("keyevent.stop", KeyEvent.VK_P, null, 0, 100);
+
+        initIntegerUnit("window.prefs.xsize", 400, "X-Grösse des Einstellungsfensters", 550, 3200, "px");
+        initIntegerUnit("window.prefs.ysize", 650, "Y-Grösse des Einstellungsfensters", 640, 2400, "px");
+        initIntegerUnit("window.loggsize", 350, "Y-Grösse des Loggingfensters", 100, 1000, "px");
+        initIntegerUnit("window.splitsize", 180, null, 100, 1000, "px");
+        initIntegerUnit("window.xsize", 1024, "X-Grösse des Hauptfensters", 800, 3200, "px");
+        initIntegerUnit("window.ysize", 768, "Y-Grösse des Hauptfensters", 600, 2400, "px");
+    }
+
+    public void fillDefaultFloats() {
+        /* Simulation prefs */
+        initFloat("sim.process.clock.variance", 0, "Uhrabweichung");
+    }
+
+    public void fillDefaultLongs() {
+        /* Simulation prefs */
+        initLongUnit("sim.message.sendingtime.min", 1000, "Minimale Nachrichtenübertragungszeit", "ms");
+        initLongUnit("sim.message.sendingtime.max", 5000, "Maximale Nachrichtenübertragungszeit", "ms");
+    }
+
+    public void fillDefaultColors() {
+        /* Internal prefs */
+        initColor("process.default", new Color(0x00, 0x00, 0x00));
+        initColor("process.running", new Color(0x0D, 0xD8, 0x09));
+        initColor("process.crashed", new Color(0xff, 0x00, 0x00));
+        initColor("process.highlight", new Color(0xff, 0xA5, 0x00));
+        initColor("process.line", new Color(0x00, 0x00, 0x00));
+        initColor("process.secondline", new Color(0xAA, 0xAA, 0xAA));
+        initColor("process.sepline", new Color(0xff, 0x00, 0x00));
+        initColor("process.stopped", new Color(0x00, 0x00, 0x00));
+        initColor("message.arrived", new Color(0x00, 0x85, 0xD2));
+        initColor("message.sending", new Color(0x0D, 0xD8, 0x09));
+        initColor("message.lost", new Color(0xFF, 0x00, 0x00));
+    }
+
+    public void fillDefaultBooleans() {
+    }
+}
diff --git a/sources/prefs/VSPrefs.java b/sources/prefs/VSPrefs.java
new file mode 100644
index 0000000..9da4808
--- /dev/null
+++ b/sources/prefs/VSPrefs.java
@@ -0,0 +1,553 @@
+package prefs;
+
+import java.awt.Color;
+import java.awt.event.KeyEvent;
+import java.io.*;
+import java.util.*;
+
+public abstract class VSPrefs implements Serializable {
+    public static final String BOOLEAN_PREFIX = "Boolean: ";
+    public static final String COLOR_PREFIX = "Color: ";
+    public static final String FLOAT_PREFIX = "Float: ";
+    public static final String INTEGER_PREFIX = "Integer: ";
+    public static final String LONG_PREFIX = "Long: ";
+    public static final String STRING_PREFIX = "String: ";
+    private HashMap<String,Color> colorVSPrefs;
+    private HashMap<String,Float> floatVSPrefs;
+    private HashMap<String,Integer> integerVSPrefs;
+    private HashMap<String,Long> longVSPrefs;
+    private HashMap<String,SettingRestriction> settingRestrictionPrefs;
+    private HashMap<String,String> descriptionPrefs;
+    private HashMap<String,String> stringVSPrefs;
+    private HashMap<String,Boolean> booleanVSPrefs;
+    private HashMap<String,Object> objectVSPrefs;
+    private HashMap<String,String> units;
+    private static final long serialVersionUID = 4L;
+    protected final static String PREFERENCES_FILENAME = "vs.dat";
+    private static long idCounter;
+    protected long id;
+
+    public class SettingRestriction implements Serializable {
+    }
+
+    public class IntegerSettingRestriction extends SettingRestriction {
+        private int minValue;
+        private int maxValue;
+
+        public IntegerSettingRestriction(int minValue, int maxValue) {
+            this.minValue = minValue;
+            this.maxValue = maxValue;
+        }
+
+        public int getMinValue() {
+            return minValue;
+        }
+
+        public int getMaxValue() {
+            return maxValue;
+        }
+    }
+
+    public class StringSettingRestriction extends SettingRestriction {
+        Vector<String> possibleSelections;
+
+        public StringSettingRestriction(String [] possibleSelections) {
+            this.possibleSelections = new Vector<String>();
+
+            for (String elem : possibleSelections)
+                this.possibleSelections.add(elem);
+        }
+
+        public Vector<String> getPossibleSelections() {
+            return possibleSelections;
+        }
+    }
+
+    public VSPrefs() {
+        colorVSPrefs = new HashMap<String,Color>();
+        descriptionPrefs = new HashMap<String,String>();
+        floatVSPrefs = new HashMap<String,Float>();
+        integerVSPrefs = new HashMap<String,Integer>();
+        longVSPrefs = new HashMap<String,Long>();
+        settingRestrictionPrefs = new HashMap<String,SettingRestriction>();
+        stringVSPrefs = new HashMap<String,String>();
+        booleanVSPrefs = new HashMap<String,Boolean>();
+        objectVSPrefs = new HashMap<String,Object>();
+        units = new HashMap<String,String>();
+        id = ++idCounter;
+    }
+
+    protected synchronized void clear() {
+        colorVSPrefs.clear();
+        floatVSPrefs.clear();
+        integerVSPrefs.clear();
+        longVSPrefs.clear();
+        stringVSPrefs.clear();
+        booleanVSPrefs.clear();
+        objectVSPrefs.clear();
+        descriptionPrefs.clear();
+        settingRestrictionPrefs.clear();
+    }
+
+    public synchronized Object getObject(String key) {
+        Object val = objectVSPrefs.get(key);
+
+        if (val == null) {
+            System.err.println("Fatal: No such object config value \""
+                               + key + "\"");
+            System.exit(1);
+        }
+
+        return val;
+    }
+
+    public synchronized boolean objectExists(String key) {
+        return null != objectVSPrefs.get(key);
+    }
+
+    public synchronized String getString(String key) {
+        String val = stringVSPrefs.get(key);
+
+        if (val == null) {
+            System.err.println("Fatal: No such string config value \""
+                               + key + "\"");
+            System.exit(1);
+        }
+
+        return val;
+    }
+
+    public synchronized Integer getIntegerObj(String key) {
+        Integer val = integerVSPrefs.get(key);
+
+        if (val == null) {
+            System.err.println("Fatal: No such integer config value \""
+                               + key + "\"");
+            System.exit(1);
+        }
+
+        return val;
+    }
+
+    public int getInteger(String key) {
+        return getIntegerObj(key).intValue();
+    }
+
+    public synchronized Float getFloatObj(String key) {
+        Float val = floatVSPrefs.get(key);
+
+        if (val == null) {
+            System.err.println("Fatal: No such float config value \""
+                               + key + "\"");
+            System.exit(1);
+        }
+
+        return val;
+    }
+
+    public float getFloat(String key) {
+        return getFloatObj(key).floatValue();
+    }
+
+    public synchronized Long getLongObj(String key) {
+        Long val = longVSPrefs.get(key);
+
+        if (val == null) {
+            System.err.println("Fatal: No such long config value \""
+                               + key + "\"");
+            System.exit(1);
+        }
+
+        return val;
+    }
+
+    public long getLong(String key) {
+        return getLongObj(key).longValue();
+    }
+
+    public synchronized Boolean getBooleanObj(String key) {
+        Boolean val = booleanVSPrefs.get(key);
+
+        if (val == null)
+            return new Boolean(false);
+
+        return val;
+    }
+
+    public boolean getBoolean(String key) {
+        return getBooleanObj(key).booleanValue();
+    }
+
+    public synchronized Color getColor(String key) {
+        Color color = colorVSPrefs.get(key);
+
+        if (color == null) {
+            System.err.println("Fatal: No such color config value \""
+                               + key + "\"");
+            System.exit(1);
+        }
+
+        return color;
+    }
+
+    public synchronized String getDescription(String key) {
+        return descriptionPrefs.get(key);
+    }
+
+    public synchronized String getUnit(String key) {
+        return units.get(key);
+    }
+
+    public synchronized SettingRestriction getRestriction(String key) {
+        return settingRestrictionPrefs.get(key);
+    }
+
+    public synchronized Set<String> getStringKeySet() {
+        return stringVSPrefs.keySet();
+    }
+
+    public synchronized Set<String> getIntegerKeySet() {
+        return integerVSPrefs.keySet();
+    }
+
+    public synchronized Set<String> getFloatKeySet() {
+        return floatVSPrefs.keySet();
+    }
+
+    public synchronized Set<String> getLongKeySet() {
+        return longVSPrefs.keySet();
+    }
+
+    public synchronized Set<String> getBooleanKeySet() {
+        return booleanVSPrefs.keySet();
+    }
+
+    public synchronized Set<String> getColorKeySet() {
+        return colorVSPrefs.keySet();
+    }
+
+    public synchronized void setObject(String key, Object val) {
+        objectVSPrefs.put(key, val);
+    }
+
+    public synchronized void setString(String key, String val) {
+        stringVSPrefs.put(key, val);
+    }
+
+    public synchronized void setInteger(String key, Integer val) {
+        integerVSPrefs.put(key, val);
+    }
+
+    public synchronized void setColor(String key, Color color) {
+        colorVSPrefs.put(key, color);
+    }
+
+    public synchronized void setInt(String key, int val) {
+        integerVSPrefs.put(key, new Integer(val));
+    }
+
+    public synchronized void setFloat(String key, float val) {
+        floatVSPrefs.put(key, new Float(val));
+    }
+
+    public synchronized void setFloat(String key, Float val) {
+        floatVSPrefs.put(key, val);
+    }
+
+    public synchronized void setLong(String key, long val) {
+        longVSPrefs.put(key, new Long(val));
+    }
+
+    public synchronized void setLong(String key, Long val) {
+        longVSPrefs.put(key, val);
+    }
+
+    public synchronized void setBoolean(String key, boolean val) {
+        booleanVSPrefs.put(key, new Boolean(val));
+    }
+
+    public synchronized void setBoolean(String key, Boolean val) {
+        booleanVSPrefs.put(key, val);
+    }
+
+    public synchronized void initString(String key, String val) {
+        if (!stringVSPrefs.containsKey(key))
+            stringVSPrefs.put(key, val);
+    }
+
+    public synchronized void initInteger(String key, Integer val) {
+        if (!integerVSPrefs.containsKey(key))
+            integerVSPrefs.put(key, val);
+    }
+
+    public void initInteger(String key, int val) {
+        initInteger(key, new Integer(val));
+    }
+
+    public synchronized void initLong(String key, Long val) {
+        if (!longVSPrefs.containsKey(key))
+            longVSPrefs.put(key, val);
+    }
+
+    public void initLong(String key, int val) {
+        initLong(key, new Long(val));
+    }
+
+    public synchronized void initFloat(String key, Float val) {
+        if (!floatVSPrefs.containsKey(key))
+            floatVSPrefs.put(key, val);
+    }
+
+    public void initFloat(String key, float val) {
+        initFloat(key, new Float(val));
+    }
+
+    public synchronized void setLongIfUnset(String key, Long val) {
+        if (!longVSPrefs.containsKey(key))
+            longVSPrefs.put(key, val);
+    }
+
+    public void setLongIfUnset(String key, long val) {
+        setLongIfUnset(key, new Long(val));
+    }
+
+    public synchronized void initBoolean(String key, Boolean val) {
+        if (!booleanVSPrefs.containsKey(key))
+            booleanVSPrefs.put(key, val);
+    }
+
+    public void initBoolean(String key, boolean val) {
+        initBoolean(key, new Boolean(val));
+    }
+
+    public synchronized void initColor(String key, Color color) {
+        if (!colorVSPrefs.containsKey(key))
+            colorVSPrefs.put(key, color);
+    }
+
+    public synchronized void setDescriptionIfUnset(String key, String descr) {
+        if (descr == null || descriptionPrefs.containsKey(key))
+            return;
+        descriptionPrefs.put(key, descr);
+    }
+
+    public synchronized void setRestriction(String key, SettingRestriction settingRestriction) {
+        settingRestrictionPrefs.put(key, settingRestriction);
+    }
+
+    public synchronized void setUnit(String key, String unit) {
+        units.put(key, unit);
+    }
+
+    public void initString(String key, String val, String descr) {
+        initString(key, val);
+        setDescriptionIfUnset(STRING_PREFIX + key, descr);
+    }
+
+    public void setLongIfUnset(String key, long val, String descr) {
+        setLongIfUnset(key, val);
+        setDescriptionIfUnset(LONG_PREFIX + key, descr);
+    }
+
+    public void initBoolean(String key, boolean val, String descr) {
+        initBoolean(key, val);
+        setDescriptionIfUnset(BOOLEAN_PREFIX + key, descr);
+    }
+
+    public void initBooleanUnit(String key, boolean val, String descr, String unit) {
+        initBoolean(key, val, descr);
+        setUnit(BOOLEAN_PREFIX + key, unit);
+    }
+
+    public void initInteger(String key, Integer val, String descr, IntegerSettingRestriction r) {
+        initInteger(key, val);
+        setDescriptionIfUnset(INTEGER_PREFIX + key, descr);
+        setRestriction(INTEGER_PREFIX + key, r);
+    }
+
+    public void initInteger(String key, Integer val, String descr, int minValue, int maxValue) {
+        initInteger(key, val, descr, new IntegerSettingRestriction(minValue, maxValue));
+    }
+
+    public void initInteger(String key, int val, String descr, IntegerSettingRestriction r) {
+        initInteger(key, new Integer(val), descr, r);
+    }
+
+    public void initInteger(String key, int val, String descr, int minValue, int maxValue) {
+        initInteger(key, new Integer(val), descr, minValue, maxValue);
+    }
+
+    public void initIntegerUnit(String key, int val, String descr, int minValue, int maxValue, String unit) {
+        initInteger(key, new Integer(val), descr, minValue, maxValue);
+        setUnit(INTEGER_PREFIX + key, unit);
+    }
+
+    public void initLong(String key, Long val, String descr) {
+        initLong(key, val);
+        setDescriptionIfUnset(LONG_PREFIX + key, descr);
+    }
+
+    public void initLong(String key, int val, String descr) {
+        initLong(key, new Long(val), descr);
+    }
+
+    public void initLongUnit(String key, int val, String descr, String unit) {
+        initLong(key, new Long(val), descr);
+        setUnit(LONG_PREFIX + key, unit);
+    }
+
+    public void initFloat(String key, Float val, String descr) {
+        initFloat(key, val);
+        setDescriptionIfUnset(FLOAT_PREFIX + key, descr);
+    }
+
+    public void initFloat(String key, float val, String descr) {
+        initFloat(key, new Float(val), descr);
+    }
+
+    public void initFloatUnit(String key, float val, String descr, String unit) {
+        initFloat(key, new Float(val), descr);
+        setUnit(FLOAT_PREFIX + key, unit);
+    }
+
+
+    public void initColor(String key, Color val, String descr) {
+        initColor(key, val);
+        setDescriptionIfUnset(COLOR_PREFIX + key, descr);
+    }
+
+    public void fillDefaultStrings() {}
+    public void fillDefaultIntegers() {}
+    public void fillDefaultFloats() {}
+    public void fillDefaultColors() {}
+    public void fillDefaultBooleans() {}
+    public void fillWithDefaults() {}
+
+    public synchronized void writeObject(ObjectOutputStream objectOutputStream)
+    throws IOException {
+        objectOutputStream.writeObject(booleanVSPrefs);
+        objectOutputStream.writeObject(colorVSPrefs);
+        objectOutputStream.writeObject(floatVSPrefs);
+        objectOutputStream.writeObject(integerVSPrefs);
+        objectOutputStream.writeObject(longVSPrefs);
+        objectOutputStream.writeObject(stringVSPrefs);
+        objectOutputStream.writeObject(units);
+    }
+
+    public synchronized void readObject(ObjectInputStream objectInputStream)
+    throws IOException, ClassNotFoundException {
+        booleanVSPrefs = (HashMap<String,Boolean>) objectInputStream.readObject();
+        colorVSPrefs = (HashMap<String,Color>) objectInputStream.readObject();
+        descriptionPrefs = new HashMap<String,String>();
+        floatVSPrefs = (HashMap<String,Float>) objectInputStream.readObject();
+        integerVSPrefs = (HashMap<String,Integer>) objectInputStream.readObject();
+        longVSPrefs = (HashMap<String,Long>) objectInputStream.readObject();
+        settingRestrictionPrefs = new HashMap<String,SettingRestriction>();
+        stringVSPrefs = (HashMap<String,String>) objectInputStream.readObject();
+        units = (HashMap<String,String>) objectInputStream.readObject();
+    }
+
+    public void saveFile(String filename) {
+        //System.out.println("SAVE FILE " + filename);
+        try {
+            FileOutputStream fileOutputStream = new FileOutputStream(filename);
+            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
+            objectOutputStream.writeObject(this);
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void saveFile() { };
+
+    public static VSPrefs openFile(String filename) {
+        VSPrefs prefs = null;
+        //System.out.println("OPEN FILE " + filename);
+
+        try {
+            FileInputStream fileInputStream = new FileInputStream(filename);
+            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
+            prefs = (VSPrefs) objectInputStream.readObject();
+
+            prefs.fillDefaultStrings();
+            prefs.fillDefaultIntegers();
+            prefs.fillDefaultFloats();
+            prefs.fillDefaultColors();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return prefs;
+    }
+
+    public void copyIntegers(VSPrefs copyInto, String[] keys) {
+        for (String key : keys)
+            copyInto.initInteger(key, getInteger(key), getDescription(INTEGER_PREFIX + key),
+                                 (IntegerSettingRestriction) getRestriction(INTEGER_PREFIX + key));
+    }
+
+    public void copyLongs(VSPrefs copyInto, String[] keys) {
+        for (String key : keys)
+            copyInto.initLong(key, getLong(key), getDescription(LONG_PREFIX + key));
+    }
+
+    public void copyFloats(VSPrefs copyInto, String[] keys) {
+        for (String key : keys)
+            copyInto.initFloat(key, getFloat(key), getDescription(FLOAT_PREFIX + key));
+    }
+
+    public void copyStrings(VSPrefs copyInto, String[] keys) {
+        for (String key : keys)
+            copyInto.initString(key, getString(key), getDescription(STRING_PREFIX + key));
+    }
+
+    public void copyColors(VSPrefs copyInto, String[] keys) {
+        for (String key : keys)
+            copyInto.initColor(key, getColor(key), getDescription(COLOR_PREFIX + key));
+    }
+
+    public String toString() {
+        String descr = "";
+
+        Set<String> set = null;
+
+        set = getIntegerKeySet();
+        if (set.size() > 0) {
+            descr += INTEGER_PREFIX;
+            for (String key : set)
+                descr += key + "=" + getInteger(key) + "; ";
+        }
+
+        set = getFloatKeySet();
+        if (set.size() > 0) {
+            descr += FLOAT_PREFIX;
+            for (String key : set)
+                descr += key + "=" + getFloat(key) + "; ";
+        }
+
+        set = getBooleanKeySet();
+        if (set.size() > 0) {
+            descr += BOOLEAN_PREFIX;
+            for (String key : set)
+                descr += key + "=" + getBoolean(key) + "; ";
+        }
+
+        set = getStringKeySet();
+        if (set.size() > 0) {
+            descr += STRING_PREFIX;
+            for (String key : set)
+                descr += key + "=" + getString(key) + "; ";
+        }
+
+        if (descr.endsWith("; "))
+            return descr.substring(0, descr.length() - 2);
+
+        return descr;
+    }
+
+    public long getID() {
+        return id;
+    }
+}