src/jalview/bin/Cache.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 jalview.datamodel.PDBEntry;
  24 import jalview.gui.UserDefinedColours;
  25 import jalview.schemes.ColourSchemeLoader;
  26 import jalview.schemes.ColourSchemes;
  27 import jalview.schemes.UserColourScheme;
  28 import jalview.structure.StructureImportSettings;
  29 import jalview.urls.IdOrgSettings;
  30 import jalview.util.ColorUtils;
  31 import jalview.util.Platform;
  32 import jalview.ws.sifts.SiftsSettings;
  33
  34 import java.awt.Color;
  35 import java.io.BufferedReader;
  36 import java.io.File;
  37 import java.io.FileInputStream;
  38 import java.io.FileOutputStream;
  39 import java.io.InputStream;
  40 import java.io.InputStreamReader;
  41 import java.text.DateFormat;
  42 import java.text.SimpleDateFormat;
  43 import java.util.Collections;
  44 import java.util.Date;
  45 import java.util.Enumeration;
  46 import java.util.Locale;
  47 import java.util.Properties;
  48 import java.util.StringTokenizer;
  49 import java.util.TreeSet;
  50
  51 import org.apache.log4j.ConsoleAppender;
  52 import org.apache.log4j.Level;
  53 import org.apache.log4j.Logger;
  54 import org.apache.log4j.SimpleLayout;
  55
  56 /**
  57  * Stores and retrieves Jalview Application Properties Lists and fields within
  58  * list entries are separated by '|' symbols unless otherwise stated (|) clauses
  59  * are alternative values for a tag. <br>
  60  * <br>
  61  * Current properties include:
  62  * <ul>
  63  * <br>
  64  * logs.Axis.Level - one of the stringified Levels for log4j controlling the
  65  * logging level for axis (used for web services) <br>
  66  * </li>
  67  * <li>logs.Castor.Level - one of the stringified Levels for log4j controlling
  68  * the logging level for castor (used for serialization) <br>
  69  * </li>
  70  * <li>logs.Jalview.Level - Cache.log stringified level. <br>
  71  * </li>
  72  * <li>SCREEN_WIDTH</li>
  73  * <li>SCREEN_HEIGHT</li>
  74  * <li>SCREEN_Y=285</li>
  75  * <li>SCREEN_X=371</li>
  76  * <li>SHOW_FULLSCREEN boolean</li>
  77  * <li>FONT_NAME java font name for alignment text display</li>
  78  * <li>FONT_SIZE size of displayed alignment text</li>
  79  * <li>FONT_STYLE style of font displayed (sequence labels are always
  80  * italic)</li>
  81  * <li>GAP_SYMBOL character to treat as gap symbol (usually -,.,' ')</li>
  82  * <li>LAST_DIRECTORY last directory for browsing alignment</li>
  83  * <li>USER_DEFINED_COLOURS list of user defined colour scheme files</li>
  84  * <li>SHOW_FULL_ID show id with '/start-end' numbers appended</li>
  85  * <li>SHOW_IDENTITY show percentage identity annotation</li>
  86  * <li>SHOW_QUALITY show alignment quality annotation</li>
  87  * <li>SHOW_ANNOTATIONS show alignment annotation rows</li>
  88  * <li>SHOW_CONSERVATION show alignment conservation annotation</li>
  89  * <li>SORT_ANNOTATIONS currently either SEQUENCE_AND_LABEL or
  90  * LABEL_AND_SEQUENCE</li>
  91  * <li>SHOW_AUTOCALC_ABOVE true to show autocalculated annotations above
  92  * sequence annotations</li>
  93  * <li>CENTRE_COLUMN_LABELS centre the labels at each column in a displayed
  94  * annotation row</li>
  95  * <li>DEFAULT_COLOUR default colour scheme to apply for a new alignment</li>
  96  * <li>DEFAULT_FILE_FORMAT file format used to save</li>
  97  * <li>STARTUP_FILE file loaded on startup (may be a fully qualified url)</li>
  98  * <li>SHOW_STARTUP_FILE flag to control loading of startup file</li>
  99  * <li>VERSION the version of the jalview build</li>
 100  * <li>BUILD_DATE date of this build</li>
 101  * <li>LATEST_VERSION the latest jalview version advertised on the
 102  * www.jalview.org</li>
 103  * <li>PIR_MODELLER boolean indicating if PIR files are written with MODELLER
 104  * descriptions</li>
 105  * <li>(FASTA,MSF,PILEUP,CLUSTAL,BLC,PIR,PFAM)_JVSUFFIX boolean for adding jv
 106  * suffix to file</li>
 107  * <li>RECENT_URL list of recently retrieved URLs</li>
 108  * <li>RECENT_FILE list of recently opened files</li>
 109  * <li>USE_PROXY flag for whether a http proxy is to be used</li>
 110  * <li>PROXY_SERVER the proxy</li>
 111  * <li>PROXY_PORT</li>
 112  * <li>NOQUESTIONNAIRES true to prevent jalview from checking the questionnaire
 113  * service</li>
 114  * <li>QUESTIONNAIRE last questionnaire:responder id string from questionnaire
 115  * service</li>
 116  * <li>USAGESTATS (false - user prompted) Enable google analytics tracker for
 117  * collecting usage statistics</li>
 118  * <li>DAS_LOCAL_SOURCE list of local das sources</li>
 119  * <li>SHOW_OVERVIEW boolean for overview window display</li>
 120  * <li>ANTI_ALIAS boolean for smooth fonts</li>
 121  * <li>RIGHT_ALIGN_IDS boolean</li>
 122  * <li>AUTO_CALC_CONSENSUS boolean for automatic recalculation of consensus</li>
 123  * <li>PAD_GAPS boolean</li>
 124  * <li>ID_ITALICS boolean</li>
 125  * <li>SHOW_JV_SUFFIX</li>
 126  * <li>WRAP_ALIGNMENT</li>
 127  * <li>EPS_RENDERING (Prompt each time|Lineart|Text) default for EPS rendering
 128  * style check</li>
 129  * <li>SORT_ALIGNMENT (No sort|Id|Pairwise Identity)</li>
 130  * <li>SEQUENCE_LINKS list of name|URL pairs for opening a url with
 131  * $SEQUENCE_ID$</li>
 132  * <li>STORED_LINKS list of name|url pairs which user has entered but are not
 133  * currently used
 134  * <li>DEFAULT_LINK name of single url to be used when user double clicks a
 135  * sequence id (must be in SEQUENCE_LINKS or STORED_LINKS)
 136  * <li>GROUP_LINKS list of name|URL[|&lt;separator&gt;] tuples - see
 137  * jalview.utils.GroupURLLink for more info</li>
 138  * <li>DAS_REGISTRY_URL the registry to query</li>
 139  * <li>DEFAULT_BROWSER for unix</li>
 140  * <li>DAS_ACTIVE_SOURCE list of active sources</li>
 141  * <li>SHOW_MEMUSAGE boolean show memory usage and warning indicator on desktop
 142  * (false)</li>
 143  * <li>VERSION_CHECK (true) check for the latest release version from
 144  * www.jalview.org (or the alias given by the www.jalview.org property)</li>
 145  * <li>SHOW_NPFEATS_TOOLTIP (true) show non-positional features in the Sequence
 146  * ID tooltip</li>
 147  * <li>SHOW_DBREFS_TOOLTIP (true) show Database Cross References in the Sequence
 148  * ID tooltip</li>
 149  * <li>SHOW_UNCONSERVED (false) only render unconserved residues - conserved
 150  * displayed as '.'</li>
 151  * <li>SORT_BY_TREE (false) sort the current alignment view according to the
 152  * order of a newly displayed tree</li>
 153  * <li>DBFETCH_USEPICR (false) use PICR to recover valid DB references from
 154  * sequence ID strings before attempting retrieval from any datasource</li>
 155  * <li>SHOW_GROUP_CONSENSUS (false) Show consensus annotation for groups in the
 156  * alignment.</li>
 157  * <li>SHOW_GROUP_CONSERVATION (false) Show conservation annotation for groups
 158  * in the alignment.</li>
 159  * <li>SHOW_CONSENSUS_HISTOGRAM (false) Show consensus annotation row's
 160  * histogram.</li>
 161  * <li>SHOW_CONSENSUS_LOGO (false) Show consensus annotation row's sequence
 162  * logo.</li>
 163  * <li>NORMALISE_CONSENSUS_LOGO (false) Show consensus annotation row's sequence
 164  * logo normalised to row height rather than histogram height.</li>
 165  * <li>FOLLOW_SELECTIONS (true) Controls whether a new alignment view should
 166  * respond to selections made in other alignments containing the same sequences.
 167  * </li>
 168  * <li>JWS2HOSTURLS comma-separated list of URLs to try for JABAWS services</li>
 169  * <li>SHOW_WSDISCOVERY_ERRORS (true) Controls if the web service URL discovery
 170  * warning dialog box is displayed.</li>
 171  * <li>ANNOTATIONCOLOUR_MIN (orange) Shade used for minimum value of annotation
 172  * when shading by annotation</li>
 173  * <li>ANNOTATIONCOLOUR_MAX (red) Shade used for maximum value of annotation
 174  * when shading by annotation</li>
 175  * <li>www.jalview.org (http://www.jalview.org) a property enabling all HTTP
 176  * requests to be redirected to a mirror of http://www.jalview.org</li>
 177  * <li>FIGURE_AUTOIDWIDTH (false) Expand the left hand column of an exported
 178  * alignment figure to accommodate even the longest sequence ID or annotation
 179  * label.</li>
 180  * <li>FIGURE_FIXEDIDWIDTH Specifies the width to use for the left-hand column
 181  * when exporting an alignment as a figure (setting FIGURE_AUTOIDWIDTH to true
 182  * will override this).</li>
 183  * <li>STRUCT_FROM_PDB (false) derive secondary structure annotation from PDB
 184  * record</li>
 185  * <li>USE_RNAVIEW (false) use RNAViewer to derive secondary structure</li>
 186  * <li>ADD_SS_ANN (false) add secondary structure annotation to alignment
 187  * display</li>
 188  * <li>ADD_TEMPFACT_ANN (false) add Temperature Factor annotation to alignment
 189  * display</li>
 190  * <li>STRUCTURE_DISPLAY choose from JMOL (default) or CHIMERA for 3D structure
 191  * display</li>
 192  * <li>CHIMERA_PATH specify full path to Chimera program (if non-standard)</li>
 193  * <li>ID_ORG_HOSTURL location of jalview service providing identifiers.org urls
 194  * </li>
 195  *
 196  * </ul>
 197  * Deprecated settings:
 198  * <ul>
 199  * *
 200  * <li>DISCOVERY_START - Boolean - controls if discovery services are queried on
 201  * startup (JWS1 services only)</li>
 202  * <li>DISCOVERY_URLS - comma separated list of Discovery Service endpoints.
 203  * (JWS1 services only)</li>
 204  * <li>SHOW_JWS1_SERVICES (true) enable or disable the original Jalview 2
 205  * services in the desktop GUI</li>
 206  * <li>ENABLE_RSBS_EDITOR (false for 2.7 release) enable or disable RSBS editing
 207  * panel in web service preferences</li>
 208  * </ul>
 209  *
 210  * @author $author$
 211  * @version $Revision$
 212  */
 213 public class Cache
 214 {
 215   /**
 216    * property giving log4j level for CASTOR loggers
 217    */
 218   public static final String CASTORLOGLEVEL = "logs.Castor.level";
 219
 220   /**
 221    * property giving log4j level for AXIS loggers
 222    */
 223   public static final String AXISLOGLEVEL = "logs.Axis.level";
 224
 225   /**
 226    * property giving log4j level for Jalview Log
 227    */
 228   public static final String JALVIEWLOGLEVEL = "logs.Jalview.level";
 229
 230   public static final String DAS_LOCAL_SOURCE = "DAS_LOCAL_SOURCE";
 231
 232   public static final String DAS_REGISTRY_URL = "DAS_REGISTRY_URL";
 233
 234   public static final String DAS_ACTIVE_SOURCE = "DAS_ACTIVE_SOURCE";
 235
 236   /**
 237    * Sifts settings
 238    */
 239   public static final String DEFAULT_SIFTS_DOWNLOAD_DIR = System
 240           .getProperty("user.home") + File.separatorChar
 241           + ".sifts_downloads" + File.separatorChar;
 242
 243   private final static String DEFAULT_CACHE_THRESHOLD_IN_DAYS = "2";
 244
 245   private final static String DEFAULT_FAIL_SAFE_PID_THRESHOLD = "30";
 246
 247   /**
 248    * Identifiers.org download settings
 249    */
 250   private static final String ID_ORG_FILE = System.getProperty("user.home")
 251           + File.separatorChar + ".identifiers.org.ids.json";
 252
 253   /**
 254    * Allowed values are PDB or mmCIF
 255    */
 256   private final static String PDB_DOWNLOAD_FORMAT = PDBEntry.Type.MMCIF
 257           .toString();
 258
 259   private final static String DEFAULT_PDB_FILE_PARSER = StructureImportSettings.StructureParser.JMOL_PARSER
 260           .toString();
 261
 262   /*
 263    * a date formatter using a fixed (rather than the user's) locale;
 264    * this ensures that date properties can be written and re-read successfully
 265    * even if the user changes their locale setting
 266    */
 267   private static final DateFormat date_format = SimpleDateFormat
 268           .getDateTimeInstance(SimpleDateFormat.MEDIUM,
 269                   SimpleDateFormat.MEDIUM, Locale.UK);
 270
 271   /**
 272    * Initialises the Jalview Application Log
 273    */
 274   public static Logger log;
 275
 276   /** Jalview Properties */
 277   public static Properties applicationProperties = new Properties()
 278   {
 279     // override results in properties output in alphabetical order
 280     @Override
 281     public synchronized Enumeration<Object> keys()
 282     {
 283       return Collections.enumeration(new TreeSet<>(super.keySet()));
 284     }
 285   };
 286
 287   /** Default file is ~/.jalview_properties */
 288   static String propertiesFile;
 289
 290   private static boolean propsAreReadOnly = Platform.isJS();
 291
 292   private static String JS_PROPERTY_PREFIX = "jalview_";
 293
 294   public static void initLogger()
 295   {
 296     if (log != null)
 297     {
 298       return;
 299     }
 300     try
 301     {
 302       // TODO: redirect stdout and stderr here in order to grab the output of
 303       // the log
 304
 305       ConsoleAppender ap = new ConsoleAppender(new SimpleLayout(),
 306               "System.err");
 307       ap.setName("JalviewLogger");
 308       org.apache.log4j.Logger.getRootLogger().addAppender(ap); // catch all for
 309       // log output
 310       Logger laxis = Logger.getLogger("org.apache.axis");
 311       Logger lcastor = Logger.getLogger("org.exolab.castor");
 312       jalview.bin.Cache.log = Logger.getLogger("jalview.bin.Jalview");
 313
 314       laxis.setLevel(Level.toLevel(
 315               Cache.getDefault("logs.Axis.Level", Level.INFO.toString())));
 316       lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level",
 317               Level.INFO.toString())));
 318       lcastor = Logger.getLogger("org.exolab.castor.xml");
 319       lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level",
 320               Level.INFO.toString())));
 321       // lcastor = Logger.getLogger("org.exolab.castor.xml.Marshaller");
 322       // lcastor.setLevel(Level.toLevel(Cache.getDefault("logs.Castor.Level",
 323       // Level.INFO.toString())));
 324       jalview.bin.Cache.log.setLevel(Level.toLevel(Cache
 325               .getDefault("logs.Jalview.level", Level.INFO.toString())));
 326       // laxis.addAppender(ap);
 327       // lcastor.addAppender(ap);
 328       // jalview.bin.Cache.log.addAppender(ap);
 329       // Tell the user that debug is enabled
 330       jalview.bin.Cache.log.debug("Jalview Debugging Output Follows.");
 331     } catch (Exception ex)
 332     {
 333       System.err.println("Problems initializing the log4j system\n");
 334       ex.printStackTrace(System.err);
 335     }
 336   }
 337
 338   /**
 339    * Loads properties from the given properties file. Any existing properties
 340    * are first cleared.
 341    */
 342   public static void loadProperties(String propsFile)
 343   {
 344     propertiesFile = propsFile;
 345     if (propsFile == null && !propsAreReadOnly)
 346     {
 347       propertiesFile = System.getProperty("user.home") + File.separatorChar
 348               + ".jalview_properties";
 349     }
 350     else
 351     {
 352       // don't corrupt the file we've been given.
 353       propsAreReadOnly = true;
 354     }
 355
 356     if (propertiesFile == null)
 357     { // BH 2019
 358         Platform.readInfoProperties(JS_PROPERTY_PREFIX , applicationProperties);
 359     } else {
 360             try
 361             {
 362               InputStream fis;
 363               try
 364               {
 365                 fis = new java.net.URL(propertiesFile).openStream();
 366                 System.out.println(
 367                         "Loading jalview properties from : " + propertiesFile);
 368                 System.out.println(
 369                         "Disabling Jalview writing to user's local properties file.");
 370                 propsAreReadOnly = true;
 371
 372               } catch (Exception ex)
 373               {
 374                 fis = null;
 375               }
 376               if (fis == null)
 377               {
 378                 fis = new FileInputStream(propertiesFile);
 379               }
 380               applicationProperties.clear();
 381               applicationProperties.load(fis);
 382
 383               // remove any old build properties
 384
 385               deleteBuildProperties();
 386               fis.close();
 387             } catch (Exception ex)
 388             {
 389               System.out.println("Error reading properties file: " + ex);
 390             }
 391     }
 392     if (getDefault("USE_PROXY", false))
 393     {
 394       String proxyServer = getDefault("PROXY_SERVER", ""),
 395               proxyPort = getDefault("PROXY_PORT", "8080");
 396
 397       System.out.println("Using proxyServer: " + proxyServer
 398               + " proxyPort: " + proxyPort);
 399
 400       System.setProperty("http.proxyHost", proxyServer);
 401       System.setProperty("http.proxyPort", proxyPort);
 402     }
 403
 404     // LOAD THE AUTHORS FROM THE authors.props file
 405     String authorDetails = (Platform.isJS() ? null :
 406             "jar:"
 407             .concat(Cache.class.getProtectionDomain().getCodeSource()
 408                     .getLocation().toString().concat("!/authors.props")));
 409
 410     try
 411     {
 412       if (authorDetails != null) {
 413           java.net.URL localJarFileURL = new java.net.URL(authorDetails);
 414           InputStream in = localJarFileURL.openStream();
 415           applicationProperties.load(in);
 416           in.close();
 417       }
 418     } catch (Exception ex) {
 419     System.out.println("Error reading author details: " + ex);
 420         authorDetails = null;
 421     }
 422     if (authorDetails == null)
 423     {
 424         applicationProperties.remove("AUTHORS");
 425         applicationProperties.remove("AUTHORFNAMES");
 426         applicationProperties.remove("YEAR");
 427     }
 428
 429     // FIND THE VERSION NUMBER AND BUILD DATE FROM jalview.jar
 430     // MUST FOLLOW READING OF LOCAL PROPERTIES FILE AS THE
 431     // VERSION MAY HAVE CHANGED SINCE LAST USING JALVIEW
 432     String buildDetails = (Platform.isJS() ? null :
 433             "jar:".concat(Cache.class.getProtectionDomain()
 434             .getCodeSource().getLocation().toString()
 435             .concat("!/.build_properties")));
 436     if (buildDetails != null)
 437     {
 438             try
 439             {
 440               java.net.URL localJarFileURL = new java.net.URL(buildDetails);
 441               InputStream in = localJarFileURL.openStream();
 442               applicationProperties.load(in);
 443               in.close();
 444             } catch (Exception ex)
 445             {
 446               System.out.println("Error reading build details: " + ex);
 447               buildDetails = null;
 448             }
 449     }
 450     if (buildDetails == null)
 451     {
 452               applicationProperties.remove("VERSION");
 453     }
 454     String jnlpVersion = System.getProperty("jalview.version");
 455     String codeVersion = getProperty("VERSION");
 456     String codeInstallation = getProperty("INSTALLATION");
 457     if (codeVersion == null)
 458     {
 459       // THIS SHOULD ONLY BE THE CASE WHEN TESTING!!
 460       codeVersion = "Test";
 461       jnlpVersion = "Test";
 462       codeInstallation = "";
 463     }
 464     else
 465     {
 466       codeInstallation = " (" + codeInstallation + ")";
 467     }
 468     new BuildDetails(codeVersion, null, codeInstallation);
 469
 470     SiftsSettings
 471             .setMapWithSifts(Cache.getDefault("MAP_WITH_SIFTS", false));
 472
 473     SiftsSettings.setSiftDownloadDirectory(jalview.bin.Cache
 474             .getDefault("sifts_download_dir", DEFAULT_SIFTS_DOWNLOAD_DIR));
 475
 476     SiftsSettings.setFailSafePIDThreshold(
 477             jalview.bin.Cache.getDefault("sifts_fail_safe_pid_threshold",
 478                     DEFAULT_FAIL_SAFE_PID_THRESHOLD));
 479
 480     SiftsSettings.setCacheThresholdInDays(
 481             jalview.bin.Cache.getDefault("sifts_cache_threshold_in_days",
 482                     DEFAULT_CACHE_THRESHOLD_IN_DAYS));
 483
 484     IdOrgSettings.setUrl(getDefault("ID_ORG_HOSTURL",
 485             "http://www.jalview.org/services/identifiers"));
 486     IdOrgSettings.setDownloadLocation(ID_ORG_FILE);
 487
 488     System.out
 489             .println("Jalview Version: " + codeVersion + codeInstallation);
 490
 491     StructureImportSettings.setDefaultStructureFileFormat(jalview.bin.Cache
 492             .getDefault("PDB_DOWNLOAD_FORMAT", PDB_DOWNLOAD_FORMAT));
 493     StructureImportSettings
 494             .setDefaultPDBFileParser(DEFAULT_PDB_FILE_PARSER);
 495     // StructureImportSettings
 496     // .setDefaultPDBFileParser(jalview.bin.Cache.getDefault(
 497     // "DEFAULT_PDB_FILE_PARSER", DEFAULT_PDB_FILE_PARSER));
 498     // jnlpVersion will be null if we're using InstallAnywhere
 499     // Dont do this check if running in headless mode
 500     if (jnlpVersion == null && getDefault("VERSION_CHECK", true)
 501             && (System.getProperty("java.awt.headless") == null || System
 502                     .getProperty("java.awt.headless").equals("false")))
 503     {
 504
 505       class VersionChecker extends Thread
 506       {
 507         @Override
 508         public void run()
 509         {
 510           String orgtimeout = System
 511                   .getProperty("sun.net.client.defaultConnectTimeout");
 512           if (orgtimeout == null)
 513           {
 514             orgtimeout = "30";
 515             System.out.println("# INFO: Setting default net timeout to "
 516                     + orgtimeout + " seconds.");
 517           }
 518           String remoteVersion = null;
 519           try
 520           {
 521             System.setProperty("sun.net.client.defaultConnectTimeout",
 522                     "5000");
 523             java.net.URL url = new java.net.URL(Cache
 524                     .getDefault("www.jalview.org", "http://www.jalview.org")
 525                     + "/webstart/jalview.jnlp");
 526             BufferedReader in = new BufferedReader(
 527                     new InputStreamReader(url.openStream()));
 528             String line = null;
 529             while ((line = in.readLine()) != null)
 530             {
 531               if (line.indexOf("jalview.version") == -1)
 532               {
 533                 continue;
 534               }
 535
 536               line = line.substring(line.indexOf("value=") + 7);
 537               line = line.substring(0, line.lastIndexOf("\""));
 538               remoteVersion = line;
 539               break;
 540             }
 541           } catch (Exception ex)
 542           {
 543             System.out.println(
 544                     "Non-fatal exception when checking version at www.jalview.org :");
 545             System.out.println(ex);
 546             remoteVersion = getProperty("VERSION");
 547           }
 548           System.setProperty("sun.net.client.defaultConnectTimeout",
 549                   orgtimeout);
 550
 551           setProperty("LATEST_VERSION", remoteVersion);
 552         }
 553       }
 554
 555       VersionChecker vc = new VersionChecker();
 556       vc.start();
 557     }
 558     else
 559     {
 560       if (jnlpVersion != null)
 561       {
 562         setProperty("LATEST_VERSION", jnlpVersion);
 563       }
 564       else
 565       {
 566         applicationProperties.remove("LATEST_VERSION");
 567       }
 568     }
 569
 570     setProperty("VERSION", codeVersion);
 571
 572     // LOAD USERDEFINED COLOURS
 573     jalview.bin.Cache
 574             .initUserColourSchemes(getProperty("USER_DEFINED_COLOURS"));
 575     jalview.io.PIRFile.useModellerOutput = Cache.getDefault("PIR_MODELLER",
 576             false);
 577   }
 578
 579   private static void deleteBuildProperties()
 580   {
 581     applicationProperties.remove("LATEST_VERSION");
 582     applicationProperties.remove("VERSION");
 583     applicationProperties.remove("AUTHORS");
 584     applicationProperties.remove("AUTHORFNAMES");
 585     applicationProperties.remove("YEAR");
 586     applicationProperties.remove("BUILD_DATE");
 587     applicationProperties.remove("INSTALLATION");
 588   }
 589
 590   /**
 591    * Gets Jalview application property of given key. Returns null if key not
 592    * found
 593    *
 594    * @param key
 595    *          Name of property
 596    *
 597    * @return Property value
 598    */
 599   public static String getProperty(String key)
 600   {
 601
 602     String prop = applicationProperties.getProperty(key);
 603     if (prop == null && Platform.isJS())
 604     {
 605         prop = applicationProperties.getProperty(Platform.getUniqueAppletID() + "_" + JS_PROPERTY_PREFIX + key);
 606     }
 607
 608     return prop;
 609   }
 610
 611   /**
 612    * These methods are used when checking if the saved preference is different
 613    * to the default setting
 614    */
 615
 616   public static boolean getDefault(String property, boolean def)
 617   {
 618     String string = getProperty(property);
 619     if (string != null)
 620     {
 621       def = Boolean.valueOf(string).booleanValue();
 622     }
 623
 624     return def;
 625   }
 626
 627   /**
 628    * Answers the value of the given property, or the supplied default value if
 629    * the property is not set
 630    */
 631   public static String getDefault(String property, String def)
 632   {
 633     String value = getProperty(property);
 634     return value == null ? def : value;
 635   }
 636
 637   /**
 638    * Stores property in the file "HOME_DIR/.jalview_properties"
 639    *
 640    * @param key
 641    *          Name of object
 642    * @param obj
 643    *          String value of property
 644    *
 645    * @return previous value of property (or null)
 646    */
 647   public static Object setProperty(String key, String obj)
 648   {
 649     Object oldValue = null;
 650     try
 651     {
 652       oldValue = applicationProperties.setProperty(key, obj);
 653       if (!propsAreReadOnly)
 654       {
 655         FileOutputStream out = new FileOutputStream(propertiesFile);
 656         applicationProperties.store(out, "---JalviewX Properties File---");
 657         out.close();
 658       }
 659     } catch (Exception ex)
 660     {
 661       System.out.println(
 662               "Error setting property: " + key + " " + obj + "\n" + ex);
 663     }
 664     return oldValue;
 665   }
 666
 667   /**
 668    * remove the specified property from the jalview properties file
 669    *
 670    * @param string
 671    */
 672   public static void removeProperty(String string)
 673   {
 674     applicationProperties.remove(string);
 675     saveProperties();
 676   }
 677
 678   /**
 679    * save the properties to the jalview properties path
 680    */
 681   public static void saveProperties()
 682   {
 683     if (!propsAreReadOnly)
 684     {
 685       try
 686       {
 687         FileOutputStream out = new FileOutputStream(propertiesFile);
 688         applicationProperties.store(out, "---JalviewX Properties File---");
 689         out.close();
 690       } catch (Exception ex)
 691       {
 692         System.out.println("Error saving properties: " + ex);
 693       }
 694     }
 695   }
 696
 697   /**
 698    * internal vamsas class discovery state
 699    */
 700   private static int vamsasJarsArePresent = -1;
 701
 702   /**
 703    * Searches for vamsas client classes on class path.
 704    *
 705    * @return true if vamsas client is present on classpath
 706    */
 707   public static boolean vamsasJarsPresent()
 708   {
 709     if (vamsasJarsArePresent == -1)
 710     {
 711       try
 712       {
 713         if (jalview.jbgui.GDesktop.class.getClassLoader()
 714                 .loadClass("uk.ac.vamsas.client.VorbaId") != null)
 715         {
 716           jalview.bin.Cache.log.debug(
 717                   "Found Vamsas Classes (uk.ac..vamsas.client.VorbaId can be loaded)");
 718           vamsasJarsArePresent = 1;
 719           Logger lvclient = Logger.getLogger("uk.ac.vamsas");
 720           lvclient.setLevel(Level.toLevel(Cache
 721                   .getDefault("logs.Vamsas.Level", Level.INFO.toString())));
 722
 723           lvclient.addAppender(log.getAppender("JalviewLogger"));
 724           // Tell the user that debug is enabled
 725           lvclient.debug("Jalview Vamsas Client Debugging Output Follows.");
 726         }
 727       } catch (Exception e)
 728       {
 729         vamsasJarsArePresent = 0;
 730         jalview.bin.Cache.log.debug("Vamsas Classes are not present");
 731       }
 732     }
 733     return (vamsasJarsArePresent > 0);
 734   }
 735
 736   /**
 737    * internal vamsas class discovery state
 738    */
 739   private static int groovyJarsArePresent = -1;
 740
 741   /**
 742    * Searches for vamsas client classes on class path.
 743    *
 744    * @return true if vamsas client is present on classpath
 745    */
 746   public static boolean groovyJarsPresent()
 747   {
 748     if (groovyJarsArePresent == -1)
 749     {
 750       try
 751       {
 752         if (Cache.class.getClassLoader()
 753                 .loadClass("groovy.lang.GroovyObject") != null)
 754         {
 755           jalview.bin.Cache.log.debug(
 756                   "Found Groovy (groovy.lang.GroovyObject can be loaded)");
 757           groovyJarsArePresent = 1;
 758           Logger lgclient = Logger.getLogger("groovy");
 759           lgclient.setLevel(Level.toLevel(Cache
 760                   .getDefault("logs.Groovy.Level", Level.INFO.toString())));
 761
 762           lgclient.addAppender(log.getAppender("JalviewLogger"));
 763           // Tell the user that debug is enabled
 764           lgclient.debug("Jalview Groovy Client Debugging Output Follows.");
 765         }
 766       } catch (Error e)
 767       {
 768         groovyJarsArePresent = 0;
 769         jalview.bin.Cache.log.debug("Groovy Classes are not present", e);
 770       } catch (Exception e)
 771       {
 772         groovyJarsArePresent = 0;
 773         jalview.bin.Cache.log.debug("Groovy Classes are not present");
 774       }
 775     }
 776     return (groovyJarsArePresent > 0);
 777   }
 778
 779   /**
 780    * GA tracker object - actually JGoogleAnalyticsTracker null if tracking not
 781    * enabled.
 782    */
 783   protected static Object tracker = null;
 784
 785   protected static Class trackerfocus = null;
 786
 787   protected static Class jgoogleanalyticstracker = null;
 788
 789   /**
 790    * Initialise the google tracker if it is not done already.
 791    */
 792   public static void initGoogleTracker()
 793   {
 794     if (tracker == null)
 795     {
 796       if (jgoogleanalyticstracker == null)
 797       {
 798         // try to get the tracker class
 799         try
 800         {
 801           jgoogleanalyticstracker = Cache.class.getClassLoader().loadClass(
 802                   "com.boxysystems.jgoogleanalytics.JGoogleAnalyticsTracker");
 803           trackerfocus = Cache.class.getClassLoader()
 804                   .loadClass("com.boxysystems.jgoogleanalytics.FocusPoint");
 805         } catch (Exception e)
 806         {
 807           log.debug(
 808                   "com.boxysystems.jgoogleanalytics package is not present - tracking not enabled.");
 809           tracker = null;
 810           jgoogleanalyticstracker = null;
 811           trackerfocus = null;
 812           return;
 813         }
 814       }
 815       // now initialise tracker
 816       Exception re = null, ex = null;
 817       Error err = null;
 818       String vrs = "No Version Accessible";
 819       try
 820       {
 821         // Google analytics tracking code for Library Finder
 822         tracker = jgoogleanalyticstracker
 823                 .getConstructor(new Class[]
 824                 { String.class, String.class, String.class })
 825                 .newInstance(new Object[]
 826                 { "Jalview Desktop",
 827                     (vrs = jalview.bin.Cache.getProperty("VERSION") + "_"
 828                             + jalview.bin.Cache.getDefault("BUILD_DATE",
 829                                     "unknown")),
 830                     "UA-9060947-1" });
 831         jgoogleanalyticstracker
 832                 .getMethod("trackAsynchronously", new Class[]
 833                 { trackerfocus })
 834                 .invoke(tracker, new Object[]
 835                 { trackerfocus.getConstructor(new Class[] { String.class })
 836                         .newInstance(new Object[]
 837                         { "Application Started." }) });
 838       } catch (RuntimeException e)
 839       {
 840         re = e;
 841       } catch (Exception e)
 842       {
 843         ex = e;
 844       } catch (Error e)
 845       {
 846         err = e;
 847       }
 848       if (re != null || ex != null || err != null)
 849       {
 850         if (log != null)
 851         {
 852           if (re != null)
 853           {
 854             log.debug("Caught runtime exception in googletracker init:",
 855                     re);
 856           }
 857           if (ex != null)
 858           {
 859             log.warn(
 860                     "Failed to initialise GoogleTracker for Jalview Desktop with version "
 861                             + vrs,
 862                     ex);
 863           }
 864           if (err != null)
 865           {
 866             log.error(
 867                     "Whilst initing GoogleTracker for Jalview Desktop version "
 868                             + vrs,
 869                     err);
 870           }
 871         }
 872         else
 873         {
 874           if (re != null)
 875           {
 876             System.err.println(
 877                     "Debug: Caught runtime exception in googletracker init:"
 878                             + vrs);
 879             re.printStackTrace();
 880           }
 881           if (ex != null)
 882           {
 883             System.err.println(
 884                     "Warning:  Failed to initialise GoogleTracker for Jalview Desktop with version "
 885                             + vrs);
 886             ex.printStackTrace();
 887           }
 888
 889           if (err != null)
 890           {
 891             System.err.println(
 892                     "ERROR: Whilst initing GoogleTracker for Jalview Desktop version "
 893                             + vrs);
 894             err.printStackTrace();
 895           }
 896         }
 897       }
 898       else
 899       {
 900         log.debug("Successfully initialised tracker.");
 901       }
 902     }
 903   }
 904
 905   /**
 906    * get the user's default colour if available
 907    *
 908    * @param property
 909    * @param defcolour
 910    * @return
 911    */
 912   public static Color getDefaultColour(String property, Color defcolour)
 913   {
 914     String colprop = getProperty(property);
 915     if (colprop == null)
 916     {
 917       return defcolour;
 918     }
 919     Color col = ColorUtils.parseColourString(colprop);
 920     if (col == null)
 921     {
 922       log.warn("Couldn't parse '" + colprop + "' as a colour for "
 923               + property);
 924     }
 925     return (col == null) ? defcolour : col;
 926   }
 927
 928   /**
 929    * store a colour as a Jalview user default property
 930    *
 931    * @param property
 932    * @param colour
 933    */
 934   public static void setColourProperty(String property, Color colour)
 935   {
 936     setProperty(property, jalview.util.Format.getHexString(colour));
 937   }
 938
 939   /**
 940    * Stores a formatted date in a jalview property, using a fixed locale.
 941    *
 942    * @param propertyName
 943    * @param date
 944    * @return the formatted date string
 945    */
 946   public static String setDateProperty(String propertyName, Date date)
 947   {
 948     String formatted = date_format.format(date);
 949     setProperty(propertyName, formatted);
 950     return formatted;
 951   }
 952
 953   /**
 954    * Reads a date stored in a Jalview property, parses it (using a fixed locale
 955    * format) and returns as a Date, or null if parsing fails
 956    *
 957    * @param propertyName
 958    * @return
 959    *
 960    */
 961   public static Date getDateProperty(String propertyName)
 962   {
 963     String val = getProperty(propertyName);
 964     if (val != null)
 965     {
 966       try
 967       {
 968         return date_format.parse(val);
 969       } catch (Exception ex)
 970       {
 971         System.err.println("Invalid or corrupt date in property '"
 972                 + propertyName + "' : value was '" + val + "'");
 973       }
 974     }
 975     return null;
 976   }
 977
 978   /**
 979    * get and parse a property as an integer. send any parsing problems to
 980    * System.err
 981    *
 982    * @param property
 983    * @return null or Integer
 984    */
 985   public static Integer getIntegerProperty(String property)
 986   {
 987     String val = getProperty(property);
 988     if (val != null && (val = val.trim()).length() > 0)
 989     {
 990       try
 991       {
 992         return Integer.valueOf(val);
 993       } catch (NumberFormatException x)
 994       {
 995         System.err.println("Invalid integer in property '" + property
 996                 + "' (value was '" + val + "')");
 997       }
 998     }
 999     return null;
1000   }
1001
1002   /**
1003    * Set the specified value, or remove it if null or empty. Does not save the
1004    * properties file.
1005    *
1006    * @param propName
1007    * @param value
1008    */
1009   public static void setOrRemove(String propName, String value)
1010   {
1011     if (propName == null)
1012     {
1013       return;
1014     }
1015     if (value == null || value.trim().length() < 1)
1016     {
1017       Cache.applicationProperties.remove(propName);
1018     }
1019     else
1020     {
1021       Cache.applicationProperties.setProperty(propName, value);
1022     }
1023   }
1024
1025   /**
1026    * Loads in user colour schemes from files.
1027    *
1028    * @param files
1029    *          a '|'-delimited list of file paths
1030    */
1031   public static void initUserColourSchemes(String files)
1032   {
1033     if (files == null || files.length() == 0)
1034     {
1035       return;
1036     }
1037
1038     // In case colours can't be loaded, we'll remove them
1039     // from the default list here.
1040     StringBuffer coloursFound = new StringBuffer();
1041     StringTokenizer st = new StringTokenizer(files, "|");
1042     while (st.hasMoreElements())
1043     {
1044       String file = st.nextToken();
1045       try
1046       {
1047         UserColourScheme ucs = ColourSchemeLoader.loadColourScheme(file);
1048         if (ucs != null)
1049         {
1050           if (coloursFound.length() > 0)
1051           {
1052             coloursFound.append("|");
1053           }
1054           coloursFound.append(file);
1055           ColourSchemes.getInstance().registerColourScheme(ucs);
1056         }
1057       } catch (Exception ex)
1058       {
1059         System.out.println("Error loading User ColourFile\n" + ex);
1060       }
1061     }
1062     if (!files.equals(coloursFound.toString()))
1063     {
1064       if (coloursFound.toString().length() > 1)
1065       {
1066         setProperty(UserDefinedColours.USER_DEFINED_COLOURS,
1067                 coloursFound.toString());
1068       }
1069       else
1070       {
1071         applicationProperties
1072                 .remove(UserDefinedColours.USER_DEFINED_COLOURS);
1073       }
1074     }
1075   }
1076
1077         /**
1078          * Add a known domain that implements access-control-allow-origin:* bh 2018
1079          *
1080          * @param defaultUniprotDomain
1081          */
1082         public static void addJ2SDirectDatabaseCall(String domain)
1083         {
1084
1085                 /**
1086                  * @j2sNative
1087                  *
1088                  *                      J2S.addDirectDatabaseCall(domain);
1089                  */
1090         }
1091 }