src/jalview/bin/Jalview.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.bin;
  22
  23 import java.awt.Color;
  24 import java.io.BufferedReader;
  25 import java.io.File;
  26 import java.io.FileOutputStream;
  27 import java.io.IOException;
  28 import java.io.InputStreamReader;
  29 import java.io.OutputStream;
  30 import java.io.OutputStreamWriter;
  31 import java.io.PrintStream;
  32 import java.io.PrintWriter;
  33 import java.net.MalformedURLException;
  34 import java.net.URI;
  35 import java.net.URISyntaxException;
  36 import java.net.URL;
  37 import java.security.AllPermission;
  38 import java.security.CodeSource;
  39 import java.security.PermissionCollection;
  40 import java.security.Permissions;
  41 import java.security.Policy;
  42 import java.util.ArrayList;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Locale;
  46 import java.util.Map;
  47 import java.util.Properties;
  48 import java.util.Vector;
  49 import java.util.logging.ConsoleHandler;
  50 import java.util.logging.Level;
  51 import java.util.logging.Logger;
  52 import java.util.stream.Collectors;
  53
  54 import javax.swing.JDialog;
  55 import javax.swing.JFrame;
  56 import javax.swing.JInternalFrame;
  57 import javax.swing.JOptionPane;
  58 import javax.swing.SwingUtilities;
  59 import javax.swing.UIManager;
  60 import javax.swing.UIManager.LookAndFeelInfo;
  61 import javax.swing.UnsupportedLookAndFeelException;
  62
  63 import com.formdev.flatlaf.FlatLightLaf;
  64 import com.formdev.flatlaf.themes.FlatMacLightLaf;
  65 import com.formdev.flatlaf.util.SystemInfo;
  66 import com.threerings.getdown.util.LaunchUtil;
  67
  68 //import edu.stanford.ejalbert.launching.IBrowserLaunching;
  69 import groovy.lang.Binding;
  70 import groovy.util.GroovyScriptEngine;
  71 import jalview.bin.argparser.Arg;
  72 import jalview.bin.argparser.Arg.Opt;
  73 import jalview.bin.argparser.Arg.Type;
  74 import jalview.bin.argparser.ArgParser;
  75 import jalview.bin.argparser.BootstrapArgs;
  76 import jalview.ext.so.SequenceOntology;
  77 import jalview.gui.AlignFrame;
  78 import jalview.gui.Desktop;
  79 import jalview.gui.PromptUserConfig;
  80 import jalview.gui.QuitHandler;
  81 import jalview.gui.QuitHandler.QResponse;
  82 import jalview.gui.StructureViewerBase;
  83 import jalview.io.AppletFormatAdapter;
  84 import jalview.io.BioJsHTMLOutput;
  85 import jalview.io.DataSourceType;
  86 import jalview.io.FileFormat;
  87 import jalview.io.FileFormatException;
  88 import jalview.io.FileFormatI;
  89 import jalview.io.FileFormats;
  90 import jalview.io.FileLoader;
  91 import jalview.io.HtmlSvgOutput;
  92 import jalview.io.IdentifyFile;
  93 import jalview.io.NewickFile;
  94 import jalview.io.exceptions.ImageOutputException;
  95 import jalview.io.gff.SequenceOntologyFactory;
  96 import jalview.schemes.ColourSchemeI;
  97 import jalview.schemes.ColourSchemeProperty;
  98 import jalview.util.ChannelProperties;
  99 import jalview.util.HttpUtils;
 100 import jalview.util.LaunchUtils;
 101 import jalview.util.MessageManager;
 102 import jalview.util.Platform;
 103 import jalview.ws.jws2.Jws2Discoverer;
 104
 105 /**
 106  * Main class for Jalview Application <br>
 107  * <br>
 108  * start with: java -classpath "$PATH_TO_LIB$/*:$PATH_TO_CLASSES$" \
 109  * jalview.bin.Jalview
 110  *
 111  * or on Windows: java -classpath "$PATH_TO_LIB$/*;$PATH_TO_CLASSES$" \
 112  * jalview.bin.Jalview jalview.bin.Jalview
 113  *
 114  * (ensure -classpath arg is quoted to avoid shell expansion of '*' and do not
 115  * embellish '*' to e.g. '*.jar')
 116  *
 117  * @author $author$
 118  * @version $Revision$
 119  */
 120 public class Jalview
 121 {
 122   static
 123   {
 124     Platform.getURLCommandArguments();
 125     Platform.addJ2SDirectDatabaseCall("https://www.jalview.org");
 126     Platform.addJ2SDirectDatabaseCall("http://www.jalview.org");
 127     Platform.addJ2SDirectDatabaseCall("http://www.compbio.dundee.ac.uk");
 128     Platform.addJ2SDirectDatabaseCall("https://www.compbio.dundee.ac.uk");
 129   }
 130
 131   /*
 132    * singleton instance of this class
 133    */
 134   private static Jalview instance;
 135
 136   private Desktop desktop;
 137
 138   protected Commands cmds;
 139
 140   public static AlignFrame currentAlignFrame;
 141
 142   public ArgParser argparser = null;
 143
 144   public BootstrapArgs bootstrapArgs = null;
 145
 146   private boolean QUIET = false;
 147
 148   public static boolean quiet()
 149   {
 150     return Jalview.getInstance() != null && Jalview.getInstance().QUIET;
 151   }
 152
 153   static
 154   {
 155     if (!Platform.isJS())
 156     /**
 157      * Java only
 158      *
 159      * @j2sIgnore
 160      */
 161     {
 162       // grab all the rights we can for the JVM
 163       Policy.setPolicy(new Policy()
 164       {
 165         @Override
 166         public PermissionCollection getPermissions(CodeSource codesource)
 167         {
 168           Permissions perms = new Permissions();
 169           perms.add(new AllPermission());
 170           return (perms);
 171         }
 172
 173         @Override
 174         public void refresh()
 175         {
 176         }
 177       });
 178     }
 179   }
 180
 181   /**
 182    * keep track of feature fetching tasks.
 183    *
 184    * @author JimP
 185    *
 186    */
 187   class FeatureFetcher
 188   {
 189     /*
 190      * TODO: generalise to track all jalview events to orchestrate batch processing
 191      * events.
 192      */
 193
 194     private int queued = 0;
 195
 196     private int running = 0;
 197
 198     public FeatureFetcher()
 199     {
 200
 201     }
 202
 203     public void addFetcher(final AlignFrame af,
 204             final Vector<String> dasSources)
 205     {
 206       final long id = System.currentTimeMillis();
 207       queued++;
 208       final FeatureFetcher us = this;
 209       new Thread(new Runnable()
 210       {
 211
 212         @Override
 213         public void run()
 214         {
 215           synchronized (us)
 216           {
 217             queued--;
 218             running++;
 219           }
 220
 221           af.setProgressBar(MessageManager
 222                   .getString("status.das_features_being_retrived"), id);
 223           af.featureSettings_actionPerformed(null);
 224           af.setProgressBar(null, id);
 225           synchronized (us)
 226           {
 227             running--;
 228           }
 229         }
 230       }).start();
 231     }
 232
 233     public synchronized boolean allFinished()
 234     {
 235       return queued == 0 && running == 0;
 236     }
 237
 238   }
 239
 240   public static Jalview getInstance()
 241   {
 242     return instance;
 243   }
 244
 245   /**
 246    * main class for Jalview application
 247    *
 248    * @param args
 249    *          open <em>filename</em>
 250    */
 251   public static void main(String[] args)
 252   {
 253     // setLogging(); // BH - for event debugging in JavaScript
 254     instance = new Jalview();
 255     instance.doMain(args);
 256   }
 257
 258   private static void logClass(String name)
 259   {
 260     // BH - for event debugging in JavaScript
 261     ConsoleHandler consoleHandler = new ConsoleHandler();
 262     consoleHandler.setLevel(Level.ALL);
 263     Logger logger = Logger.getLogger(name);
 264     logger.setLevel(Level.ALL);
 265     logger.addHandler(consoleHandler);
 266   }
 267
 268   @SuppressWarnings("unused")
 269   private static void setLogging()
 270   {
 271
 272     /**
 273      * @j2sIgnore
 274      *
 275      */
 276     {
 277       System.out.println("not in js");
 278     }
 279
 280     // BH - for event debugging in JavaScript (Java mode only)
 281     if (!Platform.isJS())
 282     /**
 283      * Java only
 284      *
 285      * @j2sIgnore
 286      */
 287     {
 288       Logger.getLogger("").setLevel(Level.ALL);
 289       logClass("java.awt.EventDispatchThread");
 290       logClass("java.awt.EventQueue");
 291       logClass("java.awt.Component");
 292       logClass("java.awt.focus.Component");
 293       logClass("java.awt.focus.DefaultKeyboardFocusManager");
 294     }
 295
 296   }
 297
 298   /**
 299    * @param args
 300    */
 301   void doMain(String[] args)
 302   {
 303     if (!Platform.isJS())
 304     {
 305       System.setSecurityManager(null);
 306     }
 307
 308     if (args == null || args.length == 0 || (args.length == 1
 309             && (args[0] == null || args[0].length() == 0)))
 310     {
 311       args = new String[] {};
 312     }
 313
 314     // get args needed before proper ArgParser
 315     bootstrapArgs = BootstrapArgs.getBootstrapArgs(args);
 316
 317     if (!Platform.isJS())
 318     {
 319       // are we being --quiet ?
 320       if (bootstrapArgs.contains(Arg.QUIET))
 321       {
 322         QUIET = true;
 323         OutputStream devNull = new OutputStream()
 324         {
 325
 326           @Override
 327           public void write(int b)
 328           {
 329             // DO NOTHING
 330           }
 331         };
 332         System.setOut(new PrintStream(devNull));
 333         // redirecting stderr not working
 334         if (bootstrapArgs.getList(Arg.QUIET).size() > 1)
 335         {
 336           System.setErr(new PrintStream(devNull));
 337         }
 338       }
 339
 340       if (bootstrapArgs.contains(Arg.HELP)
 341               || bootstrapArgs.contains(Arg.VERSION))
 342       {
 343         QUIET = true;
 344       }
 345     }
 346
 347     // set individual session preferences
 348     if (bootstrapArgs.contains(Arg.P))
 349     {
 350       for (String kev : bootstrapArgs.getValueList(Arg.P))
 351       {
 352         if (kev == null)
 353         {
 354           continue;
 355         }
 356         int equalsIndex = kev.indexOf(ArgParser.EQUALS);
 357         if (equalsIndex > -1)
 358         {
 359           String key = kev.substring(0, equalsIndex);
 360           String val = kev.substring(equalsIndex + 1);
 361           Cache.setSessionProperty(key, val);
 362         }
 363       }
 364     }
 365
 366     // Move any new getdown-launcher-new.jar into place over old
 367     // getdown-launcher.jar
 368     String appdirString = System.getProperty("getdownappdir");
 369     if (appdirString != null && appdirString.length() > 0)
 370     {
 371       final File appdir = new File(appdirString);
 372       new Thread()
 373       {
 374
 375         @Override
 376         public void run()
 377         {
 378           LaunchUtil.upgradeGetdown(
 379                   new File(appdir, "getdown-launcher-old.jar"),
 380                   new File(appdir, "getdown-launcher.jar"),
 381                   new File(appdir, "getdown-launcher-new.jar"));
 382         }
 383       }.start();
 384     }
 385
 386     if (!quiet() || bootstrapArgs.contains(Arg.VERSION))
 387     {
 388       System.out.println(
 389               "Java version: " + System.getProperty("java.version"));
 390       System.out.println("Java home: " + System.getProperty("java.home"));
 391       System.out.println("Java arch: " + System.getProperty("os.arch") + " "
 392               + System.getProperty("os.name") + " "
 393               + System.getProperty("os.version"));
 394
 395       String val = System.getProperty("sys.install4jVersion");
 396       if (val != null)
 397       {
 398         System.out.println("Install4j version: " + val);
 399       }
 400       val = System.getProperty("installer_template_version");
 401       if (val != null)
 402       {
 403         System.out.println("Install4j template version: " + val);
 404       }
 405       val = System.getProperty("launcher_version");
 406       if (val != null)
 407       {
 408         System.out.println("Launcher version: " + val);
 409       }
 410     }
 411
 412     if (Platform.isLinux() && LaunchUtils.getJavaVersion() < 11)
 413     {
 414       System.setProperty("flatlaf.uiScale", "1");
 415     }
 416
 417     // get bootstrap properties (mainly for the logger level)
 418     Properties bootstrapProperties = Cache
 419             .bootstrapProperties(bootstrapArgs.getValue(Arg.PROPS));
 420
 421     // report Jalview version
 422     Cache.loadBuildProperties(
 423             !quiet() || bootstrapArgs.contains(Arg.VERSION));
 424
 425     // stop now if only after --version
 426     if (bootstrapArgs.contains(Arg.VERSION))
 427     {
 428       Jalview.exit(null, 0);
 429     }
 430
 431     // old ArgsParser
 432     ArgsParser aparser = new ArgsParser(args);
 433
 434     // old
 435     boolean headless = false;
 436     // new
 437     boolean headlessArg = false;
 438
 439     try
 440     {
 441       String logLevel = null;
 442       if (bootstrapArgs.contains(Arg.TRACE))
 443       {
 444         logLevel = "TRACE";
 445       }
 446       else if (bootstrapArgs.contains(Arg.DEBUG))
 447       {
 448         logLevel = "DEBUG";
 449       }
 450       if (logLevel == null && !(bootstrapProperties == null))
 451       {
 452         logLevel = bootstrapProperties.getProperty(Cache.JALVIEWLOGLEVEL);
 453       }
 454       Console.initLogger(logLevel);
 455     } catch (NoClassDefFoundError error)
 456     {
 457       error.printStackTrace();
 458       String message = "\nEssential logging libraries not found."
 459               + "\nUse: java -classpath \"$PATH_TO_LIB$/*:$PATH_TO_CLASSES$\" jalview.bin.Jalview";
 460       Jalview.exit(message, 0);
 461     }
 462
 463     // register SIGTERM listener
 464     Runtime.getRuntime().addShutdownHook(new Thread()
 465     {
 466       public void run()
 467       {
 468         Console.debug("Running shutdown hook");
 469         QuitHandler.startForceQuit();
 470         boolean closeExternal = Cache
 471                 .getDefault("DEFAULT_CLOSE_EXTERNAL_VIEWERS", false)
 472                 || Cache.getDefault("ALWAYS_CLOSE_EXTERNAL_VIEWERS", false);
 473         StructureViewerBase.setQuitClose(closeExternal);
 474         if (desktop != null)
 475         {
 476           for (JInternalFrame frame : Desktop.desktop.getAllFrames())
 477           {
 478             if (frame instanceof StructureViewerBase)
 479             {
 480               ((StructureViewerBase) frame).closeViewer(closeExternal);
 481             }
 482           }
 483         }
 484
 485         if (QuitHandler.gotQuitResponse() == QResponse.CANCEL_QUIT)
 486         {
 487           // Got to here by a SIGTERM signal.
 488           // Note we will not actually cancel the quit from here -- it's too
 489           // late -- but we can wait for saving files and close external viewers
 490           // if configured.
 491           // Close viewers/Leave viewers open
 492           Console.debug("Checking for saving files");
 493           QuitHandler.getQuitResponse(false);
 494         }
 495         else
 496         {
 497           Console.debug("Nothing more to do");
 498         }
 499         Console.debug("Exiting, bye!");
 500         // shutdownHook cannot be cancelled, JVM will now halt
 501       }
 502     });
 503
 504     String usrPropsFile = bootstrapArgs.contains(Arg.PROPS)
 505             ? bootstrapArgs.getValue(Arg.PROPS)
 506             : aparser.getValue("props");
 507     // if usrPropsFile == null, loadProperties will use the Channel
 508     // preferences.file
 509     Cache.loadProperties(usrPropsFile);
 510     if (usrPropsFile != null)
 511     {
 512       System.out.println(
 513               "CMD [-props " + usrPropsFile + "] executed successfully!");
 514       testoutput(bootstrapArgs, Arg.PROPS,
 515               "test/jalview/bin/testProps.jvprops", usrPropsFile);
 516     }
 517
 518     // --argfile=... -- OVERRIDES ALL NON-BOOTSTRAP ARGS
 519     if (bootstrapArgs.contains(Arg.ARGFILE))
 520     {
 521       argparser = ArgParser.parseArgFiles(
 522               bootstrapArgs.getValueList(Arg.ARGFILE),
 523               bootstrapArgs.getBoolean(Arg.INITSUBSTITUTIONS),
 524               bootstrapArgs);
 525     }
 526     else
 527     {
 528       argparser = new ArgParser(args,
 529               bootstrapArgs.getBoolean(Arg.INITSUBSTITUTIONS),
 530               bootstrapArgs);
 531     }
 532
 533     if (!Platform.isJS())
 534     /**
 535      * Java only
 536      *
 537      * @j2sIgnore
 538      */
 539     {
 540       if (bootstrapArgs.contains(Arg.HELP))
 541       {
 542         List<Map.Entry<Type, String>> helpArgs = bootstrapArgs
 543                 .getList(Arg.HELP);
 544         System.out.println(Arg.usage(helpArgs.stream().map(e -> e.getKey())
 545                 .collect(Collectors.toList())));
 546         Jalview.exit(null, 0);
 547       }
 548       if (aparser.contains("help") || aparser.contains("h"))
 549       {
 550         /*
 551          * Now using new usage statement.
 552         showUsage();
 553         */
 554         System.out.println(Arg.usage());
 555         Jalview.exit(null, 0);
 556       }
 557
 558       // new CLI
 559       headlessArg = bootstrapArgs.isHeadless();
 560       if (headlessArg)
 561       {
 562         System.setProperty("java.awt.headless", "true");
 563       }
 564       // old CLI
 565       if (aparser.contains("nodisplay") || aparser.contains("nogui")
 566               || aparser.contains("headless"))
 567       {
 568         System.setProperty("java.awt.headless", "true");
 569         headless = true;
 570       }
 571       // anything else!
 572
 573       // allow https handshakes to download intermediate certs if necessary
 574       System.setProperty("com.sun.security.enableAIAcaIssuers", "true");
 575
 576       String jabawsUrl = bootstrapArgs.getValue(Arg.JABAWS);
 577       if (jabawsUrl == null)
 578         jabawsUrl = aparser.getValue("jabaws");
 579       if (jabawsUrl != null)
 580       {
 581         try
 582         {
 583           Jws2Discoverer.getDiscoverer().setPreferredUrl(jabawsUrl);
 584           System.out.println(
 585                   "CMD [-jabaws " + jabawsUrl + "] executed successfully!");
 586           testoutput(bootstrapArgs, Arg.JABAWS,
 587                   "http://www.compbio.dundee.ac.uk/jabaws", jabawsUrl);
 588         } catch (MalformedURLException e)
 589         {
 590           System.err.println(
 591                   "Invalid jabaws parameter: " + jabawsUrl + " ignored");
 592         }
 593       }
 594     }
 595
 596     List<String> setprops = new ArrayList<>();
 597     if (bootstrapArgs.contains(Arg.SETPROP))
 598     {
 599       setprops = bootstrapArgs.getValueList(Arg.SETPROP);
 600     }
 601     else
 602     {
 603       String sp = aparser.getValue("setprop");
 604       while (sp != null)
 605       {
 606         setprops.add(sp);
 607         sp = aparser.getValue("setprop");
 608       }
 609     }
 610     for (String setprop : setprops)
 611     {
 612       int p = setprop.indexOf('=');
 613       if (p == -1)
 614       {
 615         System.err
 616                 .println("Ignoring invalid setprop argument : " + setprop);
 617       }
 618       else
 619       {
 620         System.out.println("Executing setprop argument: " + setprop);
 621         if (Platform.isJS())
 622         {
 623           Cache.setProperty(setprop.substring(0, p),
 624                   setprop.substring(p + 1));
 625         }
 626         // DISABLED FOR SECURITY REASONS
 627         // TODO: add a property to allow properties to be overriden by cli args
 628         // Cache.setProperty(setprop.substring(0,p), setprop.substring(p+1));
 629       }
 630     }
 631     if (System.getProperty("java.awt.headless") != null
 632             && System.getProperty("java.awt.headless").equals("true"))
 633     {
 634       headless = true;
 635     }
 636     System.setProperty("http.agent", HttpUtils.getUserAgent());
 637
 638     try
 639     {
 640       Console.initLogger();
 641     } catch (
 642
 643     NoClassDefFoundError error)
 644     {
 645       error.printStackTrace();
 646       String message = "\nEssential logging libraries not found."
 647               + "\nUse: java -classpath \"$PATH_TO_LIB$/*:$PATH_TO_CLASSES$\" jalview.bin.Jalview";
 648       Jalview.exit(message, 0);
 649     }
 650     desktop = null;
 651
 652     if (!(headless || headlessArg))
 653       setLookAndFeel();
 654
 655     /*
 656      * configure 'full' SO model if preferences say to, else use the default (full SO)
 657      * - as JS currently doesn't have OBO parsing, it must use 'Lite' version
 658      */
 659     boolean soDefault = !Platform.isJS();
 660     if (Cache.getDefault("USE_FULL_SO", soDefault))
 661     {
 662       SequenceOntologyFactory.setInstance(new SequenceOntology());
 663     }
 664
 665     if (!(headless || headlessArg))
 666     {
 667       Desktop.nosplash = "false".equals(bootstrapArgs.getValue(Arg.SPLASH))
 668               || aparser.contains("nosplash")
 669               || Cache.getDefault("SPLASH", "true").equals("false");
 670       desktop = new Desktop();
 671       desktop.setInBatchMode(true); // indicate we are starting up
 672
 673       try
 674       {
 675         JalviewTaskbar.setTaskbar(this);
 676       } catch (Exception e)
 677       {
 678         Console.info("Cannot set Taskbar");
 679         Console.error(e.getMessage());
 680         // e.printStackTrace();
 681       } catch (Throwable t)
 682       {
 683         Console.info("Cannot set Taskbar");
 684         Console.error(t.getMessage());
 685         // t.printStackTrace();
 686       }
 687
 688       // set Proxy settings before all the internet calls
 689       Cache.setProxyPropertiesFromPreferences();
 690
 691       desktop.setVisible(true);
 692
 693       if (!Platform.isJS())
 694       /**
 695        * Java only
 696        *
 697        * @j2sIgnore
 698        */
 699       {
 700
 701         /**
 702          * Check to see that the JVM version being run is suitable for the Java
 703          * version this Jalview was compiled for. Popup a warning if not.
 704          */
 705         if (!LaunchUtils.checkJavaVersion())
 706         {
 707           Console.warn("The Java version being used (Java "
 708                   + LaunchUtils.getJavaVersion()
 709                   + ") may lead to problems. This installation of Jalview should be used with Java "
 710                   + LaunchUtils.getJavaCompileVersion() + ".");
 711
 712           if (!LaunchUtils
 713                   .getBooleanUserPreference("IGNORE_JVM_WARNING_POPUP"))
 714           {
 715             Object[] options = {
 716                 MessageManager.getString("label.continue") };
 717             JOptionPane.showOptionDialog(null,
 718                     MessageManager.formatMessage(
 719                             "warning.wrong_jvm_version_message",
 720                             LaunchUtils.getJavaVersion(),
 721                             LaunchUtils.getJavaCompileVersion()),
 722                     MessageManager
 723                             .getString("warning.wrong_jvm_version_title"),
 724                     JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,
 725                     null, options, options[0]);
 726           }
 727         }
 728
 729         boolean webservicediscovery = bootstrapArgs
 730                 .getBoolean(Arg.WEBSERVICEDISCOVERY);
 731         if (aparser.contains("nowebservicediscovery"))
 732           webservicediscovery = false;
 733         if (webservicediscovery)
 734         {
 735           desktop.startServiceDiscovery();
 736         }
 737         else
 738         {
 739           testoutput(argparser, Arg.WEBSERVICEDISCOVERY);
 740         }
 741
 742         boolean usagestats = !bootstrapArgs.getBoolean(Arg.NOUSAGESTATS);
 743         if (aparser.contains("nousagestats"))
 744           usagestats = false;
 745         if (usagestats)
 746         {
 747           startUsageStats(desktop);
 748           testoutput(argparser, Arg.NOUSAGESTATS);
 749         }
 750         else
 751         {
 752           System.out.println("CMD [-nousagestats] executed successfully!");
 753           testoutput(argparser, Arg.NOUSAGESTATS);
 754         }
 755
 756         boolean questionnaire = bootstrapArgs.getBoolean(Arg.QUESTIONNAIRE);
 757         if (aparser.contains("noquestionnaire"))
 758           questionnaire = false;
 759         if (questionnaire)
 760         {
 761           String url = aparser.getValue("questionnaire");
 762           if (url != null)
 763           {
 764             // Start the desktop questionnaire prompter with the specified
 765             // questionnaire
 766             Console.debug("Starting questionnaire url at " + url);
 767             desktop.checkForQuestionnaire(url);
 768             System.out.println("CMD questionnaire[-" + url
 769                     + "] executed successfully!");
 770           }
 771           else
 772           {
 773             if (Cache.getProperty("NOQUESTIONNAIRES") == null)
 774             {
 775               // Start the desktop questionnaire prompter with the specified
 776               // questionnaire
 777               // String defurl =
 778               // "http://anaplog.compbio.dundee.ac.uk/cgi-bin/questionnaire.pl";
 779               // //
 780               String defurl = "https://www.jalview.org/cgi-bin/questionnaire.pl";
 781               Console.debug(
 782                       "Starting questionnaire with default url: " + defurl);
 783               desktop.checkForQuestionnaire(defurl);
 784             }
 785           }
 786         }
 787         else
 788         {
 789           System.out
 790                   .println("CMD [-noquestionnaire] executed successfully!");
 791           testoutput(argparser, Arg.QUESTIONNAIRE);
 792         }
 793
 794         if ((!aparser.contains("nonews")
 795                 && Cache.getProperty("NONEWS") == null
 796                 && !"false".equals(bootstrapArgs.getValue(Arg.NEWS)))
 797                 || "true".equals(bootstrapArgs.getValue(Arg.NEWS)))
 798         {
 799           desktop.checkForNews();
 800         }
 801
 802         if (!aparser.contains("nohtmltemplates")
 803                 && Cache.getProperty("NOHTMLTEMPLATES") == null)
 804         {
 805           BioJsHTMLOutput.updateBioJS();
 806         }
 807       }
 808     }
 809     // Run Commands from cli
 810     cmds = new Commands(argparser, headlessArg);
 811     boolean commandsSuccess = cmds.argsWereParsed();
 812
 813     if (commandsSuccess)
 814     {
 815       if (headlessArg)
 816       {
 817         if (argparser.getBoolean(Arg.NOQUIT))
 818         {
 819           Console.warn(
 820                   "Completed " + Arg.HEADLESS.getName() + " commands, but "
 821                           + Arg.NOQUIT + " is set so not quitting!");
 822         }
 823         else
 824         {
 825           // record usage stats if in headless mode
 826           if (Cache.getDefault("USAGESTATS", false))
 827           {
 828             Cache.initGoogleTracker(headlessArg);
 829           }
 830           Jalview.exit("Successfully completed commands in headless mode",
 831                   0);
 832         }
 833       }
 834       Console.info("Successfully completed commands");
 835     }
 836     else
 837     {
 838       if (headlessArg)
 839       {
 840         Jalview.exit("Error when running Commands in headless mode", 1);
 841       }
 842       Console.warn("Error when running commands");
 843     }
 844
 845     // Check if JVM and compile version might cause problems and log if it
 846     // might.
 847     if (headless && !Platform.isJS() && !LaunchUtils.checkJavaVersion())
 848     {
 849       Console.warn("The Java version being used (Java "
 850               + LaunchUtils.getJavaVersion()
 851               + ") may lead to problems. This installation of Jalview should be used with Java "
 852               + LaunchUtils.getJavaCompileVersion() + ".");
 853     }
 854
 855     String file = null, data = null;
 856
 857     FileFormatI format = null;
 858
 859     DataSourceType protocol = null;
 860
 861     FileLoader fileLoader = new FileLoader(!headless);
 862
 863     String groovyscript = null; // script to execute after all loading is
 864     // completed one way or another
 865     // extract groovy argument and execute if necessary
 866     groovyscript = aparser.getValue("groovy", true);
 867     file = aparser.getValue("open", true);
 868
 869     if (file == null && desktop == null && !commandsSuccess)
 870     {
 871       Jalview.exit("No files to open!", 1);
 872     }
 873
 874     long progress = -1;
 875     // Finally, deal with the remaining input data.
 876     if (file != null)
 877     {
 878       if (!headless)
 879       {
 880         desktop.setProgressBar(
 881                 MessageManager
 882                         .getString("status.processing_commandline_args"),
 883                 progress = System.currentTimeMillis());
 884       }
 885       System.out.println("CMD [-open " + file + "] executed successfully!");
 886
 887       if (!Platform.isJS())
 888       /**
 889        * ignore in JavaScript -- can't just file existence - could load it?
 890        *
 891        * @j2sIgnore
 892        */
 893       {
 894         if (!HttpUtils.startsWithHttpOrHttps(file))
 895         {
 896           if (!(new File(file)).exists())
 897           {
 898             if (headless)
 899             {
 900               Jalview.exit(
 901                       "Can't find file '" + file + "' in headless mode", 1);
 902             }
 903             Console.warn("Can't find file'" + file + "'");
 904           }
 905         }
 906       }
 907
 908       protocol = AppletFormatAdapter.checkProtocol(file);
 909
 910       try
 911       {
 912         format = new IdentifyFile().identify(file, protocol);
 913       } catch (FileFormatException e1)
 914       {
 915         // TODO ?
 916       }
 917
 918       AlignFrame af = fileLoader.LoadFileWaitTillLoaded(file, protocol,
 919               format);
 920       if (af == null)
 921       {
 922         System.out.println("error");
 923       }
 924       else
 925       {
 926         setCurrentAlignFrame(af);
 927         data = aparser.getValue("colour", true);
 928         if (data != null)
 929         {
 930           data.replaceAll("%20", " ");
 931
 932           ColourSchemeI cs = ColourSchemeProperty.getColourScheme(
 933                   af.getViewport(), af.getViewport().getAlignment(), data);
 934
 935           if (cs != null)
 936           {
 937             System.out.println(
 938                     "CMD [-colour " + data + "] executed successfully!");
 939           }
 940           af.changeColour(cs);
 941         }
 942
 943         // Must maintain ability to use the groups flag
 944         data = aparser.getValue("groups", true);
 945         if (data != null)
 946         {
 947           af.parseFeaturesFile(data,
 948                   AppletFormatAdapter.checkProtocol(data));
 949           // System.out.println("Added " + data);
 950           System.out.println(
 951                   "CMD groups[-" + data + "]  executed successfully!");
 952         }
 953         data = aparser.getValue("features", true);
 954         if (data != null)
 955         {
 956           af.parseFeaturesFile(data,
 957                   AppletFormatAdapter.checkProtocol(data));
 958           // System.out.println("Added " + data);
 959           System.out.println(
 960                   "CMD [-features " + data + "]  executed successfully!");
 961         }
 962
 963         data = aparser.getValue("annotations", true);
 964         if (data != null)
 965         {
 966           af.loadJalviewDataFile(data, null, null, null);
 967           // System.out.println("Added " + data);
 968           System.out.println(
 969                   "CMD [-annotations " + data + "] executed successfully!");
 970         }
 971         // set or clear the sortbytree flag.
 972         if (aparser.contains("sortbytree"))
 973         {
 974           af.getViewport().setSortByTree(true);
 975           if (af.getViewport().getSortByTree())
 976           {
 977             System.out.println("CMD [-sortbytree] executed successfully!");
 978           }
 979         }
 980         if (aparser.contains("no-annotation"))
 981         {
 982           af.getViewport().setShowAnnotation(false);
 983           if (!af.getViewport().isShowAnnotation())
 984           {
 985             System.out.println("CMD no-annotation executed successfully!");
 986           }
 987         }
 988         if (aparser.contains("nosortbytree"))
 989         {
 990           af.getViewport().setSortByTree(false);
 991           if (!af.getViewport().getSortByTree())
 992           {
 993             System.out
 994                     .println("CMD [-nosortbytree] executed successfully!");
 995           }
 996         }
 997         data = aparser.getValue("tree", true);
 998         if (data != null)
 999         {
1000           try
1001           {
1002             System.out.println(
1003                     "CMD [-tree " + data + "] executed successfully!");
1004             NewickFile nf = new NewickFile(data,
1005                     AppletFormatAdapter.checkProtocol(data));
1006             af.getViewport()
1007                     .setCurrentTree(af.showNewickTree(nf, data).getTree());
1008           } catch (IOException ex)
1009           {
1010             System.err.println("Couldn't add tree " + data);
1011             ex.printStackTrace(System.err);
1012           }
1013         }
1014
1015         if (groovyscript != null)
1016         {
1017           // Execute the groovy script after we've done all the rendering stuff
1018           // and before any images or figures are generated.
1019           System.out.println("Executing script " + groovyscript);
1020           executeGroovyScript(groovyscript, af);
1021           System.out.println("CMD groovy[" + groovyscript
1022                   + "] executed successfully!");
1023           groovyscript = null;
1024         }
1025         String imageName = "unnamed.png";
1026         while (aparser.getSize() > 1)
1027         {
1028           try
1029           {
1030             String outputFormat = aparser.nextValue();
1031             file = aparser.nextValue();
1032
1033             if (outputFormat.equalsIgnoreCase("png"))
1034             {
1035               System.out.println("Creating PNG image: " + file);
1036               af.createPNG(new File(file));
1037               imageName = (new File(file)).getName();
1038               continue;
1039             }
1040             else if (outputFormat.equalsIgnoreCase("svg"))
1041             {
1042               System.out.println("Creating SVG image: " + file);
1043               File imageFile = new File(file);
1044               imageName = imageFile.getName();
1045               af.createSVG(imageFile);
1046               continue;
1047             }
1048             else if (outputFormat.equalsIgnoreCase("html"))
1049             {
1050               File imageFile = new File(file);
1051               imageName = imageFile.getName();
1052               HtmlSvgOutput htmlSVG = new HtmlSvgOutput(af.alignPanel);
1053
1054               System.out.println("Creating HTML image: " + file);
1055               htmlSVG.exportHTML(file);
1056               continue;
1057             }
1058             else if (outputFormat.equalsIgnoreCase("biojsmsa"))
1059             {
1060               if (file == null)
1061               {
1062                 System.err.println("The output html file must not be null");
1063                 return;
1064               }
1065               try
1066               {
1067                 BioJsHTMLOutput.refreshVersionInfo(
1068                         BioJsHTMLOutput.BJS_TEMPLATES_LOCAL_DIRECTORY);
1069               } catch (URISyntaxException e)
1070               {
1071                 e.printStackTrace();
1072               }
1073               BioJsHTMLOutput bjs = new BioJsHTMLOutput(af.alignPanel);
1074               System.out.println(
1075                       "Creating BioJS MSA Viwer HTML file: " + file);
1076               bjs.exportHTML(file);
1077               continue;
1078             }
1079             else if (outputFormat.equalsIgnoreCase("imgMap"))
1080             {
1081               System.out.println("Creating image map: " + file);
1082               af.createImageMap(new File(file), imageName);
1083               continue;
1084             }
1085             else if (outputFormat.equalsIgnoreCase("eps"))
1086             {
1087               File outputFile = new File(file);
1088               System.out.println(
1089                       "Creating EPS file: " + outputFile.getAbsolutePath());
1090               af.createEPS(outputFile);
1091               continue;
1092             }
1093
1094             FileFormatI outFormat = null;
1095             try
1096             {
1097               outFormat = FileFormats.getInstance().forName(outputFormat);
1098             } catch (Exception formatP)
1099             {
1100               System.out.println("Couldn't parse " + outFormat
1101                       + " as a valid Jalview format string.");
1102             }
1103             if (outFormat != null)
1104             {
1105               if (!outFormat.isWritable())
1106               {
1107                 System.out.println(
1108                         "This version of Jalview does not support alignment export as "
1109                                 + outputFormat);
1110               }
1111               else
1112               {
1113                 af.saveAlignment(file, outFormat);
1114                 if (af.isSaveAlignmentSuccessful())
1115                 {
1116                   System.out.println("Written alignment in "
1117                           + outFormat.getName() + " format to " + file);
1118                 }
1119                 else
1120                 {
1121                   System.out.println("Error writing file " + file + " in "
1122                           + outFormat.getName() + " format!!");
1123                 }
1124               }
1125             }
1126           } catch (ImageOutputException ioexc)
1127           {
1128             System.out.println(
1129                     "Unexpected error whilst exporting image to " + file);
1130             ioexc.printStackTrace();
1131           }
1132
1133         }
1134
1135         while (aparser.getSize() > 0)
1136         {
1137           System.out.println("Unknown arg: " + aparser.nextValue());
1138         }
1139       }
1140     }
1141
1142     AlignFrame startUpAlframe = null;
1143     // We'll only open the default file if the desktop is visible.
1144     // And the user
1145     // ////////////////////
1146
1147     if (!Platform.isJS() && !headless && file == null
1148             && Cache.getDefault("SHOW_STARTUP_FILE", true)
1149             && !cmds.commandArgsProvided()
1150             && !bootstrapArgs.getBoolean(Arg.NOSTARTUPFILE))
1151     // don't open the startup file if command line args have been processed
1152     // (&& !Commands.commandArgsProvided())
1153     /**
1154      * Java only
1155      *
1156      * @j2sIgnore
1157      */
1158     {
1159       file = Cache.getDefault("STARTUP_FILE",
1160               Cache.getDefault("www.jalview.org", "https://www.jalview.org")
1161                       + "/examples/exampleFile_2_7.jvp");
1162       if (file.equals("http://www.jalview.org/examples/exampleFile_2_3.jar")
1163               || file.equals(
1164                       "http://www.jalview.org/examples/exampleFile_2_7.jar"))
1165       {
1166         file.replace("http:", "https:");
1167         // hardwire upgrade of the startup file
1168         file.replace("_2_3", "_2_7");
1169         file.replace("2_7.jar", "2_7.jvp");
1170         // and remove the stale setting
1171         Cache.removeProperty("STARTUP_FILE");
1172       }
1173
1174       protocol = AppletFormatAdapter.checkProtocol(file);
1175
1176       if (file.endsWith(".jar"))
1177       {
1178         format = FileFormat.Jalview;
1179       }
1180       else
1181       {
1182         try
1183         {
1184           format = new IdentifyFile().identify(file, protocol);
1185         } catch (FileFormatException e)
1186         {
1187           // TODO what?
1188         }
1189       }
1190
1191       startUpAlframe = fileLoader.LoadFileWaitTillLoaded(file, protocol,
1192               format);
1193       // don't ask to save when quitting if only the startup file has been
1194       // opened
1195       Console.debug("Resetting up-to-date flag for startup file");
1196       startUpAlframe.getViewport().setSavedUpToDate(true);
1197       // extract groovy arguments before anything else.
1198     }
1199
1200     // Once all other stuff is done, execute any groovy scripts (in order)
1201     if (groovyscript != null)
1202     {
1203       if (Cache.groovyJarsPresent())
1204       {
1205         System.out.println("Executing script " + groovyscript);
1206         executeGroovyScript(groovyscript, startUpAlframe);
1207       }
1208       else
1209       {
1210         System.err.println(
1211                 "Sorry. Groovy Support is not available, so ignoring the provided groovy script "
1212                         + groovyscript);
1213       }
1214     }
1215     // and finally, turn off batch mode indicator - if the desktop still exists
1216     if (desktop != null)
1217     {
1218       if (progress != -1)
1219       {
1220         desktop.setProgressBar(null, progress);
1221       }
1222       desktop.setInBatchMode(false);
1223     }
1224   }
1225
1226   private static void setLookAndFeel()
1227   {
1228     if (!Platform.isJS())
1229     /**
1230      * Java only
1231      *
1232      * @j2sIgnore
1233      */
1234     {
1235       // property laf = "crossplatform", "system", "gtk", "metal", "nimbus",
1236       // "mac" or "flat"
1237       // If not set (or chosen laf fails), use the normal SystemLaF and if on
1238       // Mac,
1239       // try Quaqua/Vaqua.
1240       String lafProp = System.getProperty("laf");
1241       String lafSetting = Cache.getDefault("PREFERRED_LAF", null);
1242       String laf = "none";
1243       if (lafProp != null)
1244       {
1245         laf = lafProp;
1246       }
1247       else if (lafSetting != null)
1248       {
1249         laf = lafSetting;
1250       }
1251       boolean lafSet = false;
1252       switch (laf)
1253       {
1254       case "crossplatform":
1255         lafSet = setCrossPlatformLookAndFeel();
1256         if (!lafSet)
1257         {
1258           Console.error("Could not set requested laf=" + laf);
1259         }
1260         break;
1261       case "system":
1262         lafSet = setSystemLookAndFeel();
1263         if (!lafSet)
1264         {
1265           Console.error("Could not set requested laf=" + laf);
1266         }
1267         break;
1268       case "gtk":
1269         lafSet = setGtkLookAndFeel();
1270         if (!lafSet)
1271         {
1272           Console.error("Could not set requested laf=" + laf);
1273         }
1274         break;
1275       case "metal":
1276         lafSet = setMetalLookAndFeel();
1277         if (!lafSet)
1278         {
1279           Console.error("Could not set requested laf=" + laf);
1280         }
1281         break;
1282       case "nimbus":
1283         lafSet = setNimbusLookAndFeel();
1284         if (!lafSet)
1285         {
1286           Console.error("Could not set requested laf=" + laf);
1287         }
1288         break;
1289       case "flat":
1290         lafSet = setFlatLookAndFeel();
1291         if (!lafSet)
1292         {
1293           Console.error("Could not set requested laf=" + laf);
1294         }
1295         break;
1296       case "mac":
1297         lafSet = setMacLookAndFeel();
1298         if (!lafSet)
1299         {
1300           Console.error("Could not set requested laf=" + laf);
1301         }
1302         break;
1303       case "none":
1304         break;
1305       default:
1306         Console.error("Requested laf=" + laf + " not implemented");
1307       }
1308       if (!lafSet)
1309       {
1310         // Flatlaf default for everyone!
1311         lafSet = setFlatLookAndFeel();
1312         if (!lafSet)
1313         {
1314           setSystemLookAndFeel();
1315         }
1316         if (Platform.isLinux())
1317         {
1318           setLinuxLookAndFeel();
1319         }
1320         if (Platform.isMac())
1321         {
1322           setMacLookAndFeel();
1323         }
1324       }
1325     }
1326   }
1327
1328   private static boolean setCrossPlatformLookAndFeel()
1329   {
1330     boolean set = false;
1331     try
1332     {
1333       UIManager.setLookAndFeel(
1334               UIManager.getCrossPlatformLookAndFeelClassName());
1335       set = true;
1336     } catch (Exception ex)
1337     {
1338       Console.error("Unexpected Look and Feel Exception");
1339       Console.error(ex.getMessage());
1340       Console.debug(Cache.getStackTraceString(ex));
1341     }
1342     return set;
1343   }
1344
1345   private static boolean setSystemLookAndFeel()
1346   {
1347     boolean set = false;
1348     try
1349     {
1350       UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
1351       set = true;
1352     } catch (Exception ex)
1353     {
1354       Console.error("Unexpected Look and Feel Exception");
1355       Console.error(ex.getMessage());
1356       Console.debug(Cache.getStackTraceString(ex));
1357     }
1358     return set;
1359   }
1360
1361   private static boolean setSpecificLookAndFeel(String name,
1362           String className, boolean nameStartsWith)
1363   {
1364     boolean set = false;
1365     try
1366     {
1367       for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels())
1368       {
1369         if (info.getName() != null && nameStartsWith
1370                 ? info.getName().toLowerCase(Locale.ROOT)
1371                         .startsWith(name.toLowerCase(Locale.ROOT))
1372                 : info.getName().toLowerCase(Locale.ROOT)
1373                         .equals(name.toLowerCase(Locale.ROOT)))
1374         {
1375           className = info.getClassName();
1376           break;
1377         }
1378       }
1379       UIManager.setLookAndFeel(className);
1380       set = true;
1381     } catch (Exception ex)
1382     {
1383       Console.error("Unexpected Look and Feel Exception");
1384       Console.error(ex.getMessage());
1385       Console.debug(Cache.getStackTraceString(ex));
1386     }
1387     return set;
1388   }
1389
1390   private static boolean setGtkLookAndFeel()
1391   {
1392     return setSpecificLookAndFeel("gtk",
1393             "com.sun.java.swing.plaf.gtk.GTKLookAndFeel", true);
1394   }
1395
1396   private static boolean setMetalLookAndFeel()
1397   {
1398     return setSpecificLookAndFeel("metal",
1399             "javax.swing.plaf.metal.MetalLookAndFeel", false);
1400   }
1401
1402   private static boolean setNimbusLookAndFeel()
1403   {
1404     return setSpecificLookAndFeel("nimbus",
1405             "javax.swing.plaf.nimbus.NimbusLookAndFeel", false);
1406   }
1407
1408   private static boolean setFlatLookAndFeel()
1409   {
1410     boolean set = false;
1411     if (SystemInfo.isMacOS)
1412     {
1413       try
1414       {
1415         UIManager.setLookAndFeel(
1416                 "com.formdev.flatlaf.themes.FlatMacLightLaf");
1417         set = true;
1418         Console.debug("Using FlatMacLightLaf");
1419       } catch (ClassNotFoundException | InstantiationException
1420               | IllegalAccessException | UnsupportedLookAndFeelException e)
1421       {
1422         Console.debug("Exception loading FlatLightLaf", e);
1423       }
1424       System.setProperty("apple.laf.useScreenMenuBar", "true");
1425       System.setProperty("apple.awt.application.name",
1426               ChannelProperties.getProperty("app_name"));
1427       System.setProperty("apple.awt.application.appearance", "system");
1428       if (SystemInfo.isMacFullWindowContentSupported
1429               && Desktop.desktop != null)
1430       {
1431         Console.debug("Setting transparent title bar");
1432         Desktop.desktop.getRootPane()
1433                 .putClientProperty("apple.awt.fullWindowContent", true);
1434         Desktop.desktop.getRootPane()
1435                 .putClientProperty("apple.awt.transparentTitleBar", true);
1436         Desktop.desktop.getRootPane()
1437                 .putClientProperty("apple.awt.fullscreenable", true);
1438       }
1439       SwingUtilities.invokeLater(() -> {
1440         FlatMacLightLaf.setup();
1441       });
1442       Console.debug("Using FlatMacLightLaf");
1443       set = true;
1444     }
1445     if (!set)
1446     {
1447       try
1448       {
1449         UIManager.setLookAndFeel("com.formdev.flatlaf.FlatLightLaf");
1450         set = true;
1451         Console.debug("Using FlatLightLaf");
1452       } catch (ClassNotFoundException | InstantiationException
1453               | IllegalAccessException | UnsupportedLookAndFeelException e)
1454       {
1455         Console.debug("Exception loading FlatLightLaf", e);
1456       }
1457       // Windows specific properties here
1458       SwingUtilities.invokeLater(() -> {
1459         FlatLightLaf.setup();
1460       });
1461       Console.debug("Using FlatLightLaf");
1462       set = true;
1463     }
1464     else if (SystemInfo.isLinux)
1465     {
1466       try
1467       {
1468         UIManager.setLookAndFeel("com.formdev.flatlaf.FlatLightLaf");
1469         set = true;
1470         Console.debug("Using FlatLightLaf");
1471       } catch (ClassNotFoundException | InstantiationException
1472               | IllegalAccessException | UnsupportedLookAndFeelException e)
1473       {
1474         Console.debug("Exception loading FlatLightLaf", e);
1475       }
1476       // enable custom window decorations
1477       JFrame.setDefaultLookAndFeelDecorated(true);
1478       JDialog.setDefaultLookAndFeelDecorated(true);
1479       SwingUtilities.invokeLater(() -> {
1480         FlatLightLaf.setup();
1481       });
1482       Console.debug("Using FlatLightLaf");
1483       set = true;
1484     }
1485
1486     if (!set)
1487     {
1488       try
1489       {
1490         UIManager.setLookAndFeel("com.formdev.flatlaf.FlatLightLaf");
1491         set = true;
1492         Console.debug("Using FlatLightLaf");
1493       } catch (ClassNotFoundException | InstantiationException
1494               | IllegalAccessException | UnsupportedLookAndFeelException e)
1495       {
1496         Console.debug("Exception loading FlatLightLaf", e);
1497       }
1498     }
1499
1500     if (set)
1501     {
1502       UIManager.put("TabbedPane.tabType", "card");
1503       UIManager.put("TabbedPane.showTabSeparators", true);
1504       UIManager.put("TabbedPane.showContentSeparator", true);
1505       UIManager.put("TabbedPane.tabSeparatorsFullHeight", true);
1506       UIManager.put("TabbedPane.tabsOverlapBorder", true);
1507       UIManager.put("TabbedPane.hasFullBorder", true);
1508       UIManager.put("TabbedPane.tabLayoutPolicy", "scroll");
1509       UIManager.put("TabbedPane.scrollButtonsPolicy", "asNeeded");
1510       UIManager.put("TabbedPane.smoothScrolling", true);
1511       UIManager.put("TabbedPane.tabWidthMode", "compact");
1512       UIManager.put("TabbedPane.selectedBackground", Color.white);
1513       UIManager.put("TabbedPane.background", new Color(236, 236, 236));
1514       UIManager.put("TabbedPane.hoverColor", Color.lightGray);
1515     }
1516
1517     Desktop.setLiveDragMode(Cache.getDefault("FLAT_LIVE_DRAG_MODE", true));
1518     return set;
1519   }
1520
1521   private static boolean setMacLookAndFeel()
1522   {
1523     boolean set = false;
1524     System.setProperty("com.apple.mrj.application.apple.menu.about.name",
1525             ChannelProperties.getProperty("app_name"));
1526     System.setProperty("apple.laf.useScreenMenuBar", "true");
1527     /*
1528      * broken native LAFs on (ARM?) macbooks
1529     set = setQuaquaLookAndFeel();
1530     if ((!set) || !UIManager.getLookAndFeel().getClass().toString()
1531             .toLowerCase(Locale.ROOT).contains("quaqua"))
1532     {
1533       set = setVaquaLookAndFeel();
1534     }
1535      */
1536     set = setFlatLookAndFeel();
1537     return set;
1538   }
1539
1540   private static boolean setLinuxLookAndFeel()
1541   {
1542     boolean set = false;
1543     set = setFlatLookAndFeel();
1544     if (!set)
1545       set = setMetalLookAndFeel();
1546     // avoid GtkLookAndFeel -- not good results especially on HiDPI
1547     if (!set)
1548       set = setNimbusLookAndFeel();
1549     return set;
1550   }
1551
1552   /*
1553   private static void showUsage()
1554   {
1555     System.out.println(
1556             "Usage: jalview -open [FILE] [OUTPUT_FORMAT] [OUTPUT_FILE]\n\n"
1557                     + "-nodisplay\tRun Jalview without User Interface.\n"
1558                     + "-props FILE\tUse the given Jalview properties file instead of users default.\n"
1559                     + "-colour COLOURSCHEME\tThe colourscheme to be applied to the alignment\n"
1560                     + "-annotations FILE\tAdd precalculated annotations to the alignment.\n"
1561                     + "-tree FILE\tLoad the given newick format tree file onto the alignment\n"
1562                     + "-features FILE\tUse the given file to mark features on the alignment.\n"
1563                     + "-fasta FILE\tCreate alignment file FILE in Fasta format.\n"
1564                     + "-clustal FILE\tCreate alignment file FILE in Clustal format.\n"
1565                     + "-pfam FILE\tCreate alignment file FILE in PFAM format.\n"
1566                     + "-msf FILE\tCreate alignment file FILE in MSF format.\n"
1567                     + "-pileup FILE\tCreate alignment file FILE in Pileup format\n"
1568                     + "-pir FILE\tCreate alignment file FILE in PIR format.\n"
1569                     + "-blc FILE\tCreate alignment file FILE in BLC format.\n"
1570                     + "-json FILE\tCreate alignment file FILE in JSON format.\n"
1571                     + "-jalview FILE\tCreate alignment file FILE in Jalview format.\n"
1572                     + "-png FILE\tCreate PNG image FILE from alignment.\n"
1573                     + "-svg FILE\tCreate SVG image FILE from alignment.\n"
1574                     + "-html FILE\tCreate HTML file from alignment.\n"
1575                     + "-biojsMSA FILE\tCreate BioJS MSA Viewer HTML file from alignment.\n"
1576                     + "-imgMap FILE\tCreate HTML file FILE with image map of PNG image.\n"
1577                     + "-eps FILE\tCreate EPS file FILE from alignment.\n"
1578                     + "-questionnaire URL\tQueries the given URL for information about any Jalview user questionnaires.\n"
1579                     + "-noquestionnaire\tTurn off questionnaire check.\n"
1580                     + "-nonews\tTurn off check for Jalview news.\n"
1581                     + "-nousagestats\tTurn off analytics tracking for this session.\n"
1582                     + "-sortbytree OR -nosortbytree\tEnable or disable sorting of the given alignment by the given tree\n"
1583                     // +
1584                     // "-setprop PROPERTY=VALUE\tSet the given Jalview property,
1585                     // after all other properties files have been read\n\t
1586                     // (quote the 'PROPERTY=VALUE' pair to ensure spaces are
1587                     // passed in correctly)"
1588                     + "-jabaws URL\tSpecify URL for Jabaws services (e.g. for a local installation).\n"
1589                     + "-fetchfrom nickname\tQuery nickname for features for the alignments and display them.\n"
1590                     + "-groovy FILE\tExecute groovy script in FILE, after all other arguments have been processed (if FILE is the text 'STDIN' then the file will be read from STDIN)\n"
1591                     + "-jvmmempc=PERCENT\tOnly available with standalone executable jar or jalview.bin.Launcher. Limit maximum heap size (memory) to PERCENT% of total physical memory detected. This defaults to 90 if total physical memory can be detected. See https://www.jalview.org/help/html/memory.html for more details.\n"
1592                     + "-jvmmemmax=MAXMEMORY\tOnly available with standalone executable jar or jalview.bin.Launcher. Limit maximum heap size (memory) to MAXMEMORY. MAXMEMORY can be specified in bytes, kilobytes(k), megabytes(m), gigabytes(g) or if you're lucky enough, terabytes(t). This defaults to 32g if total physical memory can be detected, or to 8g if total physical memory cannot be detected. See https://www.jalview.org/help/html/memory.html for more details.\n"
1593                     + "\n~Read documentation in Application or visit https://www.jalview.org for description of Features and Annotations file~\n\n");
1594   }
1595   */
1596
1597   private static void startUsageStats(final Desktop desktop)
1598   {
1599     /**
1600      * start a User Config prompt asking if we can log usage statistics.
1601      */
1602     PromptUserConfig prompter = new PromptUserConfig(Desktop.desktop,
1603             "USAGESTATS",
1604             MessageManager.getString("prompt.plausible_analytics_title"),
1605             MessageManager.getString("prompt.plausible_analytics"),
1606             new Runnable()
1607             {
1608               @Override
1609               public void run()
1610               {
1611                 Console.debug("Initialising analytics for usage stats.");
1612                 Cache.initAnalytics();
1613                 Console.debug("Tracking enabled.");
1614               }
1615             }, new Runnable()
1616             {
1617               @Override
1618               public void run()
1619               {
1620                 Console.debug("Not enabling analytics.");
1621               }
1622             }, null, true);
1623     desktop.addDialogThread(prompter);
1624   }
1625
1626   /**
1627    * Locate the given string as a file and pass it to the groovy interpreter.
1628    *
1629    * @param groovyscript
1630    *          the script to execute
1631    * @param jalviewContext
1632    *          the Jalview Desktop object passed in to the groovy binding as the
1633    *          'Jalview' object.
1634    */
1635   protected void executeGroovyScript(String groovyscript, AlignFrame af)
1636   {
1637     /**
1638      * for scripts contained in files
1639      */
1640     File tfile = null;
1641     /**
1642      * script's URI
1643      */
1644     URL sfile = null;
1645     if (groovyscript.trim().equals("STDIN"))
1646     {
1647       // read from stdin into a tempfile and execute it
1648       try
1649       {
1650         tfile = File.createTempFile("jalview", "groovy");
1651         PrintWriter outfile = new PrintWriter(
1652                 new OutputStreamWriter(new FileOutputStream(tfile)));
1653         BufferedReader br = new BufferedReader(
1654                 new InputStreamReader(System.in));
1655         String line = null;
1656         while ((line = br.readLine()) != null)
1657         {
1658           outfile.write(line + "\n");
1659         }
1660         br.close();
1661         outfile.flush();
1662         outfile.close();
1663
1664       } catch (Exception ex)
1665       {
1666         System.err.println("Failed to read from STDIN into tempfile "
1667                 + ((tfile == null) ? "(tempfile wasn't created)"
1668                         : tfile.toString()));
1669         ex.printStackTrace();
1670         return;
1671       }
1672       try
1673       {
1674         sfile = tfile.toURI().toURL();
1675       } catch (Exception x)
1676       {
1677         System.err.println(
1678                 "Unexpected Malformed URL Exception for temporary file created from STDIN: "
1679                         + tfile.toURI());
1680         x.printStackTrace();
1681         return;
1682       }
1683     }
1684     else
1685     {
1686       try
1687       {
1688         sfile = new URI(groovyscript).toURL();
1689       } catch (Exception x)
1690       {
1691         tfile = new File(groovyscript);
1692         if (!tfile.exists())
1693         {
1694           System.err.println("File '" + groovyscript + "' does not exist.");
1695           return;
1696         }
1697         if (!tfile.canRead())
1698         {
1699           System.err.println("File '" + groovyscript + "' cannot be read.");
1700           return;
1701         }
1702         if (tfile.length() < 1)
1703         {
1704           System.err.println("File '" + groovyscript + "' is empty.");
1705           return;
1706         }
1707         try
1708         {
1709           sfile = tfile.getAbsoluteFile().toURI().toURL();
1710         } catch (Exception ex)
1711         {
1712           System.err.println("Failed to create a file URL for "
1713                   + tfile.getAbsoluteFile());
1714           return;
1715         }
1716       }
1717     }
1718     try
1719     {
1720       Map<String, java.lang.Object> vbinding = new HashMap<>();
1721       vbinding.put("Jalview", this);
1722       if (af != null)
1723       {
1724         vbinding.put("currentAlFrame", af);
1725       }
1726       Binding gbinding = new Binding(vbinding);
1727       GroovyScriptEngine gse = new GroovyScriptEngine(new URL[] { sfile });
1728       gse.run(sfile.toString(), gbinding);
1729       if ("STDIN".equals(groovyscript))
1730       {
1731         // delete temp file that we made -
1732         // only if it was successfully executed
1733         tfile.delete();
1734       }
1735     } catch (Exception e)
1736     {
1737       System.err.println("Exception Whilst trying to execute file " + sfile
1738               + " as a groovy script.");
1739       e.printStackTrace(System.err);
1740
1741     }
1742   }
1743
1744   public static boolean isHeadlessMode()
1745   {
1746     String isheadless = System.getProperty("java.awt.headless");
1747     if (isheadless != null && isheadless.equalsIgnoreCase("true"))
1748     {
1749       return true;
1750     }
1751     return false;
1752   }
1753
1754   public AlignFrame[] getAlignFrames()
1755   {
1756     return desktop == null ? new AlignFrame[] { getCurrentAlignFrame() }
1757             : Desktop.getAlignFrames();
1758
1759   }
1760
1761   /**
1762    * jalview.bin.Jalview.quit() will just run the non-GUI shutdownHook and exit
1763    */
1764   public void quit()
1765   {
1766     // System.exit will run the shutdownHook first
1767     Jalview.exit("Quitting now. Bye!", 0);
1768   }
1769
1770   public static AlignFrame getCurrentAlignFrame()
1771   {
1772     return Jalview.currentAlignFrame;
1773   }
1774
1775   public static void setCurrentAlignFrame(AlignFrame currentAlignFrame)
1776   {
1777     Jalview.currentAlignFrame = currentAlignFrame;
1778   }
1779
1780   protected Commands getCommands()
1781   {
1782     return cmds;
1783   }
1784
1785   public static void exit(String message, int exitcode)
1786   {
1787     if (Console.log == null)
1788     {
1789       // Don't start the logger just to exit!
1790       if (message != null)
1791       {
1792         if (exitcode == 0)
1793         {
1794           System.out.println(message);
1795         }
1796         else
1797         {
1798           System.err.println(message);
1799         }
1800       }
1801     }
1802     else
1803     {
1804       Console.debug("Using Jalview.exit");
1805       if (message != null)
1806       {
1807         if (exitcode == 0)
1808         {
1809           Console.info(message);
1810         }
1811         else
1812         {
1813           Console.error(message);
1814         }
1815       }
1816     }
1817     if (exitcode > -1)
1818     {
1819       System.exit(exitcode);
1820     }
1821   }
1822
1823   /******************************
1824    *
1825    * TEST OUTPUT METHODS
1826    *
1827    ******************************/
1828   /**
1829    * method for reporting string values parsed/processed during tests
1830    *
1831    */
1832   protected static void testoutput(ArgParser ap, Arg a, String s1,
1833           String s2)
1834   {
1835     BootstrapArgs bsa = ap.getBootstrapArgs();
1836     if (!bsa.getBoolean(Arg.TESTOUTPUT))
1837       return;
1838     if (!((s1 == null && s2 == null) || (s1 != null && s1.equals(s2))))
1839     {
1840       Console.debug("testoutput with unmatching values '" + s1 + "' and '"
1841               + s2 + "' for arg " + a.argString());
1842       return;
1843     }
1844     boolean isset = a.hasOption(Opt.BOOTSTRAP) ? bsa.contains(a)
1845             : ap.isSet(a);
1846     if (!isset)
1847     {
1848       Console.warn("Arg '" + a.getName() + "' not set at all");
1849       return;
1850     }
1851     testoutput(true, a, s1, s2);
1852   }
1853
1854   /**
1855    * method for reporting string values parsed/processed during tests
1856    */
1857
1858   protected static void testoutput(BootstrapArgs bsa, Arg a, String s1,
1859           String s2)
1860   {
1861     if (!bsa.getBoolean(Arg.TESTOUTPUT))
1862       return;
1863     if (!((s1 == null && s2 == null) || (s1 != null && s1.equals(s2))))
1864     {
1865       Console.debug("testoutput with unmatching values '" + s1 + "' and '"
1866               + s2 + "' for arg " + a.argString());
1867       return;
1868     }
1869     if (!a.hasOption(Opt.BOOTSTRAP))
1870     {
1871       Console.error("Non-bootstrap Arg '" + a.getName()
1872               + "' given to testoutput(BootstrapArgs bsa, Arg a, String s1, String s2) with only BootstrapArgs");
1873     }
1874     if (!bsa.contains(a))
1875     {
1876       Console.warn("Arg '" + a.getName() + "' not set at all");
1877       return;
1878     }
1879     testoutput(true, a, s1, s2);
1880   }
1881
1882   /**
1883    * report value set for string values parsed/processed during tests
1884    */
1885   private static void testoutput(boolean yes, Arg a, String s1, String s2)
1886   {
1887     if (yes && ((s1 == null && s2 == null)
1888             || (s1 != null && s1.equals(s2))))
1889     {
1890       System.out.println("[TESTOUTPUT] arg " + a.argString() + "='" + s1
1891               + "' was set");
1892     }
1893   }
1894
1895   /*
1896    * testoutput for boolean and unary values
1897    */
1898   protected static void testoutput(ArgParser ap, Arg a)
1899   {
1900     if (ap == null)
1901       return;
1902     BootstrapArgs bsa = ap.getBootstrapArgs();
1903     if (bsa == null)
1904       return;
1905     if (!bsa.getBoolean(Arg.TESTOUTPUT))
1906       return;
1907     boolean val = a.hasOption(Opt.BOOTSTRAP) ? bsa.getBoolean(a)
1908             : ap.getBoolean(a);
1909     boolean isset = a.hasOption(Opt.BOOTSTRAP) ? bsa.contains(a)
1910             : ap.isSet(a);
1911     if (!isset)
1912     {
1913       Console.warn("Arg '" + a.getName() + "' not set at all");
1914       return;
1915     }
1916     testoutput(val, a);
1917   }
1918
1919   protected static void testoutput(BootstrapArgs bsa, Arg a)
1920   {
1921     if (!bsa.getBoolean(Arg.TESTOUTPUT))
1922       return;
1923     if (!a.hasOption(Opt.BOOTSTRAP))
1924     {
1925       Console.warn("Non-bootstrap Arg '" + a.getName()
1926               + "' given to testoutput(BootstrapArgs bsa, Arg a) with only BootstrapArgs");
1927
1928     }
1929     if (!bsa.contains(a))
1930     {
1931       Console.warn("Arg '" + a.getName() + "' not set at all");
1932       return;
1933     }
1934     testoutput(bsa.getBoolean(a), a);
1935   }
1936
1937   private static void testoutput(boolean yes, Arg a)
1938   {
1939     String message = null;
1940     if (a.hasOption(Opt.BOOLEAN))
1941     {
1942       message = (yes ? a.argString() : a.negateArgString()) + " was set";
1943     }
1944     else if (a.hasOption(Opt.UNARY))
1945     {
1946       message = a.argString() + (yes ? " was set" : " was not set");
1947     }
1948     System.out.println("[TESTOUTPUT] arg " + message);
1949   }
1950 }