altosui: Call config UI from AltosConfigData directly
authorKeith Packard <keithp@keithp.com>
Sat, 8 Dec 2012 01:27:48 +0000 (17:27 -0800)
committerKeith Packard <keithp@keithp.com>
Sat, 8 Dec 2012 01:27:48 +0000 (17:27 -0800)
Don't make AltosConfig have a pile of config code, stick that in
AltosConfigData instead. This uses a new interface, AltosConfigValues
to get from AltosConfigData to the UI.

Signed-off-by: Keith Packard <keithp@keithp.com>
altoslib/AltosConfigData.java
altoslib/AltosConfigValues.java [new file with mode: 0644]
altoslib/Makefile.am
altosui/AltosConfig.java
altosui/AltosConfigUI.java

index ddc49e8..515ff48 100644 (file)
@@ -39,7 +39,7 @@ public class AltosConfigData implements Iterable<String> {
        public int      main_deploy;
        public int      apogee_delay;
        public int      apogee_lockout;
-       
+
        /* HAS_RADIO */
        public int      radio_frequency;
        public String   callsign;
@@ -136,7 +136,7 @@ public class AltosConfigData implements Iterable<String> {
 
                return r;
        }
-       
+
        public int compare_version(String other) {
                int[]   me = parse_version(version);
                int[]   them = parse_version(other);
@@ -165,14 +165,14 @@ public class AltosConfigData implements Iterable<String> {
                log_format = AltosLib.AO_LOG_FORMAT_UNKNOWN;
                version = "unknown";
 
-               main_deploy = 250;
-               apogee_delay = 0;
-               apogee_lockout = 0;
+               main_deploy = -1;
+               apogee_delay = -1;
+               apogee_lockout = -1;
 
-               radio_frequency = 0;
-               callsign = "N0CALL";
+               radio_frequency = -1;
+               callsign = null;
                radio_enable = -1;
-               radio_calibration = 0;
+               radio_calibration = -1;
                radio_channel = -1;
                radio_setting = -1;
 
@@ -180,7 +180,7 @@ public class AltosConfigData implements Iterable<String> {
                accel_cal_minus = -1;
                pad_orientation = -1;
 
-               flight_log_max = 0;
+               flight_log_max = -1;
                ignite_mode = -1;
 
                aes_key = "";
@@ -193,7 +193,7 @@ public class AltosConfigData implements Iterable<String> {
                storage_erase_unit = -1;
                stored_flight = -1;
        }
-       
+
        public void parse_line(String line) {
                lines.add(line);
                /* Version replies */
@@ -257,11 +257,11 @@ public class AltosConfigData implements Iterable<String> {
                if (npyro > 0) {
                        try {
                                AltosPyro p = new AltosPyro(pyro, line);
-                               if (pyro < npyro - 1)
+                               if (pyro < npyro)
                                        pyros[pyro++] = p;
                        } catch (Exception e) {}
                }
-               
+
                /* Storage info replies */
                try { storage_size = get_int(line, "Storage size:"); } catch (Exception e) {}
                try { storage_erase_unit = get_int(line, "Storage erase unit"); } catch (Exception e) {}
@@ -289,6 +289,182 @@ public class AltosConfigData implements Iterable<String> {
                }
        }
 
+       public boolean has_frequency() {
+               return radio_frequency >= 0 || radio_setting >= 0 || radio_channel >= 0;
+       }
+
+       public void set_frequency(double freq) {
+               int     frequency = radio_frequency;
+               int     setting = radio_setting;
+
+               if (frequency > 0) {
+                       radio_frequency = (int) Math.floor (freq * 1000 + 0.5);
+                       radio_channel = -1;
+               } else if (setting > 0) {
+                       radio_setting =AltosConvert.radio_frequency_to_setting(freq,
+                                                                                   radio_calibration);
+                       radio_channel = -1;
+               } else {
+                       radio_channel = AltosConvert.radio_frequency_to_channel(freq);
+               }
+       }
+
+       public double frequency() {
+               int     channel = radio_channel;
+               int     setting = radio_setting;
+               if (channel < 0)
+                       channel = 0;
+               if (setting < 0)
+                       setting = 0;
+
+               return AltosConvert.radio_to_frequency(radio_frequency,
+                                                      setting,
+                                                      radio_calibration,
+                                                      channel);
+       }
+
+       public int log_limit() {
+               if (storage_size > 0 && storage_erase_unit > 0) {
+                       int     log_limit = storage_size - storage_erase_unit;
+                       if (log_limit > 0)
+                               return log_limit / 1024;
+               }
+               return 1024;
+       }
+
+       public void get_values(AltosConfigValues source) {
+
+               /* HAS_FLIGHT */
+               if (main_deploy >= 0)
+                       main_deploy = source.main_deploy();
+               if (apogee_delay >= 0)
+                       apogee_delay = source.apogee_delay();
+               if (apogee_lockout >= 0)
+                       apogee_lockout = source.apogee_lockout();
+
+               /* HAS_RADIO */
+               if (has_frequency())
+                       set_frequency(source.radio_frequency());
+               if (radio_enable >= 0)
+                       radio_enable = source.radio_enable();
+               if (callsign != null)
+                       callsign = source.callsign();
+               if (radio_calibration >= 0)
+                       radio_calibration = source.radio_calibration();
+
+               /* HAS_ACCEL */
+               if (pad_orientation >= 0)
+                       pad_orientation = source.pad_orientation();
+
+               /* HAS_LOG */
+               if (flight_log_max >= 0)
+                       flight_log_max = source.flight_log_max();
+
+               /* HAS_IGNITE */
+               if (ignite_mode >= 0)
+                       ignite_mode = source.ignite_mode();
+
+               /* AO_PYRO_NUM */
+               if (npyro > 0)
+                       pyros = source.pyros();
+       }
+
+       public void set_values(AltosConfigValues dest) {
+               dest.set_serial(serial);
+               dest.set_product(product);
+               dest.set_version(version);
+               dest.set_main_deploy(main_deploy);
+               dest.set_apogee_delay(apogee_delay);
+               dest.set_apogee_lockout(apogee_lockout);
+               dest.set_radio_calibration(radio_calibration);
+               dest.set_radio_frequency(frequency());
+               boolean max_enabled = true;
+               switch (log_format) {
+               case AltosLib.AO_LOG_FORMAT_TINY:
+                       max_enabled = false;
+                       break;
+               default:
+                       if (stored_flight >= 0)
+                               max_enabled = false;
+                       break;
+               }
+               dest.set_flight_log_max_enabled(max_enabled);
+               dest.set_radio_enable(radio_enable);
+               dest.set_flight_log_max_limit(log_limit());
+               dest.set_flight_log_max(flight_log_max);
+               dest.set_ignite_mode(ignite_mode);
+               dest.set_pad_orientation(pad_orientation);
+               dest.set_callsign(callsign);
+               if (npyro > 0)
+                       dest.set_pyros(pyros);
+               else
+                       dest.set_pyros(null);
+       }
+
+       public void save(AltosLink link, boolean remote) throws InterruptedException, TimeoutException {
+
+               /* HAS_FLIGHT */
+               if (main_deploy >= 0)
+                       link.printf("c m %d\n", main_deploy);
+               if (apogee_delay >= 0)
+                       link.printf("c d %d\n", apogee_delay);
+               if (apogee_lockout >= 0)
+                       link.printf("c L %d\n", apogee_lockout);
+
+               /* Don't mess with radio calibration when remote */
+               if (radio_calibration > 0 && !remote)
+                       link.printf("c f %d\n", radio_calibration);
+
+               /* HAS_RADIO */
+               if (has_frequency()) {
+                       boolean has_frequency = radio_frequency >= 0;
+                       boolean has_setting = radio_setting > 0;
+                       double frequency = frequency();
+                       link.set_radio_frequency(frequency,
+                                                       has_frequency,
+                                                       has_setting,
+                                                       radio_calibration);
+                       /* When remote, reset the dongle frequency at the same time */
+                       if (remote) {
+                               link.stop_remote();
+                               link.set_radio_frequency(frequency);
+                               link.start_remote();
+                       }
+               }
+
+               if (callsign != null)
+                       link.printf("c c %s\n", callsign);
+               if (radio_enable >= 0)
+                       link.printf("c e %d\n", radio_enable);
+
+               /* HAS_ACCEL */
+               /* UI doesn't support accel cal */
+               if (pad_orientation >= 0)
+                       link.printf("c o %d\n", pad_orientation);
+
+               /* HAS_LOG */
+               if (flight_log_max != 0)
+                       link.printf("c l %d\n", flight_log_max);
+
+               /* HAS_IGNITE */
+               if (ignite_mode >= 0)
+                       link.printf("c i %d\n", ignite_mode);
+
+               /* HAS_AES */
+               /* UI doesn't support AES key config */
+
+               /* AO_PYRO_NUM */
+               if (pyros.length > 0) {
+                       for (int p = 0; p < pyros.length; p++) {
+                               link.printf("c P %s\n",
+                                                  pyros[p].toString());
+                       }
+               }
+
+               link.printf("c w\n");
+               link.flush_output();
+       }
+
        public AltosConfigData(AltosLink link) throws InterruptedException, TimeoutException {
                reset();
                link.printf("c s\nf\nv\n");
diff --git a/altoslib/AltosConfigValues.java b/altoslib/AltosConfigValues.java
new file mode 100644 (file)
index 0000000..69239f2
--- /dev/null
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2012 Keith Packard <keithp@keithp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+package org.altusmetrum.AltosLib;
+
+public interface AltosConfigValues {
+       /* set and get all of the dialog values */
+       public abstract void set_product(String product);
+
+       public abstract void set_version(String version);
+
+       public abstract void set_serial(int serial);
+
+       public abstract void set_main_deploy(int new_main_deploy);
+
+       public abstract int main_deploy();
+
+       public abstract void set_apogee_delay(int new_apogee_delay);
+
+       public abstract int apogee_delay();
+
+       public abstract void set_apogee_lockout(int new_apogee_lockout);
+
+       public abstract int apogee_lockout();
+
+       public abstract void set_radio_frequency(double new_radio_frequency);
+
+       public abstract double radio_frequency();
+
+       public abstract void set_radio_calibration(int new_radio_calibration);
+
+       public abstract int radio_calibration();
+
+       public abstract void set_radio_enable(int new_radio_enable);
+
+       public abstract int radio_enable();
+
+       public abstract void set_callsign(String new_callsign);
+
+       public abstract String callsign();
+
+       public abstract void set_flight_log_max(int new_flight_log_max);
+
+       public abstract void set_flight_log_max_enabled(boolean enable);
+
+       public abstract int flight_log_max();
+
+       public abstract void set_flight_log_max_limit(int flight_log_max_limit);
+
+       public abstract void set_ignite_mode(int new_ignite_mode);
+
+       public abstract int ignite_mode();
+
+       public abstract void set_pad_orientation(int new_pad_orientation);
+
+       public abstract int pad_orientation();
+
+       public abstract void set_pyros(AltosPyro[] new_pyros);
+
+       public abstract AltosPyro[] pyros();
+}
index 2579a65..0086bc6 100644 (file)
@@ -12,6 +12,7 @@ AltosLibdir = $(datadir)/java
 AltosLib_JAVA = \
        $(SRC)/AltosLib.java \
        $(SRC)/AltosConfigData.java \
+       $(SRC)/AltosConfigValues.java \
        $(SRC)/AltosConvert.java \
        $(SRC)/AltosCRCException.java \
        $(SRC)/AltosEepromChunk.java \
index 9219156..e1ffebb 100644 (file)
@@ -78,43 +78,8 @@ public class AltosConfig implements ActionListener {
                        serial_line.stop_remote();
        }
 
-       int log_limit() {
-               if (data.storage_size > 0 && data.storage_erase_unit > 0) {
-                       int     log_limit = data.storage_size - data.storage_erase_unit;
-                       if (log_limit > 0)
-                               return log_limit / 1024;
-               }
-               return 1024;
-       }
-
        void update_ui() {
-               config_ui.set_serial(data.serial);
-               config_ui.set_product(data.product);
-               config_ui.set_version(data.version);
-               config_ui.set_main_deploy(data.main_deploy);
-               config_ui.set_apogee_delay(data.apogee_delay);
-               config_ui.set_apogee_lockout(data.apogee_lockout);
-               config_ui.set_radio_calibration(data.radio_calibration);
-               config_ui.set_radio_frequency(frequency());
-               boolean max_enabled = true;
-               switch (data.log_format) {
-               case Altos.AO_LOG_FORMAT_TINY:
-                       max_enabled = false;
-                       break;
-               default:
-                       if (data.stored_flight >= 0)
-                               max_enabled = false;
-                       break;
-               }
-               config_ui.set_flight_log_max_enabled(max_enabled);
-               config_ui.set_radio_enable(data.radio_enable);
-               config_ui.set_flight_log_max_limit(log_limit());
-               config_ui.set_flight_log_max(data.flight_log_max);
-               config_ui.set_ignite_mode(data.ignite_mode);
-               config_ui.set_pad_orientation(data.pad_orientation);
-               config_ui.set_callsign(data.callsign);
-               config_ui.set_pyros(data.pyros);
-               config_ui.set_has_pyro(data.npyro > 0);
+               data.set_values(config_ui);
                config_ui.set_clean();
                if (!made_visible) {
                        made_visible = true;
@@ -170,41 +135,11 @@ public class AltosConfig implements ActionListener {
 
                void save_data() {
                        try {
-                               double frequency = frequency();
-                               boolean has_frequency = data.radio_frequency > 0;
-                               boolean has_setting = data.radio_setting > 0;
                                start_serial();
-                               serial_line.printf("c m %d\n", data.main_deploy);
-                               serial_line.printf("c d %d\n", data.apogee_delay);
-                               serial_line.printf("c L %d\n", data.apogee_lockout);
-                               if (!remote)
-                                       serial_line.printf("c f %d\n", data.radio_calibration);
-                               serial_line.set_radio_frequency(frequency,
-                                                               has_frequency,
-                                                               has_setting,
-                                                               data.radio_calibration);
-                               if (remote) {
-                                       serial_line.stop_remote();
-                                       serial_line.set_radio_frequency(frequency);
-                                       AltosUIPreferences.set_frequency(device.getSerial(), frequency);
-                                       serial_line.start_remote();
-                               }
-                               serial_line.printf("c c %s\n", data.callsign);
-                               if (data.flight_log_max != 0)
-                                       serial_line.printf("c l %d\n", data.flight_log_max);
-                               if (data.radio_enable >= 0)
-                                       serial_line.printf("c e %d\n", data.radio_enable);
-                               if (data.ignite_mode >= 0)
-                                       serial_line.printf("c i %d\n", data.ignite_mode);
-                               if (data.pad_orientation >= 0)
-                                       serial_line.printf("c o %d\n", data.pad_orientation);
-                               if (data.pyros.length > 0) {
-                                       for (int p = 0; p < data.pyros.length; p++) {
-                                               serial_line.printf("c P %s\n",
-                                                                  data.pyros[p].toString());
-                                       }
-                               }
-                               serial_line.printf("c w\n");
+                               data.save(serial_line, remote);
+                               if (remote)
+                                       AltosUIPreferences.set_frequency(device.getSerial(),
+                                                                        data.frequency());
                        } catch (InterruptedException ie) {
                        } catch (TimeoutException te) {
                        } finally {
@@ -291,51 +226,23 @@ public class AltosConfig implements ActionListener {
                                                       data.radio_channel);
        }
 
-       void set_frequency(double freq) {
-               int     frequency = data.radio_frequency;
-               int     setting = data.radio_setting;
-
-               if (frequency > 0) {
-                       data.radio_frequency = (int) Math.floor (freq * 1000 + 0.5);
-                       data.radio_channel = 0;
-               } else if (setting > 0) {
-                       data.radio_setting =AltosConvert.radio_frequency_to_setting(freq,
-                                                                                   data.radio_calibration);
-                       data.radio_channel = 0;
-               } else {
-                       data.radio_channel = AltosConvert.radio_frequency_to_channel(freq);
-               }
-       }
-
        void save_data() {
 
                /* bounds check stuff */
-               if (config_ui.flight_log_max() > log_limit()) {
+               if (config_ui.flight_log_max() > data.log_limit()) {
                        JOptionPane.showMessageDialog(owner,
                                                      String.format("Requested flight log, %dk, is larger than the available space, %dk.\n",
                                                                    config_ui.flight_log_max(),
-                                                                   log_limit()),
+                                                                   data.log_limit()),
                                                      "Maximum Flight Log Too Large",
                                                      JOptionPane.ERROR_MESSAGE);
                        return;
                }
 
-               data.main_deploy = config_ui.main_deploy();
-               data.apogee_delay = config_ui.apogee_delay();
-               data.apogee_lockout = config_ui.apogee_lockout();
-               data.radio_calibration = config_ui.radio_calibration();
-               set_frequency(config_ui.radio_frequency());
-               data.flight_log_max = config_ui.flight_log_max();
-               if (data.radio_enable >= 0)
-                       data.radio_enable = config_ui.radio_enable();
-               if (data.ignite_mode >= 0)
-                       data.ignite_mode = config_ui.ignite_mode();
-               if (data.pad_orientation >= 0)
-                       data.pad_orientation = config_ui.pad_orientation();
-               data.callsign = config_ui.callsign();
-               if (data.npyro > 0) {
-                       data.pyros = config_ui.pyros();
-               }
+               /* Pull data out of the UI and stuff back into our local data record */
+
+               data.get_values(config_ui);
+
                run_serial_thread(serial_mode_save);
        }
 
index feac053..2c3435c 100644 (file)
@@ -25,7 +25,7 @@ import org.altusmetrum.AltosLib.*;
 
 public class AltosConfigUI
        extends AltosDialog
-       implements ActionListener, ItemListener, DocumentListener
+       implements ActionListener, ItemListener, DocumentListener, AltosConfigValues
 {
 
        Container       pane;
@@ -684,6 +684,7 @@ public class AltosConfigUI
 
        public void set_apogee_delay(int new_apogee_delay) {
                apogee_delay_value.setSelectedItem(Integer.toString(new_apogee_delay));
+               apogee_delay_value.setEnabled(new_apogee_delay >= 0);
        }
 
        public int apogee_delay() {
@@ -692,6 +693,7 @@ public class AltosConfigUI
 
        public void set_apogee_lockout(int new_apogee_lockout) {
                apogee_lockout_value.setSelectedItem(Integer.toString(new_apogee_lockout));
+               apogee_lockout_value.setEnabled(new_apogee_lockout >= 0);
        }
 
        public int apogee_lockout() {
@@ -829,13 +831,10 @@ public class AltosConfigUI
                        return -1;
        }
 
-       public void set_has_pyro(boolean has_pyro) {
-               pyro.setEnabled(has_pyro);
-       }
-
        public void set_pyros(AltosPyro[] new_pyros) {
                pyros = new_pyros;
-               if (pyro_ui != null)
+               pyro.setEnabled(pyros != null);
+               if (pyros != null && pyro_ui != null)
                        pyro_ui.set_pyros(pyros);
        }