git.gag.com Git - fw/altos/blob - telegps/TeleGPS.java

   1 /*
   2  * Copyright © 2014 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 package org.altusmetrum.telegps;
  19
  20 import java.awt.*;
  21 import java.awt.event.*;
  22 import javax.swing.*;
  23 import java.io.*;
  24 import java.util.concurrent.*;
  25 import java.util.*;
  26 import org.altusmetrum.altoslib_4.*;
  27 import org.altusmetrum.altosuilib_2.*;
  28
  29 public class TeleGPS extends AltosUIFrame implements AltosFlightDisplay, AltosFontListener, ActionListener {
  30
  31         static String[] telegps_icon_names = {
  32                 "/telegps-16.png",
  33                 "/telegps-32.png",
  34                 "/telegps-48.png",
  35                 "/telegps-64.png",
  36                 "/telegps-128.png",
  37                 "/telegps-256.png"
  38         };
  39
  40         static { set_icon_names(telegps_icon_names); }
  41
  42         static AltosVoice       voice;
  43
  44         static AltosVoice voice() {
  45                 if (voice == null)
  46                         voice = new AltosVoice();
  47                 return voice;
  48         }
  49
  50         AltosFlightReader       reader;
  51         AltosDisplayThread      thread;
  52
  53         JTabbedPane     pane;
  54
  55         AltosSiteMap    sitemap;
  56         boolean         has_map;
  57
  58         JMenuBar        menu_bar;
  59         JMenu           file_menu;
  60         JMenu           monitor_menu;
  61         JMenu           device_menu;
  62
  63         /* File menu */
  64         final static String     new_command = "new";
  65         final static String     preferences_command = "preferences";
  66         final static String     load_maps_command = "loadmaps";
  67         final static String     close_command = "close";
  68         final static String     exit_command = "exit";
  69
  70         static final String[][] file_menu_entries = new String[][] {
  71                 { "New Window",         new_command },
  72                 { "Preferences",        preferences_command },
  73                 { "Load Maps",          load_maps_command },
  74                 { "Close",              close_command },
  75                 { "Exit",               exit_command },
  76         };
  77
  78         /* Monitor menu */
  79         final static String     monitor_command = "monitor";
  80         final static String     disconnect_command = "disconnect";
  81         final static String     scan_command = "scan";
  82
  83         static final String[][] monitor_menu_entries = new String[][] {
  84                 { "Monitor Device",     monitor_command },
  85                 { "Disconnect",         disconnect_command },
  86                 { "Scan Channels",      scan_command },
  87         };
  88
  89         /* Device menu */
  90         final static String     download_command = "download";
  91         final static String     configure_command = "configure";
  92         final static String     export_command = "export";
  93         final static String     graph_command = "graph";
  94
  95         static final String[][] device_menu_entries = new String[][] {
  96                 { "Download Data",      download_command },
  97                 { "Configure Device",   configure_command },
  98                 { "Export Data",        export_command },
  99                 { "Graph Data",         graph_command },
 100         };
 101
 102 //      private AltosInfoTable flightInfo;
 103
 104         boolean exit_on_close = false;
 105
 106         void stop_display() {
 107                 if (thread != null && thread.isAlive()) {
 108                         thread.interrupt();
 109                         try {
 110                                 thread.join();
 111                         } catch (InterruptedException ie) {}
 112                 }
 113                 thread = null;
 114         }
 115
 116         public void reset() {
 117                 sitemap.reset();
 118         }
 119
 120         public void set_font() {
 121                 sitemap.set_font();
 122         }
 123
 124         public void font_size_changed(int font_size) {
 125                 set_font();
 126         }
 127
 128
 129 //      AltosFlightStatusUpdate status_update;
 130
 131         public void show(AltosState state, AltosListenerState listener_state) {
 132 //              status_update.saved_state = state;
 133
 134                 if (state == null)
 135                         state = new AltosState();
 136
 137                 sitemap.show(state, listener_state);
 138                 telegps_status.show(state, listener_state);
 139         }
 140
 141         Container               bag;
 142         AltosFreqList           frequencies;
 143         JLabel                  telemetry;
 144         TeleGPSStatus           telegps_status;
 145         TeleGPSStatusUpdate     status_update;
 146
 147         ActionListener          show_timer;
 148
 149         void new_window() {
 150                 new TeleGPS();
 151         }
 152
 153         void preferences() {
 154                 new TeleGPSPreferences(this, voice());
 155         }
 156
 157         void load_maps() {
 158                 new AltosSiteMapPreload(this);
 159         }
 160
 161         void disconnect() {
 162                 setTitle("TeleGPS");
 163                 stop_display();
 164                 remove_frequency_menu();
 165         }
 166
 167         void connect(AltosDevice device) {
 168                 if (reader != null)
 169                         disconnect();
 170                 try {
 171                         AltosFlightReader       reader = new AltosTelemetryReader(new AltosSerial(device));
 172                         set_reader(reader);
 173                         add_frequency_menu(device.getSerial(), reader);
 174                 } catch (FileNotFoundException ee) {
 175                         JOptionPane.showMessageDialog(this,
 176                                                       ee.getMessage(),
 177                                                       String.format ("Cannot open %s", device.toShortString()),
 178                                                       JOptionPane.ERROR_MESSAGE);
 179                 } catch (AltosSerialInUseException si) {
 180                         JOptionPane.showMessageDialog(this,
 181                                                       String.format("Device \"%s\" already in use",
 182                                                                     device.toShortString()),
 183                                                       "Device in use",
 184                                                       JOptionPane.ERROR_MESSAGE);
 185                 } catch (IOException ee) {
 186                         JOptionPane.showMessageDialog(this,
 187                                                       String.format ("Unknown I/O error on %s", device.toShortString()),
 188                                                       "Unknown I/O error",
 189                                                       JOptionPane.ERROR_MESSAGE);
 190                 } catch (TimeoutException te) {
 191                         JOptionPane.showMessageDialog(this,
 192                                                       String.format ("Timeout on %s", device.toShortString()),
 193                                                       "Timeout error",
 194                                                       JOptionPane.ERROR_MESSAGE);
 195                 } catch (InterruptedException ie) {
 196                         JOptionPane.showMessageDialog(this,
 197                                                       String.format("Interrupted %s", device.toShortString()),
 198                                                       "Interrupted exception",
 199                                                       JOptionPane.ERROR_MESSAGE);
 200                 }
 201         }
 202
 203         void monitor() {
 204                 AltosDevice     device = AltosDeviceUIDialog.show(this,
 205                                                                   AltosLib.product_basestation);
 206                 if (device == null)
 207                         return;
 208                 connect(device);
 209         }
 210
 211         public void scan_device_selected(AltosDevice device) {
 212                 connect(device);
 213         }
 214
 215         void scan() {
 216                 new AltosScanUI(this, false);
 217         }
 218
 219         void download(){
 220         }
 221
 222         void configure() {
 223                 new TeleGPSConfig(this);
 224         }
 225
 226         void export() {
 227         }
 228
 229         void graph() {
 230         }
 231
 232         public void actionPerformed(ActionEvent ev) {
 233
 234                 /* File menu */
 235                 if (new_command.equals(ev.getActionCommand())) {
 236                         new_window();
 237                         return;
 238                 }
 239                 if (preferences_command.equals(ev.getActionCommand())) {
 240                         preferences();
 241                         return;
 242                 }
 243                 if (load_maps_command.equals(ev.getActionCommand())) {
 244                         load_maps();
 245                         return;
 246                 }
 247                 if (close_command.equals(ev.getActionCommand())) {
 248                         close();
 249                         return;
 250                 }
 251                 if (exit_command.equals(ev.getActionCommand()))
 252                         System.exit(0);
 253
 254                 /* Monitor menu */
 255                 if (monitor_command.equals(ev.getActionCommand())) {
 256                         monitor();
 257                         return;
 258                 }
 259                 if (disconnect_command.equals(ev.getActionCommand())) {
 260                         disconnect();
 261                         return;
 262                 }
 263                 if (scan_command.equals(ev.getActionCommand())) {
 264                         scan();
 265                         return;
 266                 }
 267
 268                 /* Device menu */
 269                 if (download_command.equals(ev.getActionCommand())) {
 270                         download();
 271                         return;
 272                 }
 273                 if (configure_command.equals(ev.getActionCommand())) {
 274                         configure();
 275                         return;
 276                 }
 277                 if (export_command.equals(ev.getActionCommand())) {
 278                         export();
 279                         return;
 280                 }
 281                 if (graph_command.equals(ev.getActionCommand())) {
 282                         graph();
 283                         return;
 284                 }
 285         }
 286
 287         void add_frequency_menu(int serial, final AltosFlightReader reader) {
 288                 // Channel menu
 289                 frequencies = new AltosFreqList(AltosUIPreferences.frequency(serial));
 290                 frequencies.set_product("Monitor");
 291                 frequencies.set_serial(serial);
 292                 frequencies.addActionListener(new ActionListener() {
 293                                 public void actionPerformed(ActionEvent e) {
 294                                         double frequency = frequencies.frequency();
 295                                         try {
 296                                                 reader.set_frequency(frequency);
 297                                         } catch (TimeoutException te) {
 298                                         } catch (InterruptedException ie) {
 299                                         }
 300                                         reader.save_frequency();
 301                                 }
 302                         });
 303                 menu_bar.add(frequencies);
 304         }
 305
 306         void remove_frequency_menu() {
 307                 if (frequencies != null) {
 308                         menu_bar.remove(frequencies);
 309                         frequencies = null;
 310                 }
 311         }
 312
 313         public void set_reader(AltosFlightReader reader) {
 314                 setTitle(String.format("TeleGPS %s", reader.name));
 315                 thread = new AltosDisplayThread(this, voice(), this, reader);
 316                 thread.start();
 317         }
 318
 319         static int      number_of_windows;
 320
 321         private void close() {
 322                 AltosUIPreferences.unregister_font_listener(this);
 323                 setVisible(false);
 324                 dispose();
 325                 --number_of_windows;
 326                 if (number_of_windows == 0)
 327                         System.exit(0);
 328         }
 329
 330         private void add_menu(JMenu menu, String label, String action) {
 331                 JMenuItem       item = new JMenuItem(label);
 332                 menu.add(item);
 333                 item.addActionListener(this);
 334                 item.setActionCommand(action);
 335         }
 336
 337
 338         private JMenu make_menu(String label, String[][] items) {
 339                 JMenu   menu = new JMenu(label);
 340                 for (int i = 0; i < items.length; i++)
 341                         add_menu(menu, items[i][0], items[i][1]);
 342                 menu_bar.add(menu);
 343                 return menu;
 344         }
 345
 346         public TeleGPS() {
 347
 348                 AltosUIPreferences.set_component(this);
 349
 350                 reader = null;
 351
 352                 bag = getContentPane();
 353                 bag.setLayout(new GridBagLayout());
 354
 355                 GridBagConstraints c = new GridBagConstraints();
 356
 357                 setTitle("TeleGPS");
 358
 359                 menu_bar = new JMenuBar();
 360                 setJMenuBar(menu_bar);
 361
 362                 file_menu = make_menu("File", file_menu_entries);
 363                 monitor_menu = make_menu("Monitor", monitor_menu_entries);
 364                 device_menu = make_menu("Device", device_menu_entries);
 365
 366                 int serial = -1;
 367
 368                 /* TeleGPS status is always visible */
 369                 telegps_status = new TeleGPSStatus();
 370                 c.gridx = 0;
 371                 c.gridy = 1;
 372                 c.fill = GridBagConstraints.HORIZONTAL;
 373                 c.weightx = 1;
 374                 c.gridwidth = 2;
 375                 bag.add(telegps_status, c);
 376                 c.gridwidth = 1;
 377
 378
 379                 /* The rest of the window uses a tabbed pane to
 380                  * show one of the alternate data views
 381                  */
 382                 pane = new JTabbedPane();
 383
 384                 /* Make the tabbed pane use the rest of the window space */
 385                 c.gridx = 0;
 386                 c.gridy = 2;
 387                 c.fill = GridBagConstraints.BOTH;
 388                 c.weightx = 1;
 389                 c.weighty = 1;
 390                 c.gridwidth = 2;
 391                 bag.add(pane, c);
 392
 393                 sitemap = new AltosSiteMap();
 394                 pane.add("Site Map", sitemap);
 395
 396                 setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
 397
 398                 AltosUIPreferences.register_font_listener(this);
 399
 400                 addWindowListener(new WindowAdapter() {
 401                                 @Override
 402                                 public void windowClosing(WindowEvent e) {
 403                                         close();
 404                                 }
 405                         });
 406
 407                 pack();
 408                 setVisible(true);
 409
 410                 ++number_of_windows;
 411
 412                 status_update = new TeleGPSStatusUpdate(telegps_status);
 413
 414                 new javax.swing.Timer(100, status_update).start();
 415         }
 416
 417         public TeleGPS(AltosFlightReader reader) {
 418                 this();
 419                 set_reader(reader);
 420         }
 421
 422         static AltosStateIterable record_iterable(File file) {
 423                 FileInputStream in;
 424                 try {
 425                         in = new FileInputStream(file);
 426                 } catch (Exception e) {
 427                         System.out.printf("Failed to open file '%s'\n", file);
 428                         return null;
 429                 }
 430                 if (file.getName().endsWith("telem"))
 431                         return new AltosTelemetryFile(in);
 432                 else
 433                         return new AltosEepromFile(in);
 434         }
 435
 436         static AltosReplayReader replay_file(File file) {
 437                 AltosStateIterable states = record_iterable(file);
 438                 if (states == null)
 439                         return null;
 440                 return new AltosReplayReader(states.iterator(), file);
 441         }
 442
 443         static boolean process_replay(File file) {
 444                 AltosReplayReader new_reader = replay_file(file);
 445                 if (new_reader == null)
 446                         return false;
 447
 448                 new TeleGPS(new_reader);
 449                 return true;
 450         }
 451
 452         static final int process_none = 0;
 453         static final int process_csv = 1;
 454         static final int process_kml = 2;
 455         static final int process_graph = 3;
 456         static final int process_replay = 4;
 457         static final int process_summary = 5;
 458         static final int process_cat = 6;
 459
 460         public static boolean load_library(Frame frame) {
 461                 if (!AltosUILib.load_library()) {
 462                         JOptionPane.showMessageDialog(frame,
 463                                                       String.format("No AltOS library in \"%s\"",
 464                                                                     System.getProperty("java.library.path","<undefined>")),
 465                                                       "Cannot load device access library",
 466                                                       JOptionPane.ERROR_MESSAGE);
 467                         return false;
 468                 }
 469                 return true;
 470         }
 471
 472         public static void help(int code) {
 473                 System.out.printf("Usage: altosui [OPTION]... [FILE]...\n");
 474                 System.out.printf("  Options:\n");
 475                 System.out.printf("    --fetchmaps <lat> <lon>\tpre-fetch maps for site map view\n");
 476                 System.out.printf("    --replay <filename>\t\trelive the glory of past flights \n");
 477                 System.out.printf("    --graph <filename>\t\tgraph a flight\n");
 478                 System.out.printf("    --csv\tgenerate comma separated output for spreadsheets, etc\n");
 479                 System.out.printf("    --kml\tgenerate KML output for use with Google Earth\n");
 480                 System.exit(code);
 481         }
 482
 483         public static void main(String[] args) {
 484                 int     errors = 0;
 485
 486                 load_library(null);
 487                 try {
 488                         UIManager.setLookAndFeel(AltosUIPreferences.look_and_feel());
 489                 } catch (Exception e) {
 490                 }
 491
 492                 boolean any_created = false;
 493
 494
 495                 /* Handle batch-mode */
 496                 int process = process_none;
 497                 for (int i = 0; i < args.length; i++) {
 498                         if (args[i].equals("--help"))
 499                                 help(0);
 500                         else if (args[i].equals("--fetchmaps")) {
 501                                 if (args.length < i + 3) {
 502                                         help(1);
 503                                 } else {
 504                                         double lat = Double.parseDouble(args[i+1]);
 505                                         double lon = Double.parseDouble(args[i+2]);
 506                                         AltosSiteMap.prefetchMaps(lat, lon);
 507                                         i += 2;
 508                                 }
 509                         } else if (args[i].equals("--replay"))
 510                                 process = process_replay;
 511                         else if (args[i].equals("--kml"))
 512                                 process = process_kml;
 513                         else if (args[i].equals("--csv"))
 514                                 process = process_csv;
 515                         else if (args[i].equals("--graph"))
 516                                 process = process_graph;
 517                         else if (args[i].equals("--summary"))
 518                                 process = process_summary;
 519                         else if (args[i].equals("--cat"))
 520                                 process = process_cat;
 521                         else if (args[i].startsWith("--"))
 522                                 help(1);
 523                         else {
 524                                 File file = new File(args[i]);
 525                                 switch (process) {
 526                                 case process_graph:
 527                                         ++errors;
 528                                         break;
 529                                 case process_none:
 530                                 case process_replay:
 531                                         if (!process_replay(file))
 532                                                 ++errors;
 533                                         any_created = true;
 534                                         break;
 535                                 case process_kml:
 536                                         ++errors;
 537                                         break;
 538                                 case process_csv:
 539                                         ++errors;
 540                                         break;
 541                                 case process_summary:
 542                                         ++errors;
 543                                         break;
 544                                 case process_cat:
 545                                         ++errors;
 546                                 }
 547                         }
 548                 }
 549                 if (errors != 0)
 550                         System.exit(errors);
 551                 if (!any_created)
 552                         new TeleGPS();
 553         }
 554 }