summaryrefslogtreecommitdiff
path: root/src/main/java/prefs
diff options
context:
space:
mode:
authorPaul Buetow <paul@buetow.org>2025-06-06 08:02:52 +0300
committerPaul Buetow <paul@buetow.org>2025-06-06 08:02:52 +0300
commit1d99762c7965d351510cfb5e08eac25e48d96038 (patch)
treef469493e911878ab9055ccf0494211bf9015922d /src/main/java/prefs
parent4d35597bd92607c4d194686e20b125044506c79a (diff)
Modernize project structure, update Maven config, move sources, add logging config, update README and .gitignore
Diffstat (limited to 'src/main/java/prefs')
-rw-r--r--src/main/java/prefs/VSDefaultPrefs.java275
-rw-r--r--src/main/java/prefs/VSPrefs.java1163
-rw-r--r--src/main/java/prefs/VSPrefsRestriction.java137
-rw-r--r--src/main/java/prefs/VSSerializablePrefs.java37
-rw-r--r--src/main/java/prefs/editors/VSAbstractBetterEditor.java101
-rw-r--r--src/main/java/prefs/editors/VSAbstractEditor.java1056
-rw-r--r--src/main/java/prefs/editors/VSColorChooser.java61
-rw-r--r--src/main/java/prefs/editors/VSEditorFrame.java98
-rw-r--r--src/main/java/prefs/editors/VSEditorTable.java290
-rw-r--r--src/main/java/prefs/editors/VSProcessEditor.java107
-rw-r--r--src/main/java/prefs/editors/VSSimulatorEditor.java120
11 files changed, 3445 insertions, 0 deletions
diff --git a/src/main/java/prefs/VSDefaultPrefs.java b/src/main/java/prefs/VSDefaultPrefs.java
new file mode 100644
index 0000000..f980734
--- /dev/null
+++ b/src/main/java/prefs/VSDefaultPrefs.java
@@ -0,0 +1,275 @@
+package prefs;
+
+import java.awt.Color;
+import java.awt.event.KeyEvent;
+
+/**
+ * The class VSDefaultPrefs, makes sure that the simulator has its default
+ * configuration values.
+ *
+ * @author Paul C. Buetow
+ */
+public class VSDefaultPrefs extends VSSerializablePrefs {
+ /**
+ * Inits a prefs object with default values.
+ *
+ * @return the lang.process.removeprefs
+ */
+ public static VSPrefs init() {
+ VSDefaultPrefs prefs = new VSDefaultPrefs();
+ prefs.fillWithDefaults();
+ return prefs;
+ }
+
+ /**
+ * Fill everything with ts defaults.
+ */
+ public void fillWithDefaults() {
+ super.clear();
+ addWithDefaults();
+ }
+
+ /**
+ * Adds default values if not existent.
+ */
+ public void addWithDefaults() {
+ fillDefaultBooleans();
+ fillDefaultColors();
+ fillDefaultFloats();
+ fillDefaultIntegers();
+ fillDefaultLongs();
+ fillDefaultStrings();
+ }
+
+ /**
+ * Fill with default strings.
+ */
+ public void fillDefaultStrings() {
+ initString("lang.about", "About");
+ initString("lang.about.info", "This program used to be the diploma thesis of Paul C. Buetow. Please contact vs-sim@dev.buetow.org, if you find any errors!");
+ initString("lang.activate", "activate");
+ initString("lang.activated", "activated");
+ initString("lang.actualize", "Activation");
+ initString("lang.all", "All");
+ initString("lang.antialiasing", "Anti-Aliasing");
+ initString("lang.cancel", "Abort");
+ initString("lang.client", "Client");
+ initString("lang.clientrequest.start", "Start client request");
+ initString("lang.close", "Close");
+ initString("lang.colorchooser", "Color chooser");
+ initString("lang.colorchooser2", "Please select color");
+ initString("lang.copy", "Copy");
+ initString("lang.crashed", "Crashed");
+ initString("lang.dat", "Simulation (.dat)");
+ initString("langactivate", "deactivate");
+ initString("langactivated", "deactivated");
+ initString("lang.default", "Defaults");
+ initString("lang.edit", "Edit");
+ initString("lang.editor", "Editor");
+ initString("lang.event", "Event");
+ initString("lang.event.add.global", "Insert global event");
+ initString("lang.event.add.local", "Insert local event");
+ initString("lang.event.add.time", "at");
+ initString("lang.events", "Events");
+ initString("lang.events.process", "Process events");
+ initString("lang.file", "File");
+ initString("lang.filter", "Filter");
+ initString("lang.loging.active", "Logging");
+ initString("lang.loging.clear", "Delete logs");
+ initString("lang.message", "Message");
+ initString("lang.message.recv", "Message received");
+ initString("lang.message.sent", "Message sent");
+ initString("lang.mode.expert", "Expert mode");
+ initString("lang.name", "VS-Simulator 1.2-beta");
+ initString("lang.ok", "OK");
+ initString("lang.open", "Open");
+ initString("lang.pause", "Pause");
+ initString("lang.prefs", "Preferences");
+ initString("lang.prefs.color", "Color preferences");
+ initString("lang.prefs.diverse", "Diverse preferences");
+ initString("lang.prefs.ext", "Extended preferences");
+ initString("lang.prefs.message", "Message preferences");
+ initString("lang.prefs.message.defaults", "Message prefs. for new processes");
+ initString("lang.prefs.more", "More preferences");
+ initString("lang.prefs.process", "Process preferences");
+ initString("lang.prefs.process", "Standard process preferences");
+ initString("lang.prefs.process.defaults", "Preferences for new processes");
+ initString("lang.prefs.process.ext", "Extended process preferences");
+ initString("lang.prefs.protocols", "Protocol preferences");
+ initString("lang.prefs.simulator", "Simulator preferences");
+ initString("lang.process", "Process");
+ initString("lang.process.add.new", "Insert new process");
+ initString("lang.process.crash", "Crash process");
+ initString("lang.process.edit", "Edit process");
+ initString("lang.process.id", "PID");
+ initString("lang.process.new", "New process");
+ initString("lang.process.not.selected", "No process selected");
+ initString("lang.process.recover", "Recover process");
+ initString("lang.process.remove", "Remove process");
+ initString("lang.process.selected", "Selected process");
+ initString("lang.process.time.local", "Local time");
+ initString("lang.processes.all", "All processes");
+ initString("lang.protocol", "Protocol");
+ initString("lang.protocol.client", "Client side");
+ initString("lang.protocol.editor", "Protocol editor");
+ initString("lang.protocol.server", "Server side");
+ initString("lang.protocol.tasks.activation", "Client-/Server protocol activation");
+ initString("lang.protocol.tasks.client", "Client Task-Manager (Client request)");
+ initString("lang.protocols", "Protocols");
+ initString("lang.quit", "Quit");
+ initString("lang.recovered", "Recovered");
+ initString("lang.remove", "Remove");
+ initString("lang.replay", "Repeat");
+ initString("lang.reset", "Reset");
+ initString("lang.save", "Save");
+ initString("lang.saveas", "Save as");
+ initString("lang.server", "Server");
+ initString("lang.serverrequest.start", "Start server request");
+ initString("lang.simulator", "Simulator");
+ initString("lang.simulator.close", "Close simulation");
+ initString("lang.simulator.finished", "Simulation closed");
+ initString("lang.simulator.new", "New simulation");
+ initString("lang.simulator.paused", "Simulation paused");
+ initString("lang.simulator.resetted", "Simulation resetted");
+ initString("lang.simulator.started", "Simulation started");
+ initString("lang.start", "Start");
+ initString("lang.stop", "Stop");
+ initString("lang.takeover", "Take over");
+ initString("lang.task", "Task");
+ initString("lang.task.manager", "Event editor");
+ initString("lang.tasks.fullfilled", "Fullfilled tasks");
+ initString("lang.tasks.global", "GLobal tasks");
+ initString("lang.tasks.local", "Local tasks");
+ initString("lang.time", "Time");
+ initString("lang.time.lamport", "Lamport time");
+ initString("lang.time.vector", "Vector time");
+ initString("lang.timed.global", "Global events");
+ initString("lang.timed.local", "Local events");
+ initString("lang.type", "Type");
+ initString("lang.value", "Value");
+ initString("lang.variable", "Variable");
+ initString("lang.variables", "Variables");
+ initString("lang.variables.global", "Global variables");
+ initString("lang.window.close", "Close window");
+ initString("lang.window.new", "New window");
+
+ /* Protocol names */
+ initString("lang.events.implementations.VSProcessCrashEvent", "Process Crash Event");
+ initString("lang.events.implementations.VSProcessCrashEvent.short", "Process Crash");
+ initString("lang.events.implementations.VSProcessRecoverEvent", "Process Recover Event");
+ initString("lang.events.implementations.VSProcessRecoverEvent.short", "Process Recover");
+ initString("lang.protocols.implementations.VSBasicMulticastProtocol", "Basic Multicast Protocol");
+ initString("lang.protocols.implementations.VSBasicMulticastProtocol.short", "Basic Multicast");
+ initString("lang.protocols.implementations.VSBerkelyTimeProtocol", "Berkley algorithm for internal sync.");
+ initString("lang.protocols.implementations.VSBerkelyTimeProtocol.short", "Berkley Protocol");
+ initString("lang.protocols.implementations.VSBroadcastProtocol", "Broadcast Protocol");
+ initString("lang.protocols.implementations.VSBroadcastProtocol.short", "Broadcast");
+ initString("lang.protocols.implementations.VSDummyProtocol", "Example/Dummy Protocol");
+ initString("lang.protocols.implementations.VSDummyProtocol.short", "Example/Dummy");
+ initString("lang.protocols.implementations.VSExternalTimeSyncProtocol", "Christians method for external sync.");
+ initString("lang.protocols.implementations.VSExternalTimeSyncProtocol.short", "Christians");
+ initString("lang.protocols.implementations.VSInternalTimeSyncProtocol", "Internal Synchronization Protocol");
+ initString("lang.protocols.implementations.VSInternalTimeSyncProtocol.short", "Internal sync.");
+ initString("lang.protocols.implementations.VSOnePhaseCommitProtocol", "One-Phase Commit Protocol");
+ initString("lang.protocols.implementations.VSOnePhaseCommitProtocol.short", "1-Phase Commit");
+ initString("lang.protocols.implementations.VSPingPongProtocol", "Ping-Pong Protocol");
+ initString("lang.protocols.implementations.VSPingPongProtocol.short", "Ping-Pong");
+ initString("lang.protocols.implementations.VSReliableMulticastProtocol", "Reliable Multicast Protocol");
+ initString("lang.protocols.implementations.VSReliableMulticastProtocol.short", "Reliable Multicast");
+ initString("lang.protocols.implementations.VSTwoPhaseCommitProtocol", "Two-Phase Commit");
+ initString("lang.protocols.implementations.VSTwoPhaseCommitProtocol.short", "2-Phase Commit");
+ }
+
+ /**
+ * Fill with default integers.
+ */
+ public void fillDefaultIntegers() {
+ /* Simulator prefs */
+ initInteger("sim.process.num", 3, "Number of processes", 1, 6);
+ initInteger("message.prob.outage", 0, "Message lost prob.", 0, 100, "%");
+ initInteger("process.prob.crash", 0, "Process crash prob.", 0, 100, "%");
+ initInteger("sim.seconds", 15, "Simulation duration", 5, 120, "s");
+
+ /* Internal prefs */
+ initInteger("keyevent.about", KeyEvent.VK_A, null, 0, 100);
+ initInteger("keyevent.cancel", KeyEvent.VK_A, 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_W, 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.simulator", KeyEvent.VK_S, null, 0, 100);
+ initInteger("keyevent.start", KeyEvent.VK_S, null, 0, 100);
+ initInteger("keyevent.stop", KeyEvent.VK_P, null, 0, 100);
+
+ initInteger("div.window.prefs.xsize", 400, "Configuration window X-Axis", 550, 3200, "px");
+ initInteger("div.window.prefs.ysize", 400, "Configuration window Y-Axis", 640, 2400, "px");
+ initInteger("div.window.logsize", 300, "Log window Y-Axis", 100, 1000, "px");
+ initInteger("div.window.splitsize", 320, "Toolbar X-Axis", 100, 1000, "px");
+ initInteger("div.window.xsize", 1024, "Main window X-Axis", 750, 3200, "px");
+ initInteger("div.window.ysize", 768, "Main window Y-Axis", 600, 2400, "px");
+ }
+
+ /**
+ * Fill with default floats.
+ */
+ public void fillDefaultFloats() {
+ /* Simulator prefs */
+ initFloat("process.clock.variance", 0, "Clock variance");
+ initFloat("sim.clock.speed", 0.5f, "Simulation play speed");
+ }
+
+ /**
+ * Fill default longs.
+ */
+ public void fillDefaultLongs() {
+ /* Simulator prefs */
+ initLong("message.sendingtime.min", 500, "Max transmission time", "ms");
+ initLong("message.sendingtime.max", 2000, "Min transmission time", "ms");
+ }
+
+ /**
+ * Fill with default colors.
+ */
+ public void fillDefaultColors() {
+ /* Internal prefs */
+ initColor("col.background", new Color(0xFF, 0xFF, 0xFF));
+ initColor("col.process.default", new Color(0x00, 0x00, 0x00));
+ initColor("col.process.running", new Color(0x0D, 0xD8, 0x09));
+ initColor("col.process.crashed", new Color(0xff, 0x00, 0x00));
+ initColor("col.process.highlight", new Color(0xff, 0xA5, 0x00));
+ initColor("col.process.line", new Color(0x00, 0x00, 0x00));
+ initColor("col.process.secondline", new Color(0xAA, 0xAA, 0xAA));
+ initColor("col.process.sepline", new Color(0xff, 0x00, 0x00));
+ initColor("col.process.stopped", new Color(0x00, 0x00, 0x00));
+ initColor("col.message.arrived", new Color(0x00, 0x85, 0xD2));
+ initColor("col.message.sending", new Color(0x0D, 0xD8, 0x09));
+ initColor("col.message.lost", new Color(0xFF, 0x00, 0x00));
+ }
+
+ /**
+ * Fill with default booleans.
+ */
+ public void fillDefaultBooleans() {
+ initBoolean("sim.mode.expert", false, "Expert mode");
+ initBoolean("sim.message.own.recv", false, "Processes receive own messages");
+ initBoolean("sim.message.prob.mean", true, "Use mean value of message lost prob.");
+ initBoolean("sim.message.sendingtime.mean", true, "Use mean value of transmission times");
+ initBoolean("sim.messages.relevant", true, "Only show relevant messages");
+ initBoolean("sim.periodic", false, "Repeat simulation periodically");
+ initBoolean("sim.update.lamporttime.all", false, "Lamport timestamps affect all events");
+ initBoolean("sim.update.vectortime.all", false, "Vector timestamps affect all events");
+ }
+}
diff --git a/src/main/java/prefs/VSPrefs.java b/src/main/java/prefs/VSPrefs.java
new file mode 100644
index 0000000..e7b5295
--- /dev/null
+++ b/src/main/java/prefs/VSPrefs.java
@@ -0,0 +1,1163 @@
+package prefs;
+
+import java.awt.Color;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.Vector;
+
+import serialize.VSSerialize;
+
+/**
+ * The class VSPrefs, this class is for dynamic data storage. It can hold
+ * various different types such as Boolean, Floats, Integers, Strings, Colors.
+ *
+ * @author Paul C. Buetow
+ */
+public class VSPrefs {
+ /** The Constant BOOLEAN_PREFIX. */
+ public static final String BOOLEAN_PREFIX = "Boolean: ";
+
+ /** The Constant COLOR_PREFIX. */
+ public static final String COLOR_PREFIX = "Color: ";
+
+ /** The Constant FLOAT_PREFIX. */
+ public static final String FLOAT_PREFIX = "Float: ";
+
+ /** The Constant INTEGER_PREFIX. */
+ public static final String INTEGER_PREFIX = "Integer: ";
+
+ /** The Constant VECTOR_PREFIX. */
+ public static final String VECTOR_PREFIX = "Vector: ";
+
+ /** The Constant LONG_PREFIX. */
+ public static final String LONG_PREFIX = "Long: ";
+
+ /** The Constant STRING_PREFIX. */
+ public static final String STRING_PREFIX = "String: ";
+
+ /** The color prefs. */
+ private HashMap<String,Color> colorPrefs;
+
+ /** The float prefs. */
+ private HashMap<String,Float> floatPrefs;
+
+ /** The integer prefs. */
+ private HashMap<String,Integer> integerPrefs;
+
+ /** The integer vector prefs. */
+ private HashMap<String,Vector<Integer>> vectorPrefs;
+
+ /** The long prefs. */
+ private HashMap<String,Long> longPrefs;
+
+ /** The setting restriction prefs. */
+ private HashMap<String,VSPrefsRestriction> restrictions;
+
+ /** The description prefs. */
+ private HashMap<String,String> descriptionPrefs;
+
+ /** The string prefs. */
+ private HashMap<String,String> stringPrefs;
+
+ /** The boolean prefs. */
+ private HashMap<String,Boolean> booleanPrefs;
+
+ /** The object prefs. */
+ private HashMap<String,Object> objectPrefs;
+
+ /** The units. */
+ private HashMap<String,String> units;
+
+ /** The id counter. */
+ private static int idCounter;
+
+ /** The id. */
+ protected int id;
+
+ /**
+ * Instantiates a new lang.process.removeprefs.
+ */
+ public VSPrefs() {
+ colorPrefs = new HashMap<String,Color>();
+ descriptionPrefs = new HashMap<String,String>();
+ floatPrefs = new HashMap<String,Float>();
+ integerPrefs = new HashMap<String,Integer>();
+ vectorPrefs = new HashMap<String,Vector<Integer>>();
+ longPrefs = new HashMap<String,Long>();
+ restrictions = new HashMap<String,VSPrefsRestriction>();
+ stringPrefs = new HashMap<String,String>();
+ booleanPrefs = new HashMap<String,Boolean>();
+ objectPrefs = new HashMap<String,Object>();
+ units = new HashMap<String,String>();
+ id = ++idCounter;
+ }
+
+ /**
+ * Clear.
+ */
+ protected synchronized void clear() {
+ colorPrefs.clear();
+ floatPrefs.clear();
+ integerPrefs.clear();
+ vectorPrefs.clear();
+ longPrefs.clear();
+ stringPrefs.clear();
+ booleanPrefs.clear();
+ objectPrefs.clear();
+ descriptionPrefs.clear();
+ restrictions.clear();
+ }
+
+ /* Unit methods */
+
+ /**
+ * Gets the unit.
+ *
+ * @param fullKey the full key
+ *
+ * @return the unit
+ */
+ public synchronized String getUnit(String fullKey) {
+ return units.get(fullKey);
+ }
+
+ /**
+ * Sets the unit.
+ *
+ * @param key the key
+ * @param unit the unit
+ */
+ public synchronized void initUnit(String key, String unit) {
+ if (unit == null /*|| units.containsKey(key)*/)
+ return;
+ units.put(key, unit);
+ }
+
+ /* Description methods */
+ /**
+ * Sets the description if unset.
+ *
+ * @param key the key
+ * @param descr the descr
+ */
+ public synchronized void initDescription(String key, String descr) {
+ if (descr == null /*|| descriptionPrefs.containsKey(key)*/)
+ return;
+ descriptionPrefs.put(key, descr);
+ }
+
+ /**
+ * Gets the description.
+ *
+ * @param fullKey the full key
+ *
+ * @return the description
+ */
+ public synchronized String getDescription(String fullKey) {
+ return descriptionPrefs.get(fullKey);
+ }
+
+ /* Restriction methods */
+
+ /**
+ * Gets the restriction.
+ *
+ * @param fullKey the full key
+ *
+ * @return the restriction
+ */
+ public synchronized VSPrefsRestriction getRestriction(String fullKey) {
+ return restrictions.get(fullKey);
+ }
+
+ /**
+ * Sets the restriction.
+ *
+ * @param key the key
+ * @param settingRestriction the setting restriction
+ */
+ public synchronized void initRestriction(String key,
+ VSPrefsRestriction settingRestriction) {
+ restrictions.put(key, settingRestriction);
+ }
+
+ /* Object methods */
+
+ /**
+ * Object exists.
+ *
+ * @param key the key
+ *
+ * @return true, if successful
+ */
+ public synchronized boolean objectExists(String key) {
+ return null != objectPrefs.get(key);
+ }
+
+ /**
+ * Gets the object.
+ *
+ * @param key the key
+ *
+ * @return the object
+ */
+ public synchronized Object getObject(String key) {
+ Object val = objectPrefs.get(key);
+
+ if (val == null) {
+ System.err.println("Fatal: No such object config value \"" + key + "\"");
+ System.exit(1);
+ }
+
+ return val;
+ }
+
+ /**
+ * Removes the object.
+ *
+ * @param key the key
+ */
+ public synchronized void removeObject(String key) {
+ objectPrefs.remove(key);
+ }
+
+ /**
+ * Sets the object.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void setObject(String key, Object val) {
+ objectPrefs.put(key, val);
+ }
+
+ /* Boolean methods */
+
+ /**
+ * Gets the boolean.
+ *
+ * @param key the key
+ *
+ * @return the boolean
+ */
+ public boolean getBoolean(String key) {
+ return getBooleanObj(key).booleanValue();
+ }
+
+ /**
+ * Gets the boolean key set.
+ *
+ * @return the boolean key set
+ */
+ public synchronized Set<String> getBooleanKeySet() {
+ return booleanPrefs.keySet();
+ }
+
+ /**
+ * Gets the boolean obj.
+ *
+ * @param key the key
+ *
+ * @return the boolean obj
+ */
+ public synchronized Boolean getBooleanObj(String key) {
+ Boolean val = booleanPrefs.get(key);
+
+ if (val == null)
+ return Boolean.valueOf(false);
+
+ return val;
+ }
+
+ /**
+ * Inits the boolean.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void initBoolean(String key, Boolean val) {
+ if (!booleanPrefs.containsKey(key))
+ booleanPrefs.put(key, val);
+ }
+
+ /**
+ * Inits the boolean.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void initBoolean(String key, boolean val) {
+ initBoolean(key, Boolean.valueOf(val));
+ }
+
+ /**
+ * Inits the boolean.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initBoolean(String key, boolean val, String descr) {
+ initBoolean(key, val);
+ initDescription(BOOLEAN_PREFIX + key, descr);
+ }
+
+ /**
+ * Sets the boolean.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void setBoolean(String key, Boolean val) {
+ booleanPrefs.put(key, val);
+ }
+
+ /**
+ * Sets the boolean.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void setBoolean(String key, boolean val) {
+ setBoolean(key, Boolean.valueOf(val));
+ }
+
+ /* Color methods */
+
+ /**
+ * Gets the color.
+ *
+ * @param key the key
+ *
+ * @return the color
+ */
+ public synchronized Color getColor(String key) {
+ Color color = colorPrefs.get(key);
+
+ if (color == null) {
+ System.err.println("Fatal: No such color config value \""
+ + key + "\"");
+ System.exit(1);
+ }
+
+ return color;
+ }
+
+ /**
+ * Gets the color key set.
+ *
+ * @return the color key set
+ */
+ public synchronized Set<String> getColorKeySet() {
+ return colorPrefs.keySet();
+ }
+
+ /**
+ * Inits the color.
+ *
+ * @param key the key
+ * @param color the color
+ */
+ public synchronized void initColor(String key, Color color) {
+ if (!colorPrefs.containsKey(key))
+ colorPrefs.put(key, color);
+ }
+
+ /**
+ * Inits the color.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initColor(String key, Color val, String descr) {
+ initColor(key, val);
+ initDescription(COLOR_PREFIX + key, descr);
+ }
+
+ /**
+ * Sets the color.
+ *
+ * @param key the key
+ * @param color the color
+ */
+ public synchronized void setColor(String key, Color color) {
+ colorPrefs.put(key, color);
+ }
+
+ /* Float methods */
+
+ /**
+ * Gets the float.
+ *
+ * @param key the key
+ *
+ * @return the float
+ */
+ public float getFloat(String key) {
+ return getFloatObj(key).floatValue();
+ }
+
+ /**
+ * Gets the float key set.
+ *
+ * @return the float key set
+ */
+ public synchronized Set<String> getFloatKeySet() {
+ return floatPrefs.keySet();
+ }
+
+ /**
+ * Gets the float obj.
+ *
+ * @param key the key
+ *
+ * @return the float obj
+ */
+ public synchronized Float getFloatObj(String key) {
+ Float val = floatPrefs.get(key);
+
+ if (val == null) {
+ System.err.println("Fatal: No such float config value \""
+ + key + "\"");
+ System.exit(1);
+ }
+
+ return val;
+ }
+
+ /**
+ * Inits the float.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void initFloat(String key, Float val) {
+ if (!floatPrefs.containsKey(key))
+ floatPrefs.put(key, val);
+ }
+
+ /**
+ * Inits the float.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void initFloat(String key, float val) {
+ initFloat(key, Float.valueOf(val));
+ }
+
+ /**
+ * Inits the float.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initFloat(String key, float val, String descr) {
+ initFloat(key, val);
+ initDescription(FLOAT_PREFIX + key, descr);
+ }
+
+ /**
+ * Inits the float plus unit.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ * @param unit the unit
+ */
+ public void initFloat(String key, float val, String descr, String unit) {
+ initFloat(key, val, descr);
+ initUnit(FLOAT_PREFIX + key, unit);
+ }
+
+ /**
+ * Sets the float.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void setFloat(String key, Float val) {
+ floatPrefs.put(key, val);
+ }
+
+ /**
+ * Sets the float.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void setFloat(String key, float val) {
+ setFloat(key, Float.valueOf(val));
+ }
+
+ /* Integer methods */
+
+ /**
+ * Gets the integer.
+ *
+ * @param key the key
+ *
+ * @return the integer
+ */
+ public int getInteger(String key) {
+ return getIntegerObj(key).intValue();
+ }
+
+ /**
+ * Gets the integer key set.
+ *
+ * @return the integer key set
+ */
+ public synchronized Set<String> getIntegerKeySet() {
+ return integerPrefs.keySet();
+ }
+
+ /**
+ * Gets the integer obj.
+ *
+ * @param key the key
+ *
+ * @return the integer obj
+ */
+ public synchronized Integer getIntegerObj(String key) {
+ Integer val = integerPrefs.get(key);
+
+ if (val == null) {
+ System.err.println("Fatal: No such integer config value \"" + key + "\"");
+ System.exit(1);
+ }
+
+ return val;
+ }
+
+ /**
+ * Inits the integer.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void initInteger(String key, int val) {
+ if (!integerPrefs.containsKey(key))
+ setInteger(key, Integer.valueOf(val));
+ }
+
+ /**
+ * Inits the integer.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initInteger(String key, int val, String descr) {
+ initInteger(key, val);
+ initDescription(INTEGER_PREFIX + key, descr);
+ }
+
+ /**
+ * Inits the integer.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ * @param r the restriction
+ */
+ public void initInteger(String key, int val, String descr,
+ VSPrefsRestriction.VSIntegerPrefsRestriction r) {
+ initInteger(key, val, descr);
+ initRestriction(INTEGER_PREFIX + key, r);
+ }
+
+ /**
+ * Inits the integer.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ * @param r the restriction
+ */
+ public void initInteger(String key, int val, String descr,
+ VSPrefsRestriction.VSIntegerPrefsRestriction r,
+ String unit) {
+ initInteger(key, val, descr, r);
+ initUnit(INTEGER_PREFIX + key, unit);
+ }
+
+ /**
+ * Inits the integer.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ * @param minValue the min value
+ * @param maxValue the max value
+ */
+ public void initInteger(String key, int val, String descr, int minValue,
+ int maxValue) {
+ initInteger(key, val, descr,
+ new VSPrefsRestriction.VSIntegerPrefsRestriction(
+ minValue, maxValue));
+ }
+
+ /**
+ * Inits the integer plus unit.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ * @param minValue the min value
+ * @param maxValue the max value
+ * @param unit the unit
+ */
+ public void initInteger(String key, int val, String descr, int minValue,
+ int maxValue, String unit) {
+ initInteger(key, val, descr, minValue, maxValue);
+ initUnit(INTEGER_PREFIX + key, unit);
+ }
+
+ /**
+ * Sets the integer.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void setInteger(String key, Integer val) {
+ integerPrefs.put(key, val);
+ }
+
+ /**
+ * Sets the integer.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void setInteger(String key, int val) {
+ setInteger(key, Integer.valueOf(val));
+ }
+
+ /* Integer vector methods */
+
+ /**
+ * Gets the integer key set.
+ *
+ * @return the integer key set
+ */
+ public synchronized Set<String> getVectorKeySet() {
+ return vectorPrefs.keySet();
+ }
+
+ /**
+ * Gets the integer obj.
+ *
+ * @param key the key
+ *
+ * @return the integer obj
+ */
+ public synchronized Vector<Integer> getVector(String key) {
+ Vector<Integer> val = vectorPrefs.get(key);
+
+ if (val == null) {
+ System.err.println("Fatal: No such integer config value \"" + key + "\"");
+ System.exit(1);
+ }
+
+ return val;
+ }
+
+ /**
+ * Inits the integer.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void initVector(String key, Vector<Integer> val) {
+ if (!vectorPrefs.containsKey(key))
+ setVector(key, val);
+ }
+
+ /**
+ * Inits the integer vector.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initVector(String key, Vector<Integer> val, String descr) {
+ initVector(key, val);
+ initDescription(VECTOR_PREFIX + key, descr);
+ }
+
+ /**
+ * Inits the integer vector plus unit.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initVector(String key, Vector<Integer> val, String descr,
+ String unit) {
+ initVector(key, val, descr);
+ initUnit(VECTOR_PREFIX + key, unit);
+ }
+
+ /**
+ * Sets the integer vector.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void setVector(String key, Vector<Integer> val) {
+ vectorPrefs.put(key, val);
+ }
+
+ /* Long methods */
+
+ /**
+ * Gets the long.
+ *
+ * @param key the key
+ *
+ * @return the long
+ */
+ public long getLong(String key) {
+ return getLongObj(key).longValue();
+ }
+
+ /**
+ * Gets the long key set.
+ *
+ * @return the long key set
+ */
+ public synchronized Set<String> getLongKeySet() {
+ return longPrefs.keySet();
+ }
+
+ /**
+ * Gets the long obj.
+ *
+ * @param key the key
+ *
+ * @return the long obj
+ */
+ public synchronized Long getLongObj(String key) {
+ Long val = longPrefs.get(key);
+
+ if (val == null) {
+ System.err.println("Fatal: No such long config value \"" + key + "\"");
+ System.exit(1);
+ }
+
+ return val;
+ }
+
+ /**
+ * Inits the long.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void initLong(String key, Long val) {
+ if (!longPrefs.containsKey(key))
+ longPrefs.put(key, val);
+ }
+
+ /**
+ * Sets the long if unset.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void initLong(String key, long val) {
+ initLong(key, Long.valueOf(val));
+ }
+
+ /**
+ * Inits the long.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initLong(String key, long val, String descr) {
+ initLong(key, val);
+ initDescription(LONG_PREFIX + key, descr);
+ }
+
+ /**
+ * Inits the long unit.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ * @param unit the unit
+ */
+ public void initLong(String key, long val, String descr, String unit) {
+ initLong(key, val, descr);
+ initUnit(LONG_PREFIX + key, unit);
+ }
+
+ /**
+ * Deletes the long.
+ *
+ * @param key the key
+ */
+ public synchronized void deleteLong(String key) {
+ longPrefs.remove(key);
+ }
+
+ /**
+ * Sets the long.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void setLong(String key, Long val) {
+ longPrefs.put(key, val);
+ }
+
+ /**
+ * Sets the long.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public void setLong(String key, long val) {
+ setLong(key, Long.valueOf(val));
+ }
+
+ /* String methods */
+
+ /**
+ * Gets the string.
+ *
+ * @param key the key
+ *
+ * @return the string
+ */
+ public synchronized String getString(String key) {
+ String val = stringPrefs.get(key);
+
+ if (val == null) {
+ System.err.println("Fatal: No such string config value \"" + key + "\"");
+ System.exit(1);
+ }
+
+ return val;
+ }
+
+ /**
+ * Gets the string key set.
+ *
+ * @return the string key set
+ */
+ public synchronized Set<String> getStringKeySet() {
+ return stringPrefs.keySet();
+ }
+
+ /**
+ * Inits the string.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void initString(String key, String val) {
+ //if (!stringPrefs.containsKey(key))
+ stringPrefs.put(key, val);
+ }
+
+ /**
+ * Inits the string.
+ *
+ * @param key the key
+ * @param val the val
+ * @param descr the descr
+ */
+ public void initString(String key, String val, String descr) {
+ initString(key, val);
+ initDescription(STRING_PREFIX + key, descr);
+ }
+
+ /**
+ * Sets the string.
+ *
+ * @param key the key
+ * @param val the val
+ */
+ public synchronized void setString(String key, String val) {
+ stringPrefs.put(key, val);
+ }
+
+ /* (non-Javadoc)
+ * @see serialize.VSSerializable#serialize(serialize.VSSerialize,
+ * java.io.ObjectOutputStream)
+ */
+ protected synchronized void serialize_(
+ VSSerialize serialize, ObjectOutputStream objectOutputStream)
+ throws IOException {
+ /** For later backwards compatibility, to add more stuff */
+ objectOutputStream.writeObject(Boolean.valueOf(false));
+
+ objectOutputStream.writeObject(booleanPrefs);
+ objectOutputStream.writeObject(colorPrefs);
+ objectOutputStream.writeObject(descriptionPrefs);
+ objectOutputStream.writeObject(floatPrefs);
+ objectOutputStream.writeObject(integerPrefs);
+ objectOutputStream.writeObject(longPrefs);
+ objectOutputStream.writeObject(stringPrefs);
+ objectOutputStream.writeObject(units);
+ objectOutputStream.writeObject(vectorPrefs);
+ objectOutputStream.writeObject(restrictions);
+
+ /** For later backwards compatibility, to add more stuff */
+ objectOutputStream.writeObject(Boolean.valueOf(false));
+ }
+
+ /* (non-Javadoc)
+ * @see serialize.VSSerializable#deserialize(serialize.VSSerialize,
+ * java.io.ObjectInputStream)
+ */
+ @SuppressWarnings("unchecked")
+ protected synchronized void deserialize_(VSSerialize serialize,
+ ObjectInputStream objectInputStream)
+ throws IOException, ClassNotFoundException {
+ objectPrefs.clear();
+
+ /** For later backwards compatibility, to add more stuff */
+ objectInputStream.readObject();
+
+ booleanPrefs = (HashMap<String,Boolean>) objectInputStream.readObject();
+ colorPrefs = (HashMap<String,Color>) objectInputStream.readObject();
+ descriptionPrefs = (HashMap<String,String>) objectInputStream.readObject();
+ floatPrefs = (HashMap<String,Float>) objectInputStream.readObject();
+ integerPrefs = (HashMap<String,Integer>) objectInputStream.readObject();
+ longPrefs = (HashMap<String,Long>) objectInputStream.readObject();
+ stringPrefs = (HashMap<String,String>) objectInputStream.readObject();
+ units = (HashMap<String,String>) objectInputStream.readObject();
+ vectorPrefs = (HashMap<String,Vector<Integer>>) objectInputStream.readObject();
+ restrictions = (HashMap<String,VSPrefsRestriction>) objectInputStream.readObject();
+
+ /** For later backwards compatibility, to add more stuff */
+ objectInputStream.readObject();
+ }
+
+ /**
+ * Copies integers into another VSPrefs object.
+ *
+ * @param copyInto the copy into
+ * @param keys the keys
+ */
+ public void copyIntegers(VSPrefs copyInto, String[] keys) {
+ for (String key : keys)
+ copyInto.initInteger(key,
+ getInteger(key),
+ getDescription(INTEGER_PREFIX + key),
+ (VSPrefsRestriction.VSIntegerPrefsRestriction)
+ getRestriction(INTEGER_PREFIX + key),
+ getUnit(INTEGER_PREFIX + key));
+ }
+
+ /**
+ * Copies longs into another VSPrefs object.
+ *
+ * @param copyInto the copy into
+ * @param keys the keys
+ */
+ public void copyLongs(VSPrefs copyInto, String[] keys) {
+ for (String key : keys)
+ copyInto.initLong(key, getLong(key),
+ getDescription(LONG_PREFIX + key),
+ getUnit(LONG_PREFIX + key));
+ }
+
+ /**
+ * Copies floats into another VSPrefs object.
+ *
+ * @param copyInto the copy into
+ * @param keys the keys
+ */
+ public void copyFloats(VSPrefs copyInto, String[] keys) {
+ for (String key : keys)
+ copyInto.initFloat(key, getFloat(key),
+ getDescription(FLOAT_PREFIX + key),
+ getUnit(FLOAT_PREFIX + key));
+ }
+
+ /**
+ * Copies strings into another VSPrefs object.
+ *
+ * @param copyInto the copy into
+ * @param keys the keys
+ */
+ public void copyStrings(VSPrefs copyInto, String[] keys) {
+ for (String key : keys)
+ copyInto.initString(key, getString(key),
+ getDescription(STRING_PREFIX + key));
+ }
+
+ /**
+ * Copies color references into another VSPrefs object.
+ *
+ * @param copyInto the copy into
+ * @param keys the keys
+ */
+ public void copyColors(VSPrefs copyInto, String[] keys) {
+ for (String key : keys) {
+ Color color = getColor(key);
+ float comp[] = color.getComponents(null);
+ copyInto.initColor(key, new Color(comp[0], comp[1], comp[2]),
+ getDescription(COLOR_PREFIX + key));
+ }
+ }
+
+ /**
+ * Copies colors.
+ *
+ * @param copyInto the copy into
+ * @param keys the keys
+ */
+ public void copyBooleans(VSPrefs copyInto, String[] keys) {
+ for (String key : keys)
+ copyInto.initBoolean(key, getBoolean(key),
+ getDescription(BOOLEAN_PREFIX + key));
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#toString()
+ */
+ 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 = getVectorKeySet();
+ if (set.size() > 0) {
+ descr += VECTOR_PREFIX;
+ for (String key : set)
+ descr += key + "=" + getVector(key) + "; ";
+ }
+
+ set = getLongKeySet();
+ if (set.size() > 0) {
+ descr += LONG_PREFIX;
+ for (String key : set)
+ descr += key + "=" + getLong(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;
+ }
+
+ /**
+ * Gets the iD.
+ *
+ * @return the iD
+ */
+ public int getID() {
+ return id;
+ }
+
+ /**
+ * Checks if the prefs are empty.
+ *
+ * @return true, if empty
+ */
+ public boolean isEmpty() {
+ if (!colorPrefs.isEmpty())
+ return false;
+
+ if (!floatPrefs.isEmpty())
+ return false;
+
+ if (!integerPrefs.isEmpty())
+ return false;
+
+ if (!vectorPrefs.isEmpty())
+ return false;
+
+ if (!longPrefs.isEmpty())
+ return false;
+
+ if (!stringPrefs.isEmpty())
+ return false;
+
+ if (!booleanPrefs.isEmpty())
+ return false;
+
+ return true;
+ }
+
+ /**
+ * Returns all full keys.
+ *
+ * @return All full keys
+ */
+ public ArrayList<String> getAllFullKeys() {
+ ArrayList<String> allKeys = new ArrayList<String>();
+
+ Set<String> set = null;
+
+ set = getIntegerKeySet();
+ for (String key : set)
+ allKeys.add(INTEGER_PREFIX + key);
+
+ set = getVectorKeySet();
+ for (String key : set)
+ allKeys.add(VECTOR_PREFIX + key);
+
+ set = getLongKeySet();
+ for (String key : set)
+ allKeys.add(LONG_PREFIX + key);
+
+ set = getFloatKeySet();
+ for (String key : set)
+ allKeys.add(FLOAT_PREFIX + key);
+
+ set = getBooleanKeySet();
+ for (String key : set)
+ allKeys.add(BOOLEAN_PREFIX + key);
+
+ set = getStringKeySet();
+ for (String key : set)
+ allKeys.add(STRING_PREFIX + key);
+
+ Collections.sort(allKeys);
+
+ return allKeys;
+ }
+}
diff --git a/src/main/java/prefs/VSPrefsRestriction.java b/src/main/java/prefs/VSPrefsRestriction.java
new file mode 100644
index 0000000..27e828d
--- /dev/null
+++ b/src/main/java/prefs/VSPrefsRestriction.java
@@ -0,0 +1,137 @@
+package prefs;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.Vector;
+
+/**
+ * The class VSPrefsRestriction.
+ */
+abstract public class VSPrefsRestriction implements Serializable {
+ private static final long serialVersionUID = 2L;
+
+ /**
+ * The class VSIntegerPrefsRestriction.
+ */
+ public static class VSIntegerPrefsRestriction extends VSPrefsRestriction {
+ private static final long serialVersionUID = 2L;
+ /** The min value. */
+ private int minValue;
+
+ /** The max value. */
+ private int maxValue;
+
+ /**
+ * Instantiates a new integer setting restriction.
+ *
+ * @param minValue the min value
+ * @param maxValue the max value
+ */
+ public VSIntegerPrefsRestriction(int minValue, int maxValue) {
+ this.minValue = minValue;
+ this.maxValue = maxValue;
+ }
+
+ /**
+ * Gets the min value.
+ *
+ * @return the min value
+ */
+ public int getMinValue() {
+ return minValue;
+ }
+
+ /**
+ * Gets the max value.
+ *
+ * @return the max value
+ */
+ public int getMaxValue() {
+ return maxValue;
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.VSPrefsRestriction#writeObject(java.io.ObjectOutputStream)
+ */
+ public void writeObject(ObjectOutputStream out)
+ throws IOException {
+ out.writeObject(Integer.valueOf(minValue));
+ out.writeObject(Integer.valueOf(maxValue));
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.VSPrefsRestriction#readObject(java.io.ObjectInputStream)
+ */
+ public void readObject(ObjectInputStream in)
+ throws IOException, ClassNotFoundException {
+ minValue = ((Integer) in.readObject()).intValue();
+ maxValue = ((Integer) in.readObject()).intValue();
+ }
+ }
+
+ /**
+ * The class VSStringPrefsRestriction.
+ */
+ public static class VSStringPrefsRestriction extends VSPrefsRestriction {
+ private static final long serialVersionUID = 2L;
+
+ /** The possible selections. */
+ Vector<String> possibleSelections;
+
+ /**
+ * Instantiates a new string setting restriction.
+ *
+ * @param possibleSelections the possible selections
+ */
+ public VSStringPrefsRestriction(String [] possibleSelections) {
+ this.possibleSelections = new Vector<String>();
+
+ for (String elem : possibleSelections)
+ this.possibleSelections.add(elem);
+ }
+
+ /**
+ * Gets the possible selections.
+ *
+ * @return the possible selections
+ */
+ public Vector<String> getPossibleSelections() {
+ return possibleSelections;
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.VSPrefsRestriction#writeObject(java.io.ObjectOutputStream)
+ */
+ public void writeObject(ObjectOutputStream out)
+ throws IOException {
+ out.writeObject(possibleSelections);
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.VSPrefsRestriction#readObject(java.io.ObjectInputStream)
+ */
+ @SuppressWarnings("unchecked")
+ public void readObject(ObjectInputStream in)
+ throws IOException, ClassNotFoundException {
+ possibleSelections = (Vector<String>) in.readObject();
+ }
+ }
+
+ /**
+ * Serializes the object.
+ *
+ * @param out The output stream
+ */
+ abstract public void writeObject(ObjectOutputStream out)
+ throws IOException;
+
+ /**
+ * Deserializes the object.
+ *
+ * @param in The input stream
+ */
+ abstract public void readObject(ObjectInputStream in)
+ throws IOException, ClassNotFoundException;
+}
diff --git a/src/main/java/prefs/VSSerializablePrefs.java b/src/main/java/prefs/VSSerializablePrefs.java
new file mode 100644
index 0000000..b175b41
--- /dev/null
+++ b/src/main/java/prefs/VSSerializablePrefs.java
@@ -0,0 +1,37 @@
+package prefs;
+
+//import java.util.*;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+import serialize.VSSerializable;
+import serialize.VSSerialize;
+
+/**
+ * The class VSSerializablePrefs, this class is used if the VSPrefs should
+ * be serializable.
+ *
+ * @author Paul C. Buetow
+ */
+public class VSSerializablePrefs extends VSPrefs implements VSSerializable {
+ /* (non-Javadoc)
+ * @see serialize.VSSerializable#serialize(serialize.VSSerialize,
+ * java.io.ObjectOutputStream)
+ */
+ public synchronized void serialize(VSSerialize serialize,
+ ObjectOutputStream objectOutputStream)
+ throws IOException {
+ super.serialize_(serialize, objectOutputStream);
+ }
+
+ /* (non-Javadoc)
+ * @see serialize.VSSerializable#deserialize(serialize.VSSerialize,
+ * java.io.ObjectInputStream)
+ */
+ public synchronized void deserialize(VSSerialize serialize,
+ ObjectInputStream objectInputStream)
+ throws IOException, ClassNotFoundException {
+ super.deserialize_(serialize, objectInputStream);
+ }
+}
diff --git a/src/main/java/prefs/editors/VSAbstractBetterEditor.java b/src/main/java/prefs/editors/VSAbstractBetterEditor.java
new file mode 100644
index 0000000..87296b6
--- /dev/null
+++ b/src/main/java/prefs/editors/VSAbstractBetterEditor.java
@@ -0,0 +1,101 @@
+package prefs.editors;
+
+import java.awt.Color;
+import java.awt.Container;
+import java.awt.event.ActionEvent;
+
+import javax.swing.BoxLayout;
+import javax.swing.JPanel;
+
+import prefs.VSPrefs;
+
+/**
+ * The class VSAbstractBetterEditor, is an improved VSAbstractEditor.
+ *
+ * @author Paul C. Buetow
+ */
+public abstract class VSAbstractBetterEditor extends VSAbstractEditor {
+ /** The content pane. */
+ private Container contentPane;
+
+ /** The title. */
+ private String title;
+
+ /**
+ * An simple constructor.
+ *
+ * @param prefs the prefs
+ * @param prefsToEdit the prefs to edit
+ * @param title the title
+ */
+ public VSAbstractBetterEditor(VSPrefs prefs, VSPrefs prefsToEdit,
+ String title) {
+ super(prefs, prefsToEdit);
+ this.title = title;
+ this.contentPane = createContentPane();
+ }
+
+ /**
+ * Gets the title.
+ *
+ * @return the title
+ */
+ public String getTitle() {
+ return title;
+ }
+
+ /**
+ * Gets the content pane.
+ *
+ * @return the content pane
+ */
+ public Container getContentPane() {
+ contentPane.setBackground(Color.WHITE);
+ return contentPane;
+ }
+
+ /**
+ * Creates the content pane.
+ *
+ * @return the j panel
+ */
+ private JPanel createContentPane() {
+ JPanel panel = new JPanel();
+ panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
+
+ JPanel editPanel = getEditPanel();
+ JPanel buttonPanel = getButtonPanel();
+
+ panel.add(editPanel);
+ panel.add(buttonPanel);
+
+ return panel;
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractEditor#addToButtonPanelFront(
+ * javax.swing.JPanel)
+ */
+ protected void addToButtonPanelFront(JPanel buttonPanel) { }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractEditor#addToButtonPanelLast(
+ * javax.swing.JPanel)
+ */
+ protected void addToButtonPanelLast(JPanel buttonPanel) { }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractEditor#addToEditTableLast()
+ */
+ protected void addToEditTableLast() { }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractEditor#actionPerformed(
+ * java.awt.event.ActionEvent)
+ */
+ public void actionPerformed(ActionEvent e) {
+ //String actionCommand = e.getActionCommand();
+ /* More action in the super class!!! */
+ super.actionPerformed(e);
+ }
+}
diff --git a/src/main/java/prefs/editors/VSAbstractEditor.java b/src/main/java/prefs/editors/VSAbstractEditor.java
new file mode 100644
index 0000000..266b62c
--- /dev/null
+++ b/src/main/java/prefs/editors/VSAbstractEditor.java
@@ -0,0 +1,1056 @@
+package prefs.editors;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.GridBagLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Set;
+import java.util.Vector;
+
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextField;
+
+import prefs.VSPrefs;
+import prefs.VSPrefsRestriction;
+import utils.VS3Tupel;
+import utils.VSFrame;
+
+/**
+ * The class VSAbstractEditor, an object of this class is used in order to
+ * edit a VSPrefs object.
+ *
+ * @author Paul C. Buetow
+ */
+public abstract class VSAbstractEditor implements ActionListener {
+ /** The boolean keys. */
+ private ArrayList<String> booleanKeys;
+
+ /** The color keys. */
+ private ArrayList<String> colorKeys;
+
+ /** The float keys. */
+ private ArrayList<String> floatKeys;
+
+ /** The integer keys. */
+ private ArrayList<String> integerKeys;
+
+ /** The vector keys. */
+ private ArrayList<String> vectorKeys;
+
+ /** The long keys. */
+ private ArrayList<String> longKeys;
+
+ /** The string keys. */
+ private ArrayList<String> stringKeys;
+
+ /** The boolean fields. */
+ private HashMap<String,JCheckBox> booleanFields;
+
+ /** The integer fields. */
+ private HashMap<String,JComboBox<Integer>> integerFields;
+
+ /** The vector fields. */
+ private HashMap<String,JTextField> vectorFields;
+
+ /** The color fields. */
+ private HashMap<String,JTextField> colorFields;
+
+ /** The float fields. */
+ private HashMap<String,JTextField> floatFields;
+
+ /** The long fields. */
+ private HashMap<String,JTextField> longFields;
+
+ /** The string fields. */
+ private HashMap<String,JTextField> stringFields;
+
+ /** The prefs to edit map. */
+ private HashMap<String,VSPrefs> prefsToEditMap;
+
+ /** The button panel. */
+ private JPanel buttonPanel;
+
+ /** The edit panel. */
+ private JPanel editPanel;
+
+ /** The edit table. */
+ private VSEditorTable editTable;
+
+ /** The frame. */
+ private VSFrame frame;
+
+ /** The expert mode changed. */
+ private boolean expertModeChanged;
+
+ /** The prefs. */
+ protected VSPrefs prefs;
+
+ /** The prefs to edit. */
+ protected VSPrefs prefsToEdit;
+
+ /** The Constant MIN_UNIT_LENGTH. */
+ protected static final int MIN_UNIT_LENGTH = 5;
+
+ /** The Constant VALUE_FIELD_COLS. */
+ protected static final int VALUE_FIELD_COLS = 9;
+
+ /** The Constant ALL_PREFERENCES. */
+ public static final int ALL_PREFERENCES = 0;
+
+ /** The Constant SIMULATION_PREFERENCES. */
+ public static final int SIMULATION_PREFERENCES = 1;
+
+ /**
+ * The standard constructor.
+ *
+ * @param prefs the prefs
+ * @param prefsToEdit the prefs to edit
+ */
+ public VSAbstractEditor(VSPrefs prefs, VSPrefs prefsToEdit) {
+ init(prefs, prefsToEdit);
+ }
+
+ /**
+ * Adds components to the front of the button panel .
+ *
+ * @param buttonPanel the button panel
+ */
+ abstract protected void addToButtonPanelFront(JPanel buttonPanel);
+
+ /**
+ * Adds components to last of the button panel.
+ *
+ * @param buttonPanel the button panel
+ */
+ abstract protected void addToButtonPanelLast(JPanel buttonPanel);
+
+ /**
+ * Adds the to edit table last.
+ */
+ abstract protected void addToEditTableLast();
+
+ /**
+ * Sets the default prefs.
+ *
+ * @param prefs the new prefs
+ */
+ public void setPrefs(VSPrefs prefs) {
+ this.prefs = prefs;
+ }
+
+ /**
+ * Sets the prefs to edit.
+ *
+ * @param prefsToEdit the new prefs to edit
+ */
+ public void setPrefsToEdit(VSPrefs prefsToEdit) {
+ this.prefsToEdit = prefsToEdit;
+ }
+
+ /**
+ * Sets the frame being used by the editor, if any.
+ *
+ * @param frame the new frame
+ */
+ public void setFrame(VSFrame frame) {
+ this.frame = frame;
+ }
+
+ /**
+ * Gets the frame.
+ *
+ * @return the frame
+ */
+ public VSFrame getFrame() {
+ return frame;
+ }
+
+ /**
+ * The given editors frame will get disposed if the "OK" button has been
+ * pressed. This can only happen if the editor has its own frame.
+ */
+ protected void disposeFrameIfExists() {
+ if (frame != null)
+ frame.dispose();
+ }
+
+ /**
+ * The given editors frame will get disposed if its parent component
+ * disposes. This can only happen if the editor has its own frame.
+ */
+ protected void disposeFrameWithParentIfExists() {
+ if (frame != null)
+ frame.disposeWithParent();
+ }
+
+ /**
+ * Inits the editor.
+ *
+ * @param prefs the prefs
+ * @param prefsToEdit the prefs to edit
+ */
+ private void init(VSPrefs prefs, VSPrefs prefsToEdit) {
+ this.prefs = prefs;
+ this.prefsToEdit = prefsToEdit;
+
+ editPanel = createEditPanel();
+ buttonPanel = createButtonPanel();
+
+ prefsToEditMap = new HashMap<String,VSPrefs>();
+
+ colorFields = new HashMap<String,JTextField>();
+ floatFields = new HashMap<String,JTextField>();
+ integerFields = new HashMap<String,JComboBox<Integer>>();
+ vectorFields = new HashMap<String,JTextField>();
+ longFields = new HashMap<String,JTextField>();
+ booleanFields = new HashMap<String,JCheckBox>();
+ stringFields = new HashMap<String,JTextField>();
+
+ colorKeys = filterKeys(prefsToEdit.getColorKeySet());
+ floatKeys = filterKeys(prefsToEdit.getFloatKeySet());
+ integerKeys = filterKeys(prefsToEdit.getIntegerKeySet());
+ vectorKeys = filterKeys(prefsToEdit.getVectorKeySet());
+ longKeys = filterKeys(prefsToEdit.getLongKeySet());
+ booleanKeys = filterKeys(prefsToEdit.getBooleanKeySet());
+ stringKeys = filterKeys(prefsToEdit.getStringKeySet());
+
+ fillEditPanelFront(prefsToEdit);
+ fillEditPanel(prefsToEdit);
+ }
+
+ /**
+ * Filters out all keys to edit.
+ *
+ * @param set the set which contains all keys of a given hash
+ *
+ * @return the filtered keys
+ */
+ private ArrayList<String> filterKeys(Set<String> set) {
+ ArrayList<String> filtered = new ArrayList<String>();
+ boolean expertMode = prefs.getBoolean("sim.mode.expert");
+
+ for (String elem : set) {
+ if (!elem.startsWith("lang.") && !elem.startsWith("keyevent.")) {
+ if (expertMode)
+ filtered.add(elem);
+ else if (!elem.startsWith("col.") && (!elem.startsWith("div.")))
+ filtered.add(elem);
+ }
+ }
+
+ return filtered;
+ }
+
+ /**
+ * Creates the button panel.
+ *
+ * @return the panel
+ */
+ private JPanel createButtonPanel() {
+ JPanel buttonPanel = new JPanel();
+ buttonPanel.setBackground(Color.WHITE);
+ addToButtonPanelFront(buttonPanel);
+
+ JButton resetButton = new JButton(
+ prefs.getString("lang.reset"));
+ resetButton.setMnemonic(prefs.getInteger("keyevent.reset"));
+ resetButton.addActionListener(this);
+ buttonPanel.add(resetButton);
+
+ addToButtonPanelLast(buttonPanel);
+
+ return buttonPanel;
+ }
+
+ /**
+ * Creates the unit panel.
+ *
+ * @param comp the comp
+ * @param key the key
+ *
+ * @return the panel
+ */
+ private JPanel createUnitPanel(VSPrefs prefsToEdit, Component comp,
+ String fullKey) {
+ JPanel unitPanel = new JPanel(new GridBagLayout());
+ unitPanel.setBackground(Color.WHITE);
+ unitPanel.setBorder(null);
+
+ String unitText = prefsToEdit.getUnit(fullKey);
+ if (unitText == null)
+ unitText = "";
+
+ unitText = " " + unitText;
+ while (unitText.length() < MIN_UNIT_LENGTH)
+ unitText = unitText + " ";
+ JLabel unitLabel = new JLabel(unitText);
+
+ unitPanel.setLayout(new BoxLayout(unitPanel, BoxLayout.X_AXIS));
+ unitPanel.add(comp);
+ unitPanel.add(unitLabel);
+
+ return unitPanel;
+ }
+
+ /**
+ * Creates the edit panel.
+ *
+ * @return the panel
+ */
+ private JPanel createEditPanel() {
+ JPanel editPanel = new JPanel();
+ editPanel.setLayout(new BoxLayout(editPanel, BoxLayout.Y_AXIS));
+ editPanel.setBackground(Color.WHITE);
+
+ editTable = new VSEditorTable(prefs);
+ JScrollPane scrollPane = new JScrollPane(editTable);
+ editPanel.add(scrollPane);
+
+ return editPanel;
+ }
+
+ /**
+ * Creates the integer component.
+ *
+ * @param fullKey the full key
+ * @param key the key
+ * @param prefsToEdit the prefs to edit
+ *
+ * @return the tupel representing the component
+ */
+ protected VS3Tupel<String,Component,JComboBox<Integer>> createIntegerComponent(
+ String fullKey, String key, VSPrefs prefsToEdit) {
+ String descr = prefs.getDescription(fullKey);
+ if (descr == null)
+ descr = prefsToEdit.getDescription(fullKey);
+ String label = descr == null ? fullKey : descr;
+ Integer integer = prefsToEdit.getInteger(key);
+ Integer initialSelection[] = { integer };
+ JComboBox<Integer> valComboBox = new JComboBox<>(initialSelection);
+ VSPrefsRestriction settingRestriction =
+ prefsToEdit.getRestriction(fullKey);
+
+ int minValue, maxValue;
+ if (settingRestriction != null) {
+ VSPrefsRestriction.VSIntegerPrefsRestriction
+ integerVSPrefsRestriction =
+ (VSPrefsRestriction.VSIntegerPrefsRestriction)
+ settingRestriction;
+ minValue = integerVSPrefsRestriction.getMinValue();
+ maxValue = integerVSPrefsRestriction.getMaxValue();
+
+ } else {
+ minValue = 0;
+ maxValue = 100;
+ }
+
+ for (int i = minValue; i <= maxValue; ++i)
+ valComboBox.addItem(Integer.valueOf(i));
+ valComboBox.setBorder(null);
+
+ return new VS3Tupel<String,Component,JComboBox<Integer>>(label,
+ createUnitPanel(prefsToEdit, valComboBox, fullKey),
+ valComboBox);
+ }
+
+ /**
+ * Creates the vector component.
+ *
+ * @param fullKey the full key
+ * @param key the key
+ * @param prefsToEdit the prefs to edit
+ *
+ * @return the tupel representing the component
+ */
+ protected VS3Tupel<String,Component,JTextField> createVectorComponent(
+ String fullKey, String key, VSPrefs prefsToEdit) {
+ String descr = prefs.getDescription(fullKey);
+ if (descr == null)
+ descr = prefsToEdit.getDescription(fullKey);
+ String label = descr == null ? fullKey : descr;
+
+ Vector<Integer> vec = prefsToEdit.getVector(key);
+ JTextField valField = new JTextField();
+ valField.setBorder(null);
+ valField.setText(vec.toString());
+
+ return new VS3Tupel<String,Component,JTextField>(label,
+ createUnitPanel(prefsToEdit, valField, fullKey), valField);
+ }
+
+ /**
+ * Creates the boolean component.
+ *
+ * @param fullKey the full key
+ * @param key the key
+ * @param prefsToEdit the prefs to edit
+ */
+ protected VS3Tupel<String,Component,JCheckBox> createBooleanComponent(
+ String fullKey, String key, VSPrefs prefsToEdit) {
+ final String activated = prefs.getString("lang.activated");
+ String descr = prefs.getDescription(fullKey);
+ if (descr == null)
+ descr = prefsToEdit.getDescription(fullKey);
+ String label = descr == null ? fullKey : descr;
+ JCheckBox valField = new JCheckBox(activated,
+ prefsToEdit.getBoolean(key));
+ valField.setBackground(Color.WHITE);
+ valField.setBorder(null);
+ return new VS3Tupel<String,Component,JCheckBox>(label,
+ createUnitPanel(prefsToEdit, valField, fullKey), valField);
+ }
+
+ /**
+ * Creates the long component.
+ *
+ * @param fullKey the full key
+ * @param key the key
+ * @param prefsToEdit the prefs to edit
+ *
+ * @return the tupel representing the component
+ */
+ protected VS3Tupel<String,Component,JTextField> createLongComponent(
+ String fullKey, String key, VSPrefs prefsToEdit) {
+ String descr = prefs.getDescription(fullKey);
+ if (descr == null)
+ descr = prefsToEdit.getDescription(fullKey);
+ String label = descr == null ? fullKey : descr;
+ JTextField valField = new JTextField(VALUE_FIELD_COLS);
+ valField.addKeyListener(new java.awt.event.KeyAdapter() {
+ public void keyTyped(java.awt.event.KeyEvent e) {
+ JTextField valField = (JTextField)e.getSource();
+ if (valField.getText().length() >= valField.getColumns() + 10)
+ e.consume();
+ }
+ });
+ valField.setText(""+prefsToEdit.getLong(key));
+ valField.setBorder(null);
+ return new VS3Tupel<String,Component,JTextField>(label,
+ createUnitPanel(prefsToEdit, valField, fullKey), valField);
+ }
+
+ /**
+ * Creates the float component.
+ *
+ * @param fullKey the full key
+ * @param key the key
+ * @param prefsToEdit the prefs to edit
+ *
+ * @return the tupel representing the component
+ */
+ protected VS3Tupel<String,Component,JTextField> createFloatComponent(
+ String fullKey, String key, VSPrefs prefsToEdit) {
+ String descr = prefs.getDescription(fullKey);
+ if (descr == null)
+ descr = prefsToEdit.getDescription(fullKey);
+ String label = descr == null ? fullKey : descr;
+ JTextField valField = new JTextField(VALUE_FIELD_COLS);
+ valField.addKeyListener(new java.awt.event.KeyAdapter() {
+ public void keyTyped(java.awt.event.KeyEvent e) {
+ JTextField valField = (JTextField)e.getSource();
+ if (valField.getText().length() >= valField.getColumns() + 10)
+ e.consume();
+ }
+ });
+ valField.setText(""+prefsToEdit.getFloat(key));
+ valField.setBorder(null);
+ return new VS3Tupel<String,Component,JTextField>(label,
+ createUnitPanel(prefsToEdit, valField, fullKey), valField);
+ }
+
+ /**
+ * Creates the color component.
+ *
+ * @param fullKey the full key
+ * @param key the key
+ * @param prefsToEdit the prefs to edit
+ *
+ * @return the tupel representing the component
+ */
+ protected VS3Tupel<String,Component,JTextField> createColorComponent(
+ String fullKey, String key, final VSPrefs prefsToEdit) {
+ String descr = prefs.getDescription(fullKey);
+ if (descr == null)
+ descr = prefsToEdit.getDescription(fullKey);
+ String label = descr == null ? fullKey : descr;
+ final JTextField valField = new JTextField(VALUE_FIELD_COLS);
+ Color color = prefsToEdit.getColor(key);
+ valField.setBackground(color);
+ valField.setEditable(false);
+ valField.addMouseListener(new MouseListener() {
+ public void mouseExited(MouseEvent e) { }
+ public void mouseReleased(MouseEvent e) { }
+ public void mouseEntered(MouseEvent e) { }
+ public void mousePressed(MouseEvent e) { }
+ public void mouseClicked(MouseEvent e) {
+ JFrame parentFrame = getFrame();
+ JFrame frame = new VSFrame(
+ prefs.getString("lang.name") + " - " +
+ prefs.getString(
+ "lang.colorchooser"),parentFrame);
+ frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+
+ JComponent colorChooserPane = new VSColorChooser(prefs,
+ valField);
+ colorChooserPane.setOpaque(true);
+
+ frame.setContentPane(colorChooserPane);
+ frame.pack();
+ frame.setVisible(true);
+ }
+ });
+ valField.setBorder(null);
+ return new VS3Tupel<String,Component,JTextField>(label,
+ createUnitPanel(prefsToEdit, valField, fullKey), valField);
+ }
+
+ /**
+ * Creates the string component.
+ *
+ * @param fullKey the full key
+ * @param key the key
+ * @param prefsToEdit the prefs to edit
+ *
+ * @return the tupel representing the component
+ */
+ protected VS3Tupel<String,Component,JTextField> createStringComponent(
+ String fullKey, String key, VSPrefs prefsToEdit) {
+ String descr = prefs.getDescription(fullKey);
+ if (descr == null)
+ descr = prefsToEdit.getDescription(fullKey);
+ String label = descr == null ? fullKey : descr;
+ JTextField valField = new JTextField(VALUE_FIELD_COLS);
+ valField.addKeyListener(new java.awt.event.KeyAdapter() {
+ public void keyTyped(java.awt.event.KeyEvent e) {
+ JTextField valField = (JTextField)e.getSource();
+ if (valField.getText().length() >= valField.getColumns() + 10)
+ e.consume();
+ }
+ });
+ valField.setText(prefsToEdit.getString(key));
+ valField.setBorder(null);
+ return new VS3Tupel<String,Component,JTextField>(label,
+ createUnitPanel(prefsToEdit, valField, fullKey), valField);
+ }
+
+ /**
+ * Fills the edit panel at the front. May be overloaded by another class.
+ *
+ * @param prefsToEdit the prefs to edit
+ */
+ protected void fillEditPanelFront(VSPrefs prefsToEdit) {
+ }
+
+ /**
+ * Fills the edit panel.
+ *
+ * @param prefsToEdit the prefs to edit
+ */
+ private void fillEditPanel(VSPrefs prefsToEdit) {
+ HashMap<String,Component> components = new HashMap<String,Component>();
+ HashMap<String,String> labels = new HashMap<String,String>();
+
+ for (String key : integerKeys) {
+ String fullKey = VSPrefs.INTEGER_PREFIX + key;
+ VS3Tupel<String,Component,JComboBox<Integer>> tupel =
+ createIntegerComponent(fullKey, key, prefsToEdit);
+ labels.put(fullKey, tupel.getA());
+ components.put(fullKey, tupel.getB());
+ integerFields.put(key, tupel.getC());
+ }
+
+ for (String key : vectorKeys) {
+ String fullKey = VSPrefs.VECTOR_PREFIX + key;
+ VS3Tupel<String,Component,JTextField> tupel =
+ createVectorComponent(fullKey, key, prefsToEdit);
+ labels.put(fullKey, tupel.getA());
+ components.put(fullKey, tupel.getB());
+ vectorFields.put(key, tupel.getC());
+ }
+
+ for (String key : booleanKeys) {
+ String fullKey = VSPrefs.BOOLEAN_PREFIX + key;
+ VS3Tupel<String,Component,JCheckBox> tupel =
+ createBooleanComponent(fullKey, key, prefsToEdit);
+ labels.put(fullKey, tupel.getA());
+ components.put(fullKey, tupel.getB());
+ booleanFields.put(key, tupel.getC());
+ }
+
+ for (String key : longKeys) {
+ String fullKey = VSPrefs.LONG_PREFIX + key;
+ VS3Tupel<String,Component,JTextField> tupel =
+ createLongComponent(fullKey, key, prefsToEdit);
+ labels.put(fullKey, tupel.getA());
+ components.put(fullKey, tupel.getB());
+ longFields.put(key, tupel.getC());
+ }
+
+
+ for (String key : floatKeys) {
+ String fullKey = VSPrefs.FLOAT_PREFIX + key;
+ VS3Tupel<String,Component,JTextField> tupel =
+ createFloatComponent(fullKey, key, prefsToEdit);
+ labels.put(fullKey, tupel.getA());
+ components.put(fullKey, tupel.getB());
+ floatFields.put(key, tupel.getC());
+ }
+
+
+ for (String key : colorKeys) {
+ String fullKey = VSPrefs.COLOR_PREFIX + key;
+ VS3Tupel<String,Component,JTextField> tupel =
+ createColorComponent(fullKey, key, prefsToEdit);
+ labels.put(fullKey, tupel.getA());
+ components.put(fullKey, tupel.getB());
+ colorFields.put(key, tupel.getC());
+ }
+
+ for (String key : stringKeys) {
+ String fullKey = VSPrefs.STRING_PREFIX + key;
+ VS3Tupel<String,Component,JTextField> tupel =
+ createStringComponent(fullKey, key, prefsToEdit);
+ labels.put(fullKey, tupel.getA());
+ components.put(fullKey, tupel.getB());
+ stringFields.put(key, tupel.getC());
+ }
+
+ ArrayList<String> fullKeys = new ArrayList<String>();
+ fullKeys.addAll(components.keySet());
+ Collections.sort(fullKeys);
+
+ boolean flag = false;
+ for (String fullKey : fullKeys) {
+ String key = fullKey.substring(fullKey.indexOf(' ')+1);
+ if (key.startsWith("sim.")) {
+ if (!flag) {
+ flag = true;
+ addSeparator(prefs.getString("lang.prefs.simulator"));
+ }
+ addVariable(labels.get(fullKey), components.get(fullKey),
+ prefsToEdit);
+ }
+ }
+
+ flag = false;
+ for (String fullKey : fullKeys) {
+ String key = fullKey.substring(fullKey.indexOf(' ')+1);
+ if (key.startsWith("process.")) {
+ if (!flag) {
+ flag = true;
+ if (this instanceof VSProcessEditor)
+ addSeparator(prefs.getString("lang.prefs.process"));
+ else
+ addSeparator(prefs.getString(
+ "lang.prefs.process.defaults"));
+ }
+ addVariable(labels.get(fullKey), components.get(fullKey),
+ prefsToEdit);
+ }
+ }
+
+ flag = false;
+ for (String fullKey : fullKeys) {
+ String key = fullKey.substring(fullKey.indexOf(' ')+1);
+ if (key.startsWith("message.")) {
+ if (!flag) {
+ flag = true;
+ if (this instanceof VSProcessEditor)
+ addSeparator(prefs.getString(
+ "lang.prefs.message"));
+ else
+ addSeparator(prefs.getString(
+ "lang.prefs.message.defaults"));
+ }
+ addVariable(labels.get(fullKey), components.get(fullKey),
+ prefsToEdit);
+ }
+ }
+
+ flag = false;
+ for (String fullKey : fullKeys) {
+ String key = fullKey.substring(fullKey.indexOf(' ')+1);
+ if (key.startsWith("col.")) {
+ if (!flag) {
+ flag = true;
+ addSeparator(prefs.getString("lang.prefs.color"));
+ }
+ addVariable(labels.get(fullKey), components.get(fullKey),
+ prefsToEdit);
+ }
+ }
+
+ flag = false;
+ for (String fullKey : fullKeys) {
+ String key = fullKey.substring(fullKey.indexOf(' ')+1);
+ if (key.startsWith("div.")) {
+ if (!flag) {
+ flag = true;
+ addSeparator(prefs.getString("lang.prefs.diverse"));
+ }
+ addVariable(labels.get(fullKey), components.get(fullKey),
+ prefsToEdit);
+ }
+ }
+
+ addToEditTableLast();
+ editTable.fireTableDataChanged();
+ }
+
+ /**
+ * Filters out stuff.
+ *
+ * @param set The set to filter stuff out from
+ * @param filter Only return elemens of the filter which are in the set
+ * @param prefix The prefix to use
+ *
+ * @return The filtered keys
+ */
+ private ArrayList<String> filterOut(Set<String> set,
+ ArrayList<String> filter,
+ String prefix) {
+ ArrayList<String> ret = new ArrayList<String>();
+
+ for (String key : set) {
+ String fullKey = prefix + key;
+ if (filter.contains(fullKey))
+ ret.add(fullKey);
+ }
+
+ return ret;
+ }
+
+ /**
+ * Adds the to editor more variables.
+ *
+ * @param label the label
+ * @param prefsKey the prefs key
+ * @param prefsToAdd the prefs to add
+ * @param addOnlyThisVariables only add variables which are in this list
+ */
+ protected void addToEditor(String label, String prefsKey,
+ VSPrefs prefsToAdd,
+ ArrayList<String> addOnlyThisVariables) {
+ addSeparator(label);
+ prefsKey = "(" + prefsKey + ")";
+
+ ArrayList<String> fullKeys = new ArrayList<String>();
+
+ fullKeys.addAll(filterOut(prefsToAdd.getIntegerKeySet(),
+ addOnlyThisVariables,
+ VSPrefs.INTEGER_PREFIX));
+ fullKeys.addAll(filterOut(prefsToAdd.getVectorKeySet(),
+ addOnlyThisVariables,
+ VSPrefs.VECTOR_PREFIX));
+ fullKeys.addAll(filterOut(prefsToAdd.getFloatKeySet(),
+ addOnlyThisVariables,
+ VSPrefs.FLOAT_PREFIX));
+ fullKeys.addAll(filterOut(prefsToAdd.getLongKeySet(),
+ addOnlyThisVariables,
+ VSPrefs.LONG_PREFIX));
+ fullKeys.addAll(filterOut(prefsToAdd.getBooleanKeySet(),
+ addOnlyThisVariables,
+ VSPrefs.BOOLEAN_PREFIX));
+ fullKeys.addAll(filterOut(prefsToAdd.getStringKeySet(),
+ addOnlyThisVariables,
+ VSPrefs.STRING_PREFIX));
+
+ Collections.sort(fullKeys);
+
+ for (String fullKey : fullKeys) {
+ String key = fullKey.substring(fullKey.indexOf(": ") + 2);
+ if (fullKey.startsWith(VSPrefs.INTEGER_PREFIX)) {
+ VS3Tupel<String,Component,JComboBox<Integer>> tupel =
+ createIntegerComponent(fullKey, key, prefsToAdd);
+ this.integerKeys.add(prefsKey+key);
+ this.integerFields.put(prefsKey+key, tupel.getC());
+ addVariable(prefsKey, tupel.getA(), tupel.getB(), prefsToAdd);
+
+ } else if (fullKey.startsWith(VSPrefs.VECTOR_PREFIX)) {
+ VS3Tupel<String,Component,JTextField> tupel =
+ createVectorComponent(fullKey, key, prefsToAdd);
+ this.vectorKeys.add(prefsKey+key);
+ this.vectorFields.put(prefsKey+key, tupel.getC());
+ addVariable(prefsKey, tupel.getA(), tupel.getB(), prefsToAdd);
+
+ } else if (fullKey.startsWith(VSPrefs.BOOLEAN_PREFIX)) {
+ VS3Tupel<String,Component,JCheckBox> tupel =
+ createBooleanComponent(fullKey, key, prefsToAdd);
+ this.booleanKeys.add(prefsKey + key);
+ this.booleanFields.put(prefsKey+key, tupel.getC());
+ addVariable(prefsKey, tupel.getA(), tupel.getB(), prefsToAdd);
+
+ } else if (fullKey.startsWith(VSPrefs.LONG_PREFIX)) {
+ VS3Tupel<String,Component,JTextField> tupel =
+ createLongComponent(fullKey, key, prefsToAdd);
+ this.longKeys.add(prefsKey+key);
+ this.longFields.put(prefsKey+key, tupel.getC());
+ addVariable(prefsKey, tupel.getA(), tupel.getB(), prefsToAdd);
+
+ } else if (fullKey.startsWith(VSPrefs.FLOAT_PREFIX)) {
+ VS3Tupel<String,Component,JTextField> tupel =
+ createFloatComponent(fullKey, key, prefsToAdd);
+ this.floatKeys.add(prefsKey + key);
+ this.floatFields.put(prefsKey+key, tupel.getC());
+ addVariable(prefsKey, tupel.getA(), tupel.getB(), prefsToAdd);
+
+ } else if (fullKey.startsWith(VSPrefs.STRING_PREFIX)) {
+ VS3Tupel<String,Component,JTextField> tupel =
+ createStringComponent(fullKey, key, prefsToAdd);
+ this.stringKeys.add(prefsKey + key);
+ this.stringFields.put(prefsKey+key, tupel.getC());
+ addVariable(prefsKey, tupel.getA(), tupel.getB(), prefsToAdd);
+ }
+ }
+ }
+
+ /**
+ * Adds a separator.
+ *
+ * @param label the label
+ */
+ protected void addSeparator(String label) {
+ editTable.addSeparator(label);
+ }
+
+ /**
+ * Adds a variable.
+ *
+ * @param label the label
+ * @param component the component
+ * @param prefs the prefs
+ */
+ private void addVariable(String label, Component component, VSPrefs prefs) {
+ addVariable("", label, component, prefs);
+ }
+
+ /**
+ * Adds a variable.
+ *
+ * @param prefsKey the prefs key
+ * @param label the label
+ * @param component the component
+ * @param prefs the prefs
+ */
+ private void addVariable(String prefsKey, String label,
+ Component component, VSPrefs prefs) {
+ prefsToEditMap.put(prefsKey, prefs);
+ editTable.addVariable(label, component);
+ }
+
+ /**
+ * Reset edit panel.
+ */
+ protected void resetPrefs() {
+ for (String key : integerKeys) {
+ JComboBox<Integer> valComboBox = integerFields.get(key);
+ valComboBox.setSelectedIndex(0);
+ }
+
+ for (String key : booleanKeys) {
+ String keys[] = getKeys(key);
+ JCheckBox valField = booleanFields.get(key);
+ valField.setSelected(prefsToEditMap.get(
+ keys[1]).getBoolean(keys[0]));
+ }
+
+ for (String key : vectorKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = vectorFields.get(key);
+ valField.setText(""+prefsToEditMap.get(keys[1]).getVector(keys[0]));
+ }
+
+ for (String key : floatKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = floatFields.get(key);
+ valField.setText(""+prefsToEditMap.get(keys[1]).getFloat(keys[0]));
+ }
+
+ for (String key : longKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = longFields.get(key);
+ valField.setText(""+prefsToEditMap.get(keys[1]).getLong(keys[0]));
+ }
+
+ for (String key : colorKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = colorFields.get(key);
+ valField.setBackground(prefsToEditMap.get(
+ keys[1]).getColor(keys[0]));
+ }
+
+ for (String key : stringKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = stringFields.get(key);
+ valField.setText(prefsToEditMap.get(keys[1]).getString(keys[0]));
+ }
+ }
+
+ /**
+ * Gets the keys.
+ *
+ * @param key the key
+ *
+ * @return [0] := key, [1] := prefsKey
+ */
+ private String[] getKeys(String key) {
+ String keys[] = { key, "" };
+
+ if (key.startsWith("(")) {
+ keys[1] = key.substring(0, key.indexOf(")") + 1);
+ keys[0] = key.substring(key.indexOf(")")+1);
+ }
+
+ return keys;
+ }
+
+ /**
+ * Saves the prefs.
+ */
+ protected void savePrefs() {
+ boolean expertMode = prefs.getBoolean("sim.mode.expert");
+
+ for (String key : integerKeys) {
+ String keys[] = getKeys(key);
+ JComboBox<Integer> valComboBox = integerFields.get(key);
+ prefsToEditMap.get(
+ keys[1]).setInteger(keys[0],
+ (Integer) valComboBox.getSelectedItem());
+ }
+
+ for (String key : vectorKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = vectorFields.get(key);
+
+ try {
+ String val = valField.getText();
+ Vector<Integer> vec = utils.VSTools.parseIntegerVector(val);
+ prefsToEditMap.get(keys[1]).setVector(keys[0], vec);
+ } catch (exceptions.VSParseIntegerVectorException e) {
+ }
+
+ valField.setText(""+
+ prefsToEditMap.get(keys[1]).getVector(keys[0]));
+ }
+
+ for (String key : booleanKeys) {
+ String keys[] = getKeys(key);
+ JCheckBox valField = booleanFields.get(key);
+ prefsToEditMap.get(keys[1]).setBoolean(
+ keys[0], valField.isSelected());
+ }
+
+ for (String key : floatKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = floatFields.get(key);
+
+ try {
+ Float val = Float.valueOf(valField.getText());
+ prefsToEditMap.get(keys[1]).setFloat(keys[0], val);
+
+ } catch (NumberFormatException e) {
+ valField.setText(""+
+ prefsToEditMap.get(keys[1]).getFloat(keys[0]));
+ }
+ }
+
+ for (String key : longKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = longFields.get(key);
+
+ try {
+ Long val = Long.valueOf(valField.getText());
+ prefsToEditMap.get(keys[1]).setLong(keys[0], val);
+
+ } catch (NumberFormatException e) {
+ valField.setText(""+
+ prefsToEditMap.get(keys[1]).getLong(keys[0]));
+ }
+ }
+
+ for (String key : colorKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = colorFields.get(key);
+ prefsToEditMap.get(keys[1]).setColor(
+ keys[0], valField.getBackground());
+ }
+
+ for (String key : stringKeys) {
+ String keys[] = getKeys(key);
+ JTextField valField = stringFields.get(key);
+ prefsToEditMap.get(keys[1]).setString(keys[0], valField.getText());
+ }
+
+ expertModeChanged = expertMode != prefs.getBoolean("sim.mode.expert");
+ }
+
+ /**
+ * Check if the expert mode has changed.
+ *
+ * @return true, if it has changed. false, if it has not changed.
+ */
+ public boolean expertModeChanged() {
+ boolean ret = expertModeChanged;
+
+ if (expertModeChanged)
+ expertModeChanged = false;
+
+ return ret;
+ }
+
+ /* (non-Javadoc)
+ * @see java.awt.event.ActionListener#actionPerformed(
+ * java.awt.event.ActionEvent)
+ */
+ public void actionPerformed(ActionEvent e) {
+ String actionCommand = e.getActionCommand();
+
+ if (actionCommand.equals(prefs.getString("lang.takeover"))) {
+ savePrefs();
+
+ } else if (actionCommand.equals(prefs.getString("lang.reset"))) {
+ resetPrefs();
+ }
+ }
+
+ /**
+ * Gets the edit panel
+ *
+ * @return the edit panel
+ */
+ public JPanel getEditPanel() {
+ return editPanel;
+ }
+
+ /**
+ * Gets the edit table
+ *
+ * @return the edit table
+ */
+ public VSEditorTable getEditTable() {
+ return editTable;
+ }
+
+ /**
+ * Gets the button panel.
+ *
+ * @return the button panel
+ */
+ public JPanel getButtonPanel() {
+ return buttonPanel;
+ }
+}
diff --git a/src/main/java/prefs/editors/VSColorChooser.java b/src/main/java/prefs/editors/VSColorChooser.java
new file mode 100644
index 0000000..ac67ace
--- /dev/null
+++ b/src/main/java/prefs/editors/VSColorChooser.java
@@ -0,0 +1,61 @@
+package prefs.editors;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+
+import javax.swing.BorderFactory;
+import javax.swing.JColorChooser;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import prefs.VSPrefs;
+
+/**
+ * The class VSColorChooser, is for selecting a color within an editor.
+ *
+ * @author Paul C. Buetow
+ */
+public class VSColorChooser extends JPanel implements ChangeListener {
+ /** The serial version uid */
+ private static final long serialVersionUID = 1L;
+
+ /** The color chooser. */
+ protected JColorChooser colorChooser;
+
+ /** The color. */
+ private Color color;
+
+ /** The val field. */
+ private JTextField valField;
+
+ /**
+ * Instantiates a new VSColorChooser object.
+ *
+ * @param prefs the prefs
+ * @param valField the val field
+ */
+ public VSColorChooser(VSPrefs prefs, JTextField valField) {
+ super(new BorderLayout());
+ this.color = valField.getBackground();
+ this.valField = valField;
+
+ colorChooser = new JColorChooser(Color.yellow);
+ colorChooser.setColor(color);
+ colorChooser.getSelectionModel().addChangeListener(this);
+ colorChooser.setBorder(BorderFactory.createTitledBorder(
+ prefs.getString("lang.colorchooser2")));
+ add(colorChooser, BorderLayout.CENTER);
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.event.ChangeListener#stateChanged(
+ * javax.swing.event.ChangeEvent)
+ */
+ public void stateChanged(ChangeEvent e) {
+ Color newColor = colorChooser.getColor();
+ valField.setBackground(newColor);
+ valField.repaint();
+ }
+}
diff --git a/src/main/java/prefs/editors/VSEditorFrame.java b/src/main/java/prefs/editors/VSEditorFrame.java
new file mode 100644
index 0000000..e418801
--- /dev/null
+++ b/src/main/java/prefs/editors/VSEditorFrame.java
@@ -0,0 +1,98 @@
+package prefs.editors;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+import prefs.VSPrefs;
+import utils.VSFrame;
+
+/**
+ * The class VSEditorFrame, this is a wrapper around an VSAbstractEditor
+ * object, which should be displayed in its own frame.
+ *
+ * @author Paul C. Buetow
+ */
+public class VSEditorFrame extends VSFrame implements ActionListener {
+ /** The serial version uid */
+ private static final long serialVersionUID = 1L;
+
+ /** The editor. */
+ private VSAbstractBetterEditor editor;
+
+ /** The prefs. */
+ private VSPrefs prefs;
+
+ /**
+ * Instantiates a new VSEditorFrame object.
+ *
+ * @param prefs the prefs
+ * @param relativeTo the relative to
+ * @param editor the editor
+ */
+ public VSEditorFrame(VSPrefs prefs, Component relativeTo,
+ VSAbstractBetterEditor editor) {
+ super(editor.getTitle(), relativeTo);
+ this.prefs = prefs;
+ this.editor = editor;
+ init();
+ }
+
+ /**
+ * Inits the VSEditorFrame object.
+ */
+ private void init() {
+ editor.setFrame(this);
+ fillButtonPanel(editor.getButtonPanel());
+ setContentPane(editor.getContentPane());
+ setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+ setSize(prefs.getInteger("div.window.prefs.xsize"),
+ prefs.getInteger("div.window.prefs.ysize"));
+ setResizable(false);
+ setVisible(true);
+ }
+
+ /**
+ * Fills the button panel.
+ *
+ * @param buttonPanel the button panel
+ */
+ private void fillButtonPanel(JPanel buttonPanel) {
+ JButton okButton = new JButton(
+ prefs.getString("lang.ok"));
+ okButton.setMnemonic(prefs.getInteger("keyevent.ok"));
+ okButton.addActionListener(this);
+ buttonPanel.add(okButton, 0);
+
+ JButton cancelButton = new JButton(
+ prefs.getString("lang.cancel"));
+ cancelButton.setMnemonic(prefs.getInteger("keyevent.cancel"));
+ cancelButton.addActionListener(this);
+ buttonPanel.add(cancelButton, 1);
+ buttonPanel.repaint();
+ }
+
+ /* (non-Javadoc)
+ * @see java.awt.event.ActionListener#actionPerformed(
+ * java.awt.event.ActionEvent)
+ */
+ public void actionPerformed(ActionEvent e) {
+ String actionCommand = e.getActionCommand();
+
+ if (actionCommand.equals(prefs.getString("lang.ok"))) {
+ editor.actionPerformed(e);
+ dispose();
+
+ } else if (actionCommand.equals(prefs.getString("lang.cancel"))) {
+ editor.actionPerformed(e);
+ dispose();
+
+ } else {
+ editor.actionPerformed(e);
+ }
+ }
+}
diff --git a/src/main/java/prefs/editors/VSEditorTable.java b/src/main/java/prefs/editors/VSEditorTable.java
new file mode 100644
index 0000000..7be0dbf
--- /dev/null
+++ b/src/main/java/prefs/editors/VSEditorTable.java
@@ -0,0 +1,290 @@
+package prefs.editors;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.util.ArrayList;
+
+import javax.swing.AbstractCellEditor;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.JTextPane;
+import javax.swing.table.AbstractTableModel;
+import javax.swing.table.TableCellEditor;
+import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
+import javax.swing.text.Style;
+import javax.swing.text.StyleConstants;
+
+import prefs.VSPrefs;
+
+/**
+ * The class VSEditorTable, each VSAbstractEditor uses an object of this class
+ * for displaying all editable items!
+ *
+ * @author Paul C. Buetow
+ */
+public class VSEditorTable extends JTable {
+ /** The serial version uid */
+ private static final long serialVersionUID = 1L;
+
+ /** The nodes. */
+ private ArrayList<VSNode> nodes;
+
+ /** The model. */
+ private VSEditorTableModel model;
+
+ /**
+ * The class VSNode.
+ */
+ private class VSNode {
+ /** The key. */
+ private String key;
+
+ /** The comp. */
+ private Component comp;
+
+ /**
+ * Instantiates a new VSNode object.
+ *
+ * @param key the key
+ */
+ public VSNode(String key) {
+ this.key = key;
+ }
+
+ /**
+ * Instantiates a new VSNode object.
+ *
+ * @param key the key
+ * @param comp the comp
+ */
+ public VSNode(String key, Component comp) {
+ this.key = key;
+ this.comp = comp;
+ }
+
+ /**
+ * Gets the key.
+ *
+ * @return the key
+ */
+ public String getKey() {
+ return key;
+ }
+
+ /**
+ * Gets the component.
+ *
+ * @return the component
+ */
+ public Component getComponent() {
+ return comp;
+ }
+
+ /**
+ * Gets the renderer component.
+ *
+ * @return the renderer component
+ */
+ public Component getRendererComponent() {
+ return comp;
+ }
+
+ /**
+ * Checks if it is a separator.
+ *
+ * @return true, if is separator
+ */
+ public boolean isSeparator() {
+ return comp == null;
+ }
+ }
+
+ /**
+ * The class VSEditorTableModel, it is the model of a VSEditorTable.
+ */
+ private class VSEditorTableModel extends AbstractTableModel
+ implements TableCellRenderer {
+ /** The serial version uid */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Instantiates a new lang.process.removeeditor table model.
+ */
+ public VSEditorTableModel() {
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.table.AbstractTableModel#getColumnName(int)
+ */
+ public String getColumnName(int col) {
+ return "";
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.table.TableModel#getRowCount()
+ */
+ public int getRowCount() {
+ return nodes.size();
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.table.TableModel#getColumnCount()
+ */
+ public int getColumnCount() {
+ return 2;
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.table.TableModel#getValueAt(int, int)
+ */
+ public Object getValueAt(int row, int col) {
+ VSNode node = nodes.get(row);
+
+ if (node.isSeparator()) {
+ if (col == 1)
+ return "";
+
+ return node.getKey();
+ }
+
+ if (col == 0)
+ return node.getKey();
+
+ return node.getComponent();
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.table.AbstractTableModel#isCellEditable(int, int)
+ */
+ public boolean isCellEditable(int row, int col) {
+ if (col == 0)
+ return false;
+
+ if (nodes.get(row).isSeparator())
+ return false;
+
+ return true;
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.table.AbstractTableModel#setValueAt(
+ * java.lang.Object, int, int)
+ */
+ public void setValueAt(Object value, int row, int col) {
+ }
+
+ /* (non-Javadoc)
+ * @see
+ * javax.swing.table.TableCellRenderer#getTableCellRendererComponent(
+ * javax.swing.JTable, java.lang.Object, boolean, boolean, int, int)
+ */
+ public Component getTableCellRendererComponent(JTable table,
+ Object object, boolean isSelected, boolean hasFocus, int
+ row, int col) {
+
+ VSNode node = nodes.get(row);
+
+ if (node.isSeparator()) {
+ JTextPane pane = new JTextPane();
+ if (col == 0) {
+ pane.setText(node.getKey());
+ Style style = pane.addStyle("Bold", null);
+ StyleConstants.setBold(style, true);
+ }
+ pane.setBackground(new Color(0xCF, 0xCF, 0XCF));
+ return pane;
+ }
+
+ if (col == 0) {
+ JTextField field = new JTextField(" "+node.getKey()+":");
+ field.setBorder(null);
+ field.setEditable(false);
+ field.setBackground(Color.WHITE);
+ return field;
+ }
+
+ return node.getRendererComponent();
+ }
+ }
+
+ /**
+ * The class VSTableCellEditor, is the editor of the VSEditorTable
+ */
+ private class VSTableCellEditor extends AbstractCellEditor
+ implements TableCellEditor {
+ /** The serial version uid */
+ private static final long serialVersionUID = 1L;
+
+ /* (non-Javadoc)
+ * @see javax.swing.table.TableCellEditor#getTableCellEditorComponent(
+ * javax.swing.JTable, java.lang.Object, boolean, int, int)
+ */
+ public Component getTableCellEditorComponent(JTable table,
+ Object object,
+ boolean isSelected,
+ int row,
+ int col) {
+ return nodes.get(row).getComponent();
+ }
+
+ /* (non-Javadoc)
+ * @see javax.swing.CellEditor#getCellEditorValue()
+ */
+ public Object getCellEditorValue() {
+ return new String("");
+ }
+ }
+
+ /**
+ * Instantiates a new VSEditorTable object.
+ *
+ * @param prefs the prefs
+ */
+ public VSEditorTable(VSPrefs prefs) {
+ //this.prefs = prefs;
+ this.nodes = new ArrayList<VSNode>();
+ this.model = new VSEditorTableModel();
+ setModel(model);
+ setDefaultRenderer(Object.class, model);
+ setDefaultEditor(Object.class, new VSTableCellEditor());
+ setIntercellSpacing(new Dimension(5, 5));
+ setRowHeight(25);
+ setBackground(Color.WHITE);
+ getTableHeader().setVisible(false);
+ TableColumn col = getColumnModel().getColumn(1);
+ col.setMinWidth(100);
+ col.setMaxWidth(100);
+ col.setResizable(false);
+
+ col = getColumnModel().getColumn(0);
+ col.sizeWidthToFit();
+ }
+
+ /**
+ * Adds the variable.
+ *
+ * @param key the key
+ * @param comp the comp
+ */
+ public void addVariable(String key, Component comp) {
+ nodes.add(new VSNode(key, comp));
+ }
+
+ /**
+ * Adds the separator.
+ *
+ * @param text the text
+ */
+ public void addSeparator(String text) {
+ nodes.add(new VSNode(text));
+ }
+
+ /**
+ * Fires that the table data has changed.
+ */
+ public void fireTableDataChanged() {
+ model.fireTableDataChanged();
+ }
+}
diff --git a/src/main/java/prefs/editors/VSProcessEditor.java b/src/main/java/prefs/editors/VSProcessEditor.java
new file mode 100644
index 0000000..105152e
--- /dev/null
+++ b/src/main/java/prefs/editors/VSProcessEditor.java
@@ -0,0 +1,107 @@
+package prefs.editors;
+
+import java.awt.event.ActionEvent;
+import java.util.ArrayList;
+
+import javax.swing.JButton;
+import javax.swing.JPanel;
+
+import core.VSInternalProcess;
+import events.VSRegisteredEvents;
+import prefs.VSPrefs;
+import protocols.VSAbstractProtocol;
+
+/**
+ * The class VSProcessEditor, is for editing a VSInternalProcess object.
+ *
+ * @author Paul C. Buetow
+ */
+public class VSProcessEditor extends VSAbstractBetterEditor {
+ /** The process. */
+ private VSInternalProcess process;
+
+ /** The TAKEOVE r_ button. */
+ public static boolean TAKEOVER_BUTTON;
+
+ /**
+ * Instantiates a new VSProcessEditor object.
+ *
+ * @param prefs the prefs
+ * @param process the process
+ */
+ public VSProcessEditor(VSPrefs prefs, VSInternalProcess process) {
+ super(prefs, process, prefs.getString("lang.name") + " - " +
+ prefs.getString("lang.prefs.process"));;
+ this.process = process;
+ disposeFrameWithParentIfExists();
+ makeProtocolVariablesEditable();
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractBetterEditor#addToButtonPanelFront(
+ * javax.swing.JPanel)
+ */
+ protected void addToButtonPanelFront(JPanel buttonPanel) {
+ JButton takeoverButton = new JButton(
+ prefs.getString("lang.takeover"));
+ takeoverButton.setMnemonic(prefs.getInteger("keyevent.takeover"));
+ takeoverButton.addActionListener(this);
+ buttonPanel.add(takeoverButton);
+ }
+
+ /**
+ * Make protocol variables editable.
+ */
+ protected void makeProtocolVariablesEditable() {
+ ArrayList<String> editableProtocolsClassnames =
+ VSRegisteredEvents.getEditableProtocolsClassnames();
+
+ //String protocolString = " " + prefs.getString("lang.protocol");
+ String clientString = " " + prefs.getString("lang.client");
+ String serverString = " " + prefs.getString("lang.server");
+
+ for (String protocolClassname : editableProtocolsClassnames) {
+ String protocolShortname =
+ VSRegisteredEvents.getShortnameByClassname(
+ protocolClassname);
+ VSAbstractProtocol protocol =
+ process.getProtocolObject(protocolClassname);
+ protocol.onClientInit();
+ protocol.onServerInit();
+
+ ArrayList<String> clientVariables =
+ VSRegisteredEvents.getProtocolClientVariables(
+ protocolClassname);
+ if (clientVariables != null)
+ addToEditor(protocolShortname + clientString,
+ protocolShortname, protocol, clientVariables);
+
+ ArrayList<String> serverVariables =
+ VSRegisteredEvents.getProtocolServerVariables(
+ protocolClassname);
+ if (serverVariables != null)
+ addToEditor(protocolShortname + serverString,
+ protocolShortname, protocol, serverVariables);
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractBetterEditor#actionPerformed(
+ * java.awt.event.ActionEvent)
+ */
+ public void actionPerformed(ActionEvent e) {
+ String actionCommand = e.getActionCommand();
+
+ if (actionCommand.equals(prefs.getString("lang.ok"))) {
+ savePrefs();
+ process.updateFromPrefs();
+
+ } else if (actionCommand.equals(prefs.getString("lang.takeover"))) {
+ savePrefs();
+ process.updateFromPrefs();
+
+ } else {
+ super.actionPerformed(e);
+ }
+ }
+}
diff --git a/src/main/java/prefs/editors/VSSimulatorEditor.java b/src/main/java/prefs/editors/VSSimulatorEditor.java
new file mode 100644
index 0000000..9ee0e58
--- /dev/null
+++ b/src/main/java/prefs/editors/VSSimulatorEditor.java
@@ -0,0 +1,120 @@
+package prefs.editors;
+
+import java.awt.event.ActionEvent;
+
+import javax.swing.JButton;
+import javax.swing.JPanel;
+
+import prefs.VSPrefs;
+import simulator.VSSimulator;
+import simulator.VSSimulatorFrame;
+
+/**
+ * The class VSSimulatorEditor, is for editing a VSSimulator object.
+ *
+ * @author Paul C. Buetow
+ */
+public class VSSimulatorEditor extends VSAbstractBetterEditor {
+ /** The constant OPENED_NEW_WINDOW */
+ public static final boolean OPENED_NEW_WINDOW = true;
+
+ /** The constant OPENED_NEW_TAB */
+ public static final boolean OPENED_NEW_TAB = false;
+
+ /** The simulator frame. */
+ private VSSimulatorFrame simulatorFrame;
+
+ /** The simulator. */
+ private VSSimulator simulator;
+
+ /** The TAKEOVE r_ button. */
+ public static boolean TAKEOVER_BUTTON;
+
+ /** The dont start new simulator. */
+ private boolean dontStartNewSimulator;
+
+ /** Open a new simulator window. */
+ private boolean openedNewWindow;
+
+ /**
+ * Instantiates a new VSSimulatorEditor object.
+ *
+ * @param prefs the prefs
+ * @param simulatorFrame the simulator frame
+ * @param simulator the simulator
+ */
+ public VSSimulatorEditor(VSPrefs prefs, VSSimulatorFrame simulatorFrame,
+ VSSimulator simulator) {
+ super(prefs, prefs, prefs.getString("lang.name")
+ + " - " + prefs.getString("lang.prefs"));
+ this.dontStartNewSimulator = true;//simulator != null;
+ this.simulatorFrame = simulatorFrame;
+ this.simulator = simulator;
+ }
+
+ /**
+ * Instantiates a new VSSimulatorEditor object.
+ *
+ * @param prefs the prefs
+ * @param simulatorFrame the simulator frame
+ */
+ public VSSimulatorEditor(VSPrefs prefs, VSSimulatorFrame simulatorFrame,
+ boolean openedNewWindow) {
+ super(prefs, prefs, prefs.getString("lang.name")
+ + " - " + prefs.getString("lang.prefs"));
+ this.simulatorFrame = simulatorFrame;
+ this.openedNewWindow = openedNewWindow;
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractBetterEditor#addToButtonPanelFront(
+ * javax.swing.JPanel)
+ */
+ protected void addToButtonPanelFront(JPanel buttonPanel) {
+ if (TAKEOVER_BUTTON) {
+ TAKEOVER_BUTTON = false;
+ JButton takeoverButton = new JButton(
+ prefs.getString("lang.takeover"));
+ takeoverButton.setMnemonic(prefs.getInteger("keyevent.takeover"));
+ takeoverButton.addActionListener(this);
+ buttonPanel.add(takeoverButton);
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see prefs.editors.VSAbstractBetterEditor#actionPerformed(
+ * java.awt.event.ActionEvent)
+ */
+ public void actionPerformed(ActionEvent e) {
+ String actionCommand = e.getActionCommand();
+
+ if (actionCommand.equals(prefs.getString("lang.takeover"))) {
+ savePrefs();
+
+ if (simulator != null) {
+ if (expertModeChanged())
+ simulator.fireExpertModeChanged();
+ simulator.updateFromPrefs();
+ }
+
+ } else if (actionCommand.equals(prefs.getString("lang.cancel"))) {
+ if (!dontStartNewSimulator && openedNewWindow)
+ simulatorFrame.dispose();
+
+ } else if (actionCommand.equals(prefs.getString("lang.ok"))) {
+ savePrefs();
+ if (expertModeChanged()) {
+ if (simulator != null)
+ simulator.fireExpertModeChanged();
+ }
+ if (!dontStartNewSimulator)
+ simulatorFrame.addSimulator(new VSSimulator(prefsToEdit,
+ simulatorFrame));
+ else if (simulator != null)
+ simulator.updateFromPrefs();
+
+ } else {
+ super.actionPerformed(e);
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-17 16:48:31 +0000