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; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  */
  18
  19 package org.altusmetrum.telegps;
  20
  21 import java.awt.*;
  22 import java.awt.event.*;
  23 import javax.swing.*;
  24 import java.io.*;
  25 import java.util.concurrent.*;
  26 import java.util.*;
  27 import java.text.*;
  28 import org.altusmetrum.altoslib_11.*;
  29 import org.altusmetrum.altosuilib_11.*;
  30
  31 public class TeleGPS
  32         extends AltosUIFrame
  33         implements AltosFlightDisplay, AltosFontListener, AltosUnitsListener, ActionListener
  34 {
  35
  36         static String[] telegps_icon_names = {
  37                 "/altusmetrum-telegps-16.png",
  38                 "/altusmetrum-telegps-32.png",
  39                 "/altusmetrum-telegps-48.png",
  40                 "/altusmetrum-telegps-64.png",
  41                 "/altusmetrum-telegps-128.png",
  42                 "/altusmetrum-telegps-256.png"
  43         };
  44
  45         static { set_icon_names(telegps_icon_names); }
  46
  47         static AltosVoice       voice;
  48
  49         static AltosVoice voice() {
  50                 if (voice == null)
  51                         voice = new AltosVoice();
  52                 return voice;
  53         }
  54
  55         AltosFlightReader       reader;
  56         TeleGPSDisplayThread    thread;
  57         boolean                 idle_mode;
  58
  59         JMenuBar                menu_bar;
  60
  61         JMenu                   file_menu;
  62         JMenu                   monitor_menu;
  63         JMenu                   device_menu;
  64         AltosUIFreqList         frequencies;
  65         ActionListener          frequency_listener;
  66         AltosUIRateList         rates;
  67         ActionListener          rate_listener;
  68
  69         Container               bag;
  70
  71         TeleGPSStatus           telegps_status;
  72         TeleGPSStatusUpdate     status_update;
  73
  74         JTabbedPane             pane;
  75
  76         AltosUIMap              map;
  77         TeleGPSInfo             gps_info;
  78         TeleGPSState            gps_state;
  79         AltosInfoTable          info_table;
  80
  81         LinkedList<AltosFlightDisplay>  displays;
  82
  83         /* File menu */
  84         final static String     new_command = "new";
  85         final static String     graph_command = "graph";
  86         final static String     export_command = "export";
  87         final static String     load_maps_command = "loadmaps";
  88         final static String     preferences_command = "preferences";
  89         final static String     close_command = "close";
  90         final static String     exit_command = "exit";
  91
  92         static final String[][] file_menu_entries = new String[][] {
  93                 { "New Window",         new_command },
  94                 { "Graph Data",         graph_command },
  95                 { "Export Data",        export_command },
  96                 { "Load Maps",          load_maps_command },
  97                 { "Preferences",        preferences_command },
  98                 { "Close",              close_command },
  99                 { "Exit",               exit_command },
 100         };
 101
 102         /* Monitor menu */
 103         final static String     connect_command = "connect";
 104         final static String     disconnect_command = "disconnect";
 105         final static String     scan_command = "scan";
 106
 107         static final String[][] monitor_menu_entries = new String[][] {
 108                 { "Connect Device",     connect_command },
 109                 { "Disconnect",         disconnect_command },
 110                 { "Scan Channels",      scan_command },
 111         };
 112
 113         /* Device menu */
 114         final static String     download_command = "download";
 115         final static String     configure_command = "configure";
 116         final static String     flash_command = "flash";
 117
 118         static final String[][] device_menu_entries = new String[][] {
 119                 { "Download Data",      download_command },
 120                 { "Configure Device",   configure_command },
 121                 { "Flash Device",       flash_command },
 122         };
 123
 124         void stop_display() {
 125                 if (thread != null && thread.isAlive()) {
 126                         thread.interrupt();
 127                         try {
 128                                 thread.join();
 129                         } catch (InterruptedException ie) {}
 130                 }
 131                 thread = null;
 132         }
 133
 134         public void reset() {
 135                 for (AltosFlightDisplay display : displays)
 136                         display.reset();
 137         }
 138
 139         public void font_size_changed(int font_size) {
 140                 for (AltosFlightDisplay display : displays)
 141                         display.font_size_changed(font_size);
 142         }
 143
 144         public void units_changed(boolean imperial_units) {
 145                 for (AltosFlightDisplay display : displays)
 146                         display.units_changed(imperial_units);
 147         }
 148
 149         public void show(AltosState state, AltosListenerState listener_state) {
 150                 try {
 151                         status_update.saved_state = state;
 152                         status_update.saved_listener_state = listener_state;
 153
 154                         if (state == null)
 155                                 state = new AltosState(new AltosCalData());
 156
 157                         int i = 0;
 158                         for (AltosFlightDisplay display : displays) {
 159                                 display.show(state, listener_state);
 160                                 i++;
 161                         }
 162                 } catch (Exception ex) {
 163                         System.out.printf("Exception %s\n", ex.toString());
 164                         for (StackTraceElement e : ex.getStackTrace())
 165                                 System.out.printf("%s\n", e.toString());
 166                 }
 167         }
 168
 169         void new_window() {
 170                 new TeleGPS();
 171         }
 172
 173         void preferences() {
 174                 new TeleGPSPreferences(this, voice());
 175         }
 176
 177         void load_maps() {
 178                 new AltosUIMapPreload(this);
 179         }
 180
 181         void disconnect() {
 182                 setTitle("TeleGPS");
 183                 stop_display();
 184                 telegps_status.stop();
 185
 186                 telegps_status.disable_receive();
 187                 disable_frequency_menu();
 188                 disable_rate_menu();
 189         }
 190
 191         void connect_flight(AltosDevice device) {
 192                 try {
 193                         AltosFlightReader       reader = new AltosTelemetryReader(new AltosSerial(device));
 194                         set_reader(reader, device, false);
 195                 } catch (FileNotFoundException ee) {
 196                         JOptionPane.showMessageDialog(this,
 197                                                       ee.getMessage(),
 198                                                       String.format ("Cannot open %s", device.toShortString()),
 199                                                       JOptionPane.ERROR_MESSAGE);
 200                 } catch (AltosSerialInUseException si) {
 201                         JOptionPane.showMessageDialog(this,
 202                                                       String.format("Device \"%s\" already in use",
 203                                                                     device.toShortString()),
 204                                                       "Device in use",
 205                                                       JOptionPane.ERROR_MESSAGE);
 206                 } catch (IOException ee) {
 207                         JOptionPane.showMessageDialog(this,
 208                                                       String.format ("Unknown I/O error on %s", device.toShortString()),
 209                                                       "Unknown I/O error",
 210                                                       JOptionPane.ERROR_MESSAGE);
 211                 } catch (TimeoutException te) {
 212                         JOptionPane.showMessageDialog(this,
 213                                                       String.format ("Timeout on %s", device.toShortString()),
 214                                                       "Timeout error",
 215                                                       JOptionPane.ERROR_MESSAGE);
 216                 } catch (InterruptedException ie) {
 217                         JOptionPane.showMessageDialog(this,
 218                                                       String.format("Interrupted %s", device.toShortString()),
 219                                                       "Interrupted exception",
 220                                                       JOptionPane.ERROR_MESSAGE);
 221                 }
 222         }
 223
 224         void connect_idle(AltosDevice device) {
 225                 try {
 226                         AltosFlightReader       reader = new AltosIdleReader(new AltosSerial(device), false);
 227                         set_reader(reader, device, true);
 228                 } catch (FileNotFoundException ee) {
 229                         JOptionPane.showMessageDialog(this,
 230                                                       ee.getMessage(),
 231                                                       String.format ("Cannot open %s", device.toShortString()),
 232                                                       JOptionPane.ERROR_MESSAGE);
 233                 } catch (AltosSerialInUseException si) {
 234                         JOptionPane.showMessageDialog(this,
 235                                                       String.format("Device \"%s\" already in use",
 236                                                                     device.toShortString()),
 237                                                       "Device in use",
 238                                                       JOptionPane.ERROR_MESSAGE);
 239                 } catch (IOException ee) {
 240                         JOptionPane.showMessageDialog(this,
 241                                                       String.format ("Unknown I/O error on %s", device.toShortString()),
 242                                                       "Unknown I/O error",
 243                                                       JOptionPane.ERROR_MESSAGE);
 244                 } catch (TimeoutException te) {
 245                         JOptionPane.showMessageDialog(this,
 246                                                       String.format ("Timeout on %s", device.toShortString()),
 247                                                       "Timeout error",
 248                                                       JOptionPane.ERROR_MESSAGE);
 249                 } catch (InterruptedException ie) {
 250                         JOptionPane.showMessageDialog(this,
 251                                                       String.format("Interrupted %s", device.toShortString()),
 252                                                       "Interrupted exception",
 253                                                       JOptionPane.ERROR_MESSAGE);
 254                 }
 255         }
 256
 257         void connect(AltosDevice device) {
 258                 if (reader != null)
 259                         disconnect();
 260                 if (device.matchProduct(AltosLib.product_basestation))
 261                         connect_flight(device);
 262                 else
 263                         connect_idle(device);
 264         }
 265
 266         void connect() {
 267                 AltosDevice     device = AltosDeviceUIDialog.show(this,
 268                                                                   AltosLib.product_any);
 269                 if (device == null)
 270                         return;
 271                 connect(device);
 272         }
 273
 274         public void scan_device_selected(AltosDevice device) {
 275                 connect(device);
 276         }
 277
 278         void scan() {
 279                 new AltosScanUI(this, false);
 280         }
 281
 282         void download(){
 283                 new AltosEepromManage(this, AltosLib.product_telegps);
 284         }
 285
 286         void configure() {
 287                 new TeleGPSConfig(this);
 288         }
 289
 290         private static AltosFlightSeries make_series(AltosRecordSet set) {
 291                 AltosFlightSeries series = new AltosFlightSeries(set.cal_data());
 292                 set.capture_series(series);
 293                 series.finish();
 294                 return series;
 295         }
 296
 297         void export() {
 298                 AltosDataChooser chooser = new AltosDataChooser(this);
 299
 300                 AltosRecordSet set = chooser.runDialog();
 301                 if (set == null)
 302                         return;
 303                 AltosFlightSeries series = make_series(set);
 304                 new AltosCSVUI(this, series, series.cal_data, chooser.file());
 305         }
 306
 307         void graph() {
 308                 AltosDataChooser chooser = new AltosDataChooser(this);
 309                 AltosRecordSet set = chooser.runDialog();
 310                 if (set == null)
 311                         return;
 312                 try {
 313                         new TeleGPSGraphUI(set, chooser.file());
 314                 } catch (InterruptedException ie) {
 315                 } catch (IOException ie) {
 316                 }
 317         }
 318
 319         void flash() {
 320                 AltosFlashUI.show(this);
 321         }
 322
 323         public void actionPerformed(ActionEvent ev) {
 324
 325                 /* File menu */
 326                 if (new_command.equals(ev.getActionCommand())) {
 327                         new_window();
 328                         return;
 329                 }
 330                 if (preferences_command.equals(ev.getActionCommand())) {
 331                         preferences();
 332                         return;
 333                 }
 334                 if (load_maps_command.equals(ev.getActionCommand())) {
 335                         load_maps();
 336                         return;
 337                 }
 338                 if (close_command.equals(ev.getActionCommand())) {
 339                         close();
 340                         return;
 341                 }
 342                 if (exit_command.equals(ev.getActionCommand()))
 343                         System.exit(0);
 344
 345                 /* Monitor menu */
 346                 if (connect_command.equals(ev.getActionCommand())) {
 347                         connect();
 348                         return;
 349                 }
 350                 if (disconnect_command.equals(ev.getActionCommand())) {
 351                         disconnect();
 352                         return;
 353                 }
 354                 if (scan_command.equals(ev.getActionCommand())) {
 355                         scan();
 356                         return;
 357                 }
 358
 359                 /* Device menu */
 360                 if (download_command.equals(ev.getActionCommand())) {
 361                         download();
 362                         return;
 363                 }
 364                 if (configure_command.equals(ev.getActionCommand())) {
 365                         configure();
 366                         return;
 367                 }
 368                 if (export_command.equals(ev.getActionCommand())) {
 369                         export();
 370                         return;
 371                 }
 372                 if (graph_command.equals(ev.getActionCommand())) {
 373                         graph();
 374                         return;
 375                 }
 376                 if (flash_command.equals(ev.getActionCommand())) {
 377                         flash();
 378                         return;
 379                 }
 380         }
 381
 382         void enable_frequency_menu(int serial, final AltosFlightReader reader) {
 383
 384                 if (frequency_listener != null)
 385                         disable_frequency_menu();
 386
 387                 frequency_listener = new ActionListener() {
 388                                 public void actionPerformed(ActionEvent e) {
 389                                         double frequency = frequencies.frequency();
 390                                         try {
 391                                                 reader.set_frequency(frequency);
 392                                         } catch (TimeoutException te) {
 393                                         } catch (InterruptedException ie) {
 394                                         }
 395                                         reader.save_frequency();
 396                                 }
 397                         };
 398
 399                 frequencies.addActionListener(frequency_listener);
 400                 frequencies.set_product("Monitor");
 401                 frequencies.set_serial(serial);
 402                 frequencies.set_frequency(AltosUIPreferences.frequency(serial));
 403                 frequencies.setEnabled(true);
 404
 405         }
 406
 407         void disable_frequency_menu() {
 408                 if (frequency_listener != null) {
 409                         frequencies.removeActionListener(frequency_listener);
 410                         frequencies.setEnabled(false);
 411                         frequency_listener = null;
 412                 }
 413
 414         }
 415
 416         void enable_rate_menu(int serial, final AltosFlightReader reader) {
 417
 418                 if (rate_listener != null)
 419                         disable_rate_menu();
 420
 421                 rate_listener = new ActionListener() {
 422                                 public void actionPerformed(ActionEvent e) {
 423                                         int rate = rates.rate();
 424                                         try {
 425                                                 reader.set_telemetry_rate(rate);
 426                                         } catch (TimeoutException te) {
 427                                         } catch (InterruptedException ie) {
 428                                         }
 429                                         reader.save_telemetry_rate();
 430                                 }
 431                         };
 432
 433                 rates.addActionListener(rate_listener);
 434                 rates.set_product("Monitor");
 435                 rates.set_serial(serial);
 436                 rates.set_rate(AltosUIPreferences.telemetry_rate(serial));
 437                 rates.setEnabled(reader.supports_telemetry_rate(AltosLib.ao_telemetry_rate_2400));
 438         }
 439
 440         void disable_rate_menu() {
 441                 if (rate_listener != null) {
 442                         rates.removeActionListener(rate_listener);
 443                         rates.setEnabled(false);
 444                         rate_listener = null;
 445                 }
 446
 447         }
 448
 449         public void set_reader(AltosFlightReader reader, AltosDevice device, boolean idle_mode) {
 450                 this.idle_mode = idle_mode;
 451                 status_update = new TeleGPSStatusUpdate(telegps_status);
 452
 453                 telegps_status.start(status_update);
 454
 455                 setTitle(String.format("TeleGPS %s", reader.name));
 456                 thread = new TeleGPSDisplayThread(this, voice(), this, reader);
 457                 thread.start();
 458
 459                 if (device != null) {
 460                         if (idle_mode) {
 461                                 disable_frequency_menu();
 462                                 disable_rate_menu();
 463                         } else {
 464                                 enable_frequency_menu(device.getSerial(), reader);
 465                                 enable_rate_menu(device.getSerial(), reader);
 466                         }
 467                 }
 468         }
 469
 470         static int      number_of_windows;
 471
 472         static public void add_window() {
 473                 ++number_of_windows;
 474         }
 475
 476         static public void subtract_window() {
 477                 --number_of_windows;
 478                 if (number_of_windows == 0)
 479                         System.exit(0);
 480         }
 481
 482         private void close() {
 483                 disconnect();
 484                 AltosUIPreferences.unregister_font_listener(this);
 485                 AltosPreferences.unregister_units_listener(this);
 486                 setVisible(false);
 487                 dispose();
 488                 subtract_window();
 489         }
 490
 491         private void add_menu(JMenu menu, String label, String action) {
 492                 JMenuItem       item = new JMenuItem(label);
 493                 menu.add(item);
 494                 item.addActionListener(this);
 495                 item.setActionCommand(action);
 496         }
 497
 498
 499         private JMenu make_menu(String label, String[][] items) {
 500                 JMenu   menu = new JMenu(label);
 501                 for (int i = 0; i < items.length; i++) {
 502                         if (MAC_OS_X) {
 503                                 if (items[i][1].equals("exit"))
 504                                         continue;
 505                                 if (items[i][1].equals("preferences"))
 506                                         continue;
 507                         }
 508                         add_menu(menu, items[i][0], items[i][1]);
 509                 }
 510                 menu_bar.add(menu);
 511                 return menu;
 512         }
 513
 514         /* OSXAdapter interfaces */
 515         public void macosx_file_handler(String path) {
 516                 process_graph(new File(path));
 517         }
 518
 519         public void macosx_quit_handler() {
 520                 System.exit(0);
 521         }
 522
 523         public void macosx_preferences_handler() {
 524                 preferences();
 525         }
 526
 527         public TeleGPS() {
 528
 529                 AltosUIPreferences.set_component(this);
 530
 531                 register_for_macosx_events();
 532
 533                 reader = null;
 534
 535                 bag = getContentPane();
 536                 bag.setLayout(new GridBagLayout());
 537
 538                 setTitle("TeleGPS");
 539
 540                 menu_bar = new JMenuBar();
 541                 setJMenuBar(menu_bar);
 542
 543                 file_menu = make_menu("File", file_menu_entries);
 544                 monitor_menu = make_menu("Monitor", monitor_menu_entries);
 545                 device_menu = make_menu("Device", device_menu_entries);
 546
 547                 set_inset(3);
 548                 frequencies = new AltosUIFreqList();
 549                 frequencies.setEnabled(false);
 550                 bag.add(frequencies, constraints (0, 1));
 551
 552                 rates = new AltosUIRateList();
 553                 rates.setEnabled(false);
 554                 bag.add(rates, constraints(1, 1));
 555                 next_row();
 556                 set_inset(0);
 557
 558                 displays = new LinkedList<AltosFlightDisplay>();
 559
 560                 int serial = -1;
 561
 562                 /* TeleGPS status is always visible */
 563                 telegps_status = new TeleGPSStatus();
 564                 bag.add(telegps_status, constraints(0, 3, GridBagConstraints.HORIZONTAL));
 565                 next_row();
 566
 567                 displays.add(telegps_status);
 568
 569
 570                 /* The rest of the window uses a tabbed pane to
 571                  * show one of the alternate data views
 572                  */
 573                 pane = new JTabbedPane();
 574
 575                 /* Make the tabbed pane use the rest of the window space */
 576                 bag.add(pane, constraints(0, 3, GridBagConstraints.BOTH));
 577
 578                 map = new AltosUIMap();
 579                 pane.add(map.getName(), map);
 580                 displays.add(map);
 581
 582                 gps_info = new TeleGPSInfo();
 583                 pane.add(gps_info.getName(), gps_info);
 584                 displays.add(gps_info);
 585
 586                 gps_state = new TeleGPSState();
 587                 pane.add(gps_state.getName(), gps_state);
 588                 displays.add(gps_state);
 589
 590                 info_table = new AltosInfoTable();
 591                 pane.add("Table", info_table);
 592                 displays.add(info_table);
 593
 594                 setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
 595
 596                 AltosUIPreferences.register_font_listener(this);
 597                 AltosPreferences.register_units_listener(this);
 598
 599                 addWindowListener(new WindowAdapter() {
 600                                 @Override
 601                                 public void windowClosing(WindowEvent e) {
 602                                         close();
 603                                 }
 604                         });
 605
 606                 pack();
 607                 setVisible(true);
 608
 609                 add_window();
 610         }
 611
 612         public TeleGPS(AltosFlightReader reader, boolean idle_mode) {
 613                 this();
 614                 set_reader(reader, null, idle_mode);
 615         }
 616
 617         public TeleGPS(AltosDevice device) {
 618                 this();
 619                 connect(device);
 620         }
 621
 622         static AltosRecordSet record_set(File file) {
 623                 FileInputStream in;
 624                 if (file.getName().endsWith("telem")) {
 625                         try {
 626                                 in = new FileInputStream(file);
 627                                 return new AltosTelemetryFile(in);
 628                         } catch (Exception e) {
 629                                 System.out.printf("Failed to open file '%s'\n", file);
 630                         }
 631                 } else {
 632
 633                         try {
 634                                 return new AltosEepromFile(new FileReader(file));
 635                         } catch (Exception e) {
 636                                 System.out.printf("Failed to open file '%s'\n", file);
 637                         }
 638                 }
 639                 return null;
 640         }
 641
 642         static AltosReplayReader replay_file(File file) {
 643                 AltosRecordSet set = record_set(file);
 644                 if (set == null)
 645                         return null;
 646                 return new AltosReplayReader(set, file);
 647         }
 648
 649         static boolean process_graph(File file) {
 650                 AltosRecordSet set = record_set(file);
 651                 if (set == null)
 652                         return false;
 653                 try {
 654                         new TeleGPSGraphUI(set, file);
 655                 } catch (Exception e) {
 656                         return false;
 657                 }
 658                 return true;
 659         }
 660
 661         static boolean process_replay(File file) {
 662                 AltosReplayReader new_reader = replay_file(file);
 663                 if (new_reader == null)
 664                         return false;
 665
 666                 new TeleGPS(new_reader, true);
 667                 return true;
 668         }
 669
 670         static final int process_none = 0;
 671         static final int process_csv = 1;
 672         static final int process_kml = 2;
 673         static final int process_graph = 3;
 674         static final int process_replay = 4;
 675         static final int process_summary = 5;
 676         static final int process_cat = 6;
 677
 678         public static boolean load_library(Frame frame) {
 679                 if (!AltosUILib.load_library()) {
 680                         JOptionPane.showMessageDialog(frame,
 681                                                       String.format("No AltOS library in \"%s\"",
 682                                                                     System.getProperty("java.library.path","<undefined>")),
 683                                                       "Cannot load device access library",
 684                                                       JOptionPane.ERROR_MESSAGE);
 685                         return false;
 686                 }
 687                 return true;
 688         }
 689
 690         public static void help(int code) {
 691                 System.out.printf("Usage: altosui [OPTION]... [FILE]...\n");
 692                 System.out.printf("  Options:\n");
 693                 System.out.printf("    --replay <filename>\t\trelive the glory of past flights \n");
 694                 System.out.printf("    --graph <filename>\t\tgraph a flight\n");
 695                 System.out.printf("    --csv\tgenerate comma separated output for spreadsheets, etc\n");
 696                 System.out.printf("    --kml\tgenerate KML output for use with Google Earth\n");
 697                 System.exit(code);
 698         }
 699
 700         public static void main(String[] args) {
 701                 int     errors = 0;
 702
 703                 load_library(null);
 704                 try {
 705                         UIManager.setLookAndFeel(AltosUIPreferences.look_and_feel());
 706                 } catch (Exception e) {
 707                 }
 708
 709                 boolean any_created = false;
 710
 711
 712                 /* Handle batch-mode */
 713                 int process = process_none;
 714                 for (int i = 0; i < args.length; i++) {
 715                         if (args[i].equals("--help"))
 716                                 help(0);
 717                         else if (args[i].equals("--replay"))
 718                                 process = process_replay;
 719                         else if (args[i].equals("--kml"))
 720                                 process = process_kml;
 721                         else if (args[i].equals("--csv"))
 722                                 process = process_csv;
 723                         else if (args[i].equals("--graph"))
 724                                 process = process_graph;
 725                         else if (args[i].equals("--summary"))
 726                                 process = process_summary;
 727                         else if (args[i].equals("--cat"))
 728                                 process = process_cat;
 729                         else if (args[i].startsWith("--"))
 730                                 help(1);
 731                         else {
 732                                 File file = new File(args[i]);
 733                                 switch (process) {
 734                                 case process_none:
 735                                 case process_graph:
 736                                         if (!process_graph(file))
 737                                                 ++errors;
 738                                         break;
 739                                 case process_replay:
 740                                         if (!process_replay(file))
 741                                                 ++errors;
 742                                         any_created = true;
 743                                         break;
 744                                 case process_kml:
 745                                         ++errors;
 746                                         break;
 747                                 case process_csv:
 748                                         ++errors;
 749                                         break;
 750                                 case process_summary:
 751                                         ++errors;
 752                                         break;
 753                                 case process_cat:
 754                                         ++errors;
 755                                 }
 756                         }
 757                 }
 758                 if (errors != 0)
 759                         System.exit(errors);
 760                 if (number_of_windows == 0) {
 761                         java.util.List<AltosDevice> devices = AltosUSBDevice.list(AltosLib.product_basestation);
 762                         if (devices != null)
 763                                 for (AltosDevice device : devices) {
 764                                         new TeleGPS(device);
 765                                         any_created = true;
 766                                 }
 767                         if (number_of_windows == 0)
 768                                 new TeleGPS();
 769                 }
 770         }
 771 }