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