X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=build.gradle;h=db1b53364fda582682f7aaec8c782b6d69aeeb9b;hb=225f7f621ba32ba196f3c7805c79c85b32faa5e5;hp=fc1d7c25cfaa4a17733d7bd992dc2601c17f8c43;hpb=1b7f570e89db9e6f0b0604a49cf0f04f90a60629;p=jalview.git

diff --git a/build.gradle b/build.gradle
index fc1d7c2..db1b533 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,18 +1,36 @@
+/* Convention for properties.  Read from gradle.properties, use lower_case_underlines for property names.
+ * For properties set within build.gradle, use camelCaseNoSpace.
+ */
 import org.apache.tools.ant.filters.ReplaceTokens
 import org.gradle.internal.os.OperatingSystem
+import org.gradle.plugins.ide.internal.generator.PropertiesPersistableConfigurationObject
+import org.gradle.api.internal.PropertiesTransformer
+import org.gradle.util.ConfigureUtil
 import org.gradle.plugins.ide.eclipse.model.Output
 import org.gradle.plugins.ide.eclipse.model.Library
 import java.security.MessageDigest
 import groovy.transform.ExternalizeMethods
 import groovy.util.XmlParser
 import groovy.xml.XmlUtil
-
+import com.vladsch.flexmark.util.ast.Node
+import com.vladsch.flexmark.html.HtmlRenderer
+import com.vladsch.flexmark.parser.Parser
+import com.vladsch.flexmark.util.data.MutableDataSet
+import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
+import com.vladsch.flexmark.ext.tables.TablesExtension
+import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughExtension
+import com.vladsch.flexmark.ext.autolink.AutolinkExtension
+import com.vladsch.flexmark.ext.anchorlink.AnchorLinkExtension
+import com.vladsch.flexmark.ext.toc.TocExtension
 
 buildscript {
   repositories {
     mavenCentral()
     mavenLocal()
   }
+  dependencies {
+    classpath "com.vladsch.flexmark:flexmark-all:0.62.0"
+  }
 }
 
 
@@ -20,9 +38,11 @@ plugins {
   id 'java'
   id 'application'
   id 'eclipse'
+  id "com.diffplug.gradle.spotless" version "3.28.0"
   id 'com.github.johnrengelman.shadow' version '4.0.3'
   id 'com.install4j.gradle' version '8.0.4'
   id 'com.dorongold.task-tree' version '1.5' // only needed to display task dependency tree with  gradle task1 [task2 ...] taskTree
+  id 'com.palantir.git-version' version '0.12.3'
 }
 
 repositories {
@@ -37,24 +57,13 @@ def string(Object o) {
   return o == null ? "" : o.toString()
 }
 
-
-ext {
-  jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath()
-  jalviewDirRelativePath = jalviewDir
-
-  // local build environment properties
-  // can be "projectDir/local.properties"
-  def localProps = "${projectDir}/local.properties"
-  def propsFile = null;
-  if (file(localProps).exists()) {
-    propsFile = localProps
-  }
-  // or "../projectDir_local.properties"
-  def dirLocalProps = projectDir.getParent() + "/" + projectDir.getName() + "_local.properties"
-  if (file(dirLocalProps).exists()) {
-    propsFile = dirLocalProps
+def overrideProperties(String propsFileName, boolean output = false) {
+  if (propsFileName == null) {
+    return
   }
-  if (propsFile != null) {
+  def propsFile = file(propsFileName)
+  if (propsFile != null && propsFile.exists()) {
+    println("Using properties from file '${propsFileName}'")
     try {
       def p = new Properties()
       def localPropsFIS = new FileInputStream(propsFile)
@@ -62,18 +71,43 @@ ext {
       localPropsFIS.close()
       p.each {
         key, val -> 
-          def oldval = findProperty(key)
-          setProperty(key, val)
-          if (oldval != null) {
-            println("Overriding property '${key}' ('${oldval}') with ${file(propsFile).getName()} value '${val}'")
+          def oldval
+          if (project.hasProperty(key)) {
+            oldval = project.findProperty(key)
+            project.setProperty(key, val)
+            if (output) {
+              println("Overriding property '${key}' ('${oldval}') with ${file(propsFile).getName()} value '${val}'")
+            }
           } else {
-            println("Setting unknown property '${key}' with ${file(propsFile).getName()}s value '${val}'")
+            ext.setProperty(key, val)
+            if (output) {
+              println("Setting ext property '${key}' with ${file(propsFile).getName()}s value '${val}'")
+            }
           }
       }
     } catch (Exception e) {
-      System.out.println("Exception reading local.properties")
+      println("Exception reading local.properties")
+      e.printStackTrace()
     }
   }
+}
+
+ext {
+  jalviewDirAbsolutePath = file(jalviewDir).getAbsolutePath()
+  jalviewDirRelativePath = jalviewDir
+
+  getdownChannelName = CHANNEL.toLowerCase()
+  // default to "default". Currently only has different cosmetics for "develop", "release", "default"
+  propertiesChannelName = ["develop", "release", "test-release"].contains(getdownChannelName) ? getdownChannelName : "default"
+  // Import channel_properties
+  channelDir = string("${jalviewDir}/${channel_properties_dir}/${propertiesChannelName}")
+  channelGradleProperties = string("${channelDir}/channel_gradle.properties")
+  overrideProperties(channelGradleProperties, false)
+  // local build environment properties
+  // can be "projectDir/local.properties"
+  overrideProperties("${projectDir}/local.properties", true)
+  // or "../projectDir_local.properties"
+  overrideProperties(projectDir.getParent() + "/" + projectDir.getName() + "_local.properties", true)
 
   ////  
   // Import releaseProps from the RELEASE file
@@ -91,7 +125,7 @@ ext {
   }
   ////
   // Set JALVIEW_VERSION if it is not already set
-  if (findProperty(JALVIEW_VERSION)==null || "".equals(JALVIEW_VERSION)) {
+  if (findProperty("JALVIEW_VERSION")==null || "".equals(JALVIEW_VERSION)) {
     JALVIEW_VERSION = releaseProps.get("jalview.version")
   }
   
@@ -112,6 +146,11 @@ ext {
   } else {
     println("HEADLESS BUILD")
   }
+  
+  J2S_ENABLED = (project.hasProperty('j2s.compiler.status') && project['j2s.compiler.status'] != null && project['j2s.compiler.status'] == "enable")
+  if (J2S_ENABLED) {
+    println("J2S ENABLED")
+  } 
   /* *-/
   System.properties.sort { it.key }.each {
     key, val -> println("SYSTEM PROPERTY ${key}='${val}'")
@@ -136,35 +175,37 @@ ext {
   cloverBuildDir = "${buildDir}/clover"
   cloverInstrDir = file("${cloverBuildDir}/clover-instr")
   cloverClassesDir = file("${cloverBuildDir}/clover-classes")
-  cloverReportDir = file("${cloverBuildDir}/clover-report")
+  cloverReportDir = file("${buildDir}/reports/clover")
   cloverTestInstrDir = file("${cloverBuildDir}/clover-test-instr")
   cloverTestClassesDir = file("${cloverBuildDir}/clover-test-classes")
   //cloverTestClassesDir = cloverClassesDir
   cloverDb = string("${cloverBuildDir}/clover.db")
 
-  resourceClassesDir = useClover ? cloverClassesDir : classesDir
-
   testSourceDir = useClover ? cloverTestInstrDir : testDir
   testClassesDir = useClover ? cloverTestClassesDir : "${jalviewDir}/${test_output_dir}"
 
   getdownWebsiteDir = string("${jalviewDir}/${getdown_website_dir}/${JAVA_VERSION}")
   buildDist = true
+  buildProperties = null
 
   // the following values might be overridden by the CHANNEL switch
-  getdownChannelName = CHANNEL.toLowerCase()
   getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
   getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
   getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher}")
   getdownAppDistDir = getdown_app_dir_alt
-  buildProperties = string("${classesDir}/${build_properties_file}")
+  getdownImagesDir = string("${jalviewDir}/${getdown_images_dir}")
   reportRsyncCommand = false
   jvlChannelName = CHANNEL.toLowerCase()
   install4jSuffix = CHANNEL.substring(0, 1).toUpperCase() + CHANNEL.substring(1).toLowerCase(); // BUILD -> Build
-  install4jDSStore = "DS_Store-NON-RELEASE"
-  install4jDMGBackgroundImage = "jalview_dmg_background-NON-RELEASE.png"
+  install4jDMGDSStore = "${install4j_images_dir}/${install4j_dmg_ds_store}"
+  install4jDMGBackgroundImage = "${install4j_images_dir}/${install4j_dmg_background}"
   install4jInstallerName = "${jalview_name} Non-Release Installer"
   install4jExecutableName = jalview_name.replaceAll("[^\\w]+", "_").toLowerCase()
   install4jExtraScheme = "jalviewx"
+  install4jMacIconsFile = string("${install4j_images_dir}/${install4j_mac_icons_file}")
+  install4jWindowsIconsFile = string("${install4j_images_dir}/${install4j_windows_icons_file}")
+  install4jPngIconFile = string("${install4j_images_dir}/${install4j_png_icon_file}")
+  install4jBackground = string("${install4j_images_dir}/${install4j_background}")
   switch (CHANNEL) {
 
     case "BUILD":
@@ -184,8 +225,6 @@ ext {
     getdownAppDistDir = getdown_app_dir_release
     reportRsyncCommand = true
     install4jSuffix = ""
-    install4jDSStore = "DS_Store"
-    install4jDMGBackgroundImage = "jalview_dmg_background.png"
     install4jInstallerName = "${jalview_name} Installer"
     break
 
@@ -228,27 +267,27 @@ ext {
     JALVIEW_VERSION=JALVIEW_VERSION+"-develop"
     
     install4jSuffix = "Develop"
-    install4jDSStore = "DS_Store-DEVELOP"
-    install4jDMGBackgroundImage = "jalview_dmg_background-DEVELOP.png"
     install4jExtraScheme = "jalviewd"
     install4jInstallerName = "${jalview_name} Develop Installer"
     break
 
     case "TEST-RELEASE":
     reportRsyncCommand = true
-    
-    // TEST-RELEASE is usually associated with a Jalview release series so set the version
-    JALVIEW_VERSION=JALVIEW_VERSION+"-test"
-    
+    // Don't ignore transpile errors for release build
+    if (jalviewjs_ignore_transpile_errors.equals("true")) {
+      jalviewjs_ignore_transpile_errors = "false"
+      println("Setting jalviewjs_ignore_transpile_errors to 'false'")
+    }
+    JALVIEW_VERSION = JALVIEW_VERSION+"-test"
     install4jSuffix = "Test"
-    install4jDSStore = "DS_Store-TEST-RELEASE"
-    install4jDMGBackgroundImage = "jalview_dmg_background-TEST.png"
     install4jExtraScheme = "jalviewt"
     install4jInstallerName = "${jalview_name} Test Installer"
     break
 
     case ~/^SCRATCH(|-[-\w]*)$/:
     getdownChannelName = CHANNEL
+    JALVIEW_VERSION = JALVIEW_VERSION+"-"+CHANNEL
+    
     getdownDir = string("${getdownChannelName}/${JAVA_VERSION}")
     getdownAppBase = string("${getdown_channel_base}/${getdownDir}")
     reportRsyncCommand = true
@@ -264,13 +303,12 @@ ext {
     }
     JALVIEW_VERSION = "TEST"
     install4jSuffix = "Test-Local"
-    install4jDSStore = "DS_Store-TEST-RELEASE"
-    install4jDMGBackgroundImage = "jalview_dmg_background-TEST.png"
     install4jExtraScheme = "jalviewt"
     install4jInstallerName = "${jalview_name} Test Installer"
     break
 
     case "LOCAL":
+    JALVIEW_VERSION = "TEST"
     getdownAppBase = file(getdownWebsiteDir).toURI().toString()
     getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
     install4jExtraScheme = "jalviewl"
@@ -283,7 +321,13 @@ ext {
   }
   // override getdownAppBase if requested
   if (findProperty("getdown_appbase_override") != null) {
-    getdownAppBase = string(getProperty("getdown_appbase_override"))
+    // revert to LOCAL if empty string
+    if (string(getdown_appbase_override) == "") {
+      getdownAppBase = file(getdownWebsiteDir).toURI().toString()
+      getdownLauncher = string("${jalviewDir}/${getdown_lib_dir}/${getdown_launcher_local}")
+    } else {
+      getdownAppBase = string(getdown_appbase_override)
+    }
     println("Overriding getdown appbase with '${getdownAppBase}'")
   }
   // sanitise file name for jalview launcher file for this channel
@@ -329,8 +373,9 @@ ext {
   modules_compileClasspath = fileTree(dir: "${jalviewDir}/${j11modDir}", include: ["*.jar"])
   modules_runtimeClasspath = modules_compileClasspath
   */
-  gitHash = string("")
-  gitBranch = string("")
+  def details = versionDetails()
+  gitHash = details.gitHash
+  gitBranch = details.branchName
 
   println("Using a ${CHANNEL} profile.")
 
@@ -408,12 +453,18 @@ ext {
     install4jHomeDir = System.getProperty("user.home") + install4jHomeDir.substring(1)
   }
 
+  resourceBuildDir = string("${buildDir}/resources")
+  resourcesBuildDir = string("${resourceBuildDir}/resources_build")
+  helpBuildDir = string("${resourceBuildDir}/help_build")
+  docBuildDir = string("${resourceBuildDir}/doc_build")
 
-
+  if (buildProperties == null) {
+    buildProperties = string("${resourcesBuildDir}/${build_properties_file}")
+  }
   buildingHTML = string("${jalviewDir}/${doc_dir}/building.html")
-  helpFile = string("${resourceClassesDir}/${help_dir}/help.jhm")
   helpParentDir = string("${jalviewDir}/${help_parent_dir}")
   helpSourceDir = string("${helpParentDir}/${help_dir}")
+  helpFile = string("${helpBuildDir}/${help_dir}/help.jhm")
 
 
   relativeBuildDir = file(jalviewDirAbsolutePath).toPath().relativize(buildDir.toPath())
@@ -433,6 +484,7 @@ ext {
   jalviewjsJalviewTemplateName = string(jalviewjs_name)
   jalviewjsJ2sSettingsFileName = string("${jalviewDir}/${jalviewjs_j2s_settings}")
   jalviewjsJ2sProps = null
+  jalviewjsJ2sPlugin = jalviewjs_j2s_plugin
 
   eclipseWorkspace = null
   eclipseBinary = string("")
@@ -450,16 +502,14 @@ sourceSets {
     }
 
     resources {
-      srcDirs resourceDir
-      srcDirs += helpParentDir
+      srcDirs = [ resourcesBuildDir, docBuildDir, helpBuildDir ]
     }
 
-    jar.destinationDir = file("${jalviewDir}/${package_dir}")
-
     compileClasspath = files(sourceSets.main.java.outputDir)
     compileClasspath += fileTree(dir: "${jalviewDir}/${libDir}", include: ["*.jar"])
 
     runtimeClasspath = compileClasspath
+    runtimeClasspath += files(sourceSets.main.resources.srcDirs)
   }
 
   clover {
@@ -496,6 +546,7 @@ sourceSets {
     compileClasspath += fileTree(dir: "${jalviewDir}/${utils_dir}/testnglibs", include: ["**/*.jar"])
 
     runtimeClasspath = compileClasspath
+    runtimeClasspath += files(sourceSets.test.resources.srcDirs)
   }
 
 }
@@ -516,14 +567,12 @@ eclipse {
 
   classpath {
     //defaultOutputDir = sourceSets.main.java.outputDir
-    def removeThese = []
-    configurations.each{
-      if (it.isCanBeResolved()) {
-        removeThese += it
+    configurations.each{ c->
+      if (c.isCanBeResolved()) {
+        minusConfigurations += [c]
       }
     }
 
-    minusConfigurations += removeThese
     plusConfigurations = [ ]
     file {
 
@@ -622,6 +671,22 @@ eclipse {
             props.putAt(t, v)
           }
         }
+        // codestyle file -- overrides previous formatter prefs
+        def csFile = file("${jalviewDirAbsolutePath}/${eclipse_codestyle_file}")
+        if (csFile.exists()) {
+          XmlParser parser = new XmlParser()
+          def profiles = parser.parse(csFile)
+          def profile = profiles.'profile'.find { p -> (p.'@kind' == "CodeFormatterProfile" && p.'@name' == "Jalview") }
+          if (profile != null) {
+            profile.'setting'.each { s ->
+              def id = s.'@id'
+              def value = s.'@value'
+              if (id != null && value != null) {
+                props.putAt(id, value)
+              }
+            }
+          }
+        }
       }
     }
 
@@ -630,11 +695,68 @@ eclipse {
   if (IN_ECLIPSE) {
     // Don't want these to be activated if in headless build
     synchronizationTasks "eclipseSynchronizationTask"
-    autoBuildTasks "eclipseAutoBuildTask"
+    //autoBuildTasks "eclipseAutoBuildTask"
+
+  }
+}
+
+
+/* hack to change eclipse prefs in .settings files other than org.eclipse.jdt.core.prefs */
+// Class to allow updating arbitrary properties files
+class PropertiesFile extends PropertiesPersistableConfigurationObject {
+  public PropertiesFile(PropertiesTransformer t) { super(t); }
+  @Override protected void load(Properties properties) { }
+  @Override protected void store(Properties properties) { }
+  @Override protected String getDefaultResourceName() { return ""; }
+  // This is necessary, because PropertiesPersistableConfigurationObject fails
+  // if no default properties file exists.
+  @Override public void loadDefaults() { load(new StringBufferInputStream("")); }
+}
+
+// Task to update arbitrary properties files (set outputFile)
+class PropertiesFileTask extends PropertiesGeneratorTask<PropertiesFile> {
+  private final PropertiesFileContentMerger file;
+  public PropertiesFileTask() { file = new PropertiesFileContentMerger(getTransformer()); }
+  protected PropertiesFile create() { return new PropertiesFile(getTransformer()); }
+  protected void configure(PropertiesFile props) {
+    file.getBeforeMerged().execute(props); file.getWhenMerged().execute(props);
+  }
+  public void file(Closure closure) { ConfigureUtil.configure(closure, file); }
+}
+
+task eclipseUIPreferences(type: PropertiesFileTask) {
+  description = "Generate Eclipse additional settings"
+  def filename = "org.eclipse.jdt.ui.prefs"
+  outputFile = "$projectDir/.settings/${filename}" as File
+  file {
+    withProperties {
+      it.load new FileInputStream("$projectDir/utils/eclipse/${filename}" as String)
+    }
+  }
+}
 
+task eclipseGroovyCorePreferences(type: PropertiesFileTask) {
+  description = "Generate Eclipse additional settings"
+  def filename = "org.eclipse.jdt.groovy.core.prefs"
+  outputFile = "$projectDir/.settings/${filename}" as File
+  file {
+    withProperties {
+      it.load new FileInputStream("$projectDir/utils/eclipse/${filename}" as String)
+    }
   }
 }
 
+task eclipseAllPreferences {
+  dependsOn eclipseJdt
+  dependsOn eclipseUIPreferences
+  dependsOn eclipseGroovyCorePreferences
+}
+
+eclipseUIPreferences.mustRunAfter eclipseJdt
+eclipseGroovyCorePreferences.mustRunAfter eclipseJdt
+
+/* end of eclipse preferences hack */
+
 
 // clover bits
 
@@ -642,6 +764,7 @@ eclipse {
 task cleanClover {
   doFirst {
     delete cloverBuildDir
+    delete cloverReportDir
   }
 }
 
@@ -764,7 +887,7 @@ task cloverHtmlReport(type: JavaExec) {
     file(cloverDb).exists()
   }
 
-  def cloverHtmlDir = "${cloverReportDir}/clover"
+  def cloverHtmlDir = cloverReportDir
   inputs.dir cloverClassesDir
   outputs.dir cloverHtmlDir
 
@@ -855,22 +978,23 @@ compileCloverJava {
 
 
 compileJava {
-
+  // JBP->BS should the print statement in doFirst refer to compile_target_compatibility ?
+  sourceCompatibility = compile_source_compatibility
+  targetCompatibility = compile_target_compatibility
+  options.compilerArgs = additional_compiler_args
+  options.encoding = "UTF-8"
   doFirst {
-    sourceCompatibility = compile_source_compatibility
-    targetCompatibility = compile_target_compatibility
-    options.compilerArgs = additional_compiler_args
-    print ("Setting target compatibility to "+targetCompatibility+"\n")
+    print ("Setting target compatibility to "+compile_target_compatibility+"\n")
   }
 
 }
 
 
 compileTestJava {
+  sourceCompatibility = compile_source_compatibility
+  targetCompatibility = compile_target_compatibility
+  options.compilerArgs = additional_compiler_args
   doFirst {
-    sourceCompatibility = compile_source_compatibility
-    targetCompatibility = compile_target_compatibility
-    options.compilerArgs = additional_compiler_args
     print ("Setting target compatibility to "+targetCompatibility+"\n")
   }
 }
@@ -898,110 +1022,146 @@ def getDate(format) {
 }
 
 
-task setGitVals {
-  def hashStdOut = new ByteArrayOutputStream()
-  exec {
-    commandLine "git", "rev-parse", "--short", "HEAD"
-    standardOutput = hashStdOut
-    ignoreExitValue true
-  }
-
-  def branchStdOut = new ByteArrayOutputStream()
-  exec {
-    commandLine "git", "rev-parse", "--abbrev-ref", "HEAD"
-    standardOutput = branchStdOut
-    ignoreExitValue true
-  }
-
-  gitHash = hashStdOut.toString().trim()
-  gitBranch = branchStdOut.toString().trim()
-
-  outputs.upToDateWhen { false }
-}
-
-
-task createBuildProperties(type: WriteProperties) {
-  dependsOn setGitVals
-  inputs.dir(sourceDir)
-  inputs.dir(resourceDir)
-  file(buildProperties).getParentFile().mkdirs()
-  outputFile (buildProperties)
-  // taking time specific comment out to allow better incremental builds
-  comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
-  //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
-  property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
-  property "VERSION", JALVIEW_VERSION
-  property "INSTALLATION", INSTALLATION+" git-commit:"+gitHash+" ["+gitBranch+"]"
-  outputs.file(outputFile)
-}
+def convertMdToHtml (FileTree mdFiles, File cssFile) {
+  MutableDataSet options = new MutableDataSet()
 
+  def extensions = new ArrayList<>()
+  extensions.add(AnchorLinkExtension.create()) 
+  extensions.add(AutolinkExtension.create())
+  extensions.add(StrikethroughExtension.create())
+  extensions.add(TaskListExtension.create())
+  extensions.add(TablesExtension.create())
+  extensions.add(TocExtension.create())
+  
+  options.set(Parser.EXTENSIONS, extensions)
+
+  // set GFM table parsing options
+  options.set(TablesExtension.WITH_CAPTION, false)
+  options.set(TablesExtension.COLUMN_SPANS, false)
+  options.set(TablesExtension.MIN_HEADER_ROWS, 1)
+  options.set(TablesExtension.MAX_HEADER_ROWS, 1)
+  options.set(TablesExtension.APPEND_MISSING_COLUMNS, true)
+  options.set(TablesExtension.DISCARD_EXTRA_COLUMNS, true)
+  options.set(TablesExtension.HEADER_SEPARATOR_COLUMN_MATCH, true)
+  // GFM anchor links
+  options.set(AnchorLinkExtension.ANCHORLINKS_SET_ID, false)
+  options.set(AnchorLinkExtension.ANCHORLINKS_ANCHOR_CLASS, "anchor")
+  options.set(AnchorLinkExtension.ANCHORLINKS_SET_NAME, true)
+  options.set(AnchorLinkExtension.ANCHORLINKS_TEXT_PREFIX, "<span class=\"octicon octicon-link\"></span>")
+
+  Parser parser = Parser.builder(options).build()
+  HtmlRenderer renderer = HtmlRenderer.builder(options).build()
+
+  mdFiles.each { mdFile ->
+    // add table of contents
+    def mdText = "[TOC]\n"+mdFile.text
+
+    // grab the first top-level title
+    def title = null
+    def titleRegex = /(?m)^#(\s+|([^#]))(.*)/
+    def matcher = mdText =~ titleRegex
+    if (matcher.size() > 0) {
+      // matcher[0][2] is the first character of the title if there wasn't any whitespace after the #
+      title = (matcher[0][2] != null ? matcher[0][2] : "")+matcher[0][3]
+    }
+    // or use the filename if none found
+    if (title == null) {
+      title = mdFile.getName()
+    }
 
-task cleanBuildingHTML(type: Delete) {
-  doFirst {
-    delete buildingHTML
+    Node document = parser.parse(mdText)
+    String htmlBody = renderer.render(document)
+    def htmlText = '''<html>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta http-equiv="Content-Style-Type" content="text/css" />
+    <meta name="generator" content="flexmark" />
+'''
+    htmlText += ((title != null) ? "  <title>${title}</title>" : '' )
+    htmlText += '''
+    <style type="text/css">code{white-space: pre;}</style>
+'''
+    htmlText += ((cssFile != null) ? cssFile.text : '')
+    htmlText += '''</head>
+  <body>
+'''
+    htmlText += htmlBody
+    htmlText += '''
+  </body>
+</html>
+'''
+
+    def htmlFilePath = mdFile.getPath().replaceAll(/\..*?$/, ".html")
+    def htmlFile = file(htmlFilePath)
+    println("Creating ${htmlFilePath}")
+    htmlFile.text = htmlText
   }
 }
 
 
-task convertBuildingMD(type: Exec) {
-  dependsOn cleanBuildingHTML
-  def buildingMD = "${jalviewDir}/${doc_dir}/building.md"
-  def css = "${jalviewDir}/${doc_dir}/github.css"
-
-  def pandoc = null
-  pandoc_exec.split(",").each {
-    if (file(it.trim()).exists()) {
-      pandoc = it.trim()
-      return true
-    }
-  }
-
-  def hostname = "hostname".execute().text.trim()
-  def buildtoolsPandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc"
-  if ((pandoc == null || ! file(pandoc).exists()) && file(buildtoolsPandoc).exists()) {
-    pandoc = System.getProperty("user.home")+"/buildtools/pandoc/bin/pandoc"
+task copyDocs(type: Copy) {
+  def inputDir = "${jalviewDir}/${doc_dir}"
+  def outputDir = "${docBuildDir}/${doc_dir}"
+  from(inputDir) {
+    include('**/*.txt')
+    include('**/*.md')
+    include('**/*.html')
+    include('**/*.xml')
+    filter(ReplaceTokens,
+      beginToken: '$$',
+      endToken: '$$',
+      tokens: [
+        'Version-Rel': JALVIEW_VERSION,
+        'Year-Rel': getDate("yyyy")
+      ]
+    )
   }
-
-  doFirst {
-    if (pandoc != null && file(pandoc).exists()) {
-        commandLine pandoc, '-s', '-o', buildingHTML, '--metadata', 'pagetitle="Building Jalview from Source"', '--toc', '-H', css, buildingMD
-    } else {
-        println("Cannot find pandoc. Skipping convert building.md to HTML")
-        throw new StopExecutionException("Cannot find pandoc. Skipping convert building.md to HTML")
-    }
+  from(inputDir) {
+    exclude('**/*.txt')
+    exclude('**/*.md')
+    exclude('**/*.html')
+    exclude('**/*.xml')
   }
+  into outputDir
 
-  ignoreExitValue true
-
-  inputs.file(buildingMD)
-  inputs.file(css)
-  outputs.file(buildingHTML)
+  inputs.dir(inputDir)
+  outputs.dir(outputDir)
 }
 
 
-clean {
-  doFirst {
-    delete buildingHTML
-  }
-}
+task convertMdFiles {
+  dependsOn copyDocs
+  def mdFiles = fileTree(dir: docBuildDir, include: "**/*.md")
+  def cssFile = file("${jalviewDir}/${flexmark_css}")
 
+  doLast {
+    convertMdToHtml(mdFiles, cssFile)
+  }
 
-task syncDocs(type: Sync) {
-  dependsOn convertBuildingMD
-  def syncDir = "${resourceClassesDir}/${doc_dir}"
-  from fileTree("${jalviewDir}/${doc_dir}")
-  into syncDir
+  inputs.files(mdFiles)
+  inputs.file(cssFile)
 
+  def htmlFiles = []
+  mdFiles.each { mdFile ->
+    def htmlFilePath = mdFile.getPath().replaceAll(/\..*?$/, ".html")
+    htmlFiles.add(file(htmlFilePath))
+  }
+  outputs.files(htmlFiles)
 }
 
 
 task copyHelp(type: Copy) {
   def inputDir = helpSourceDir
-  def outputDir = "${resourceClassesDir}/${help_dir}"
+  def outputDir = "${helpBuildDir}/${help_dir}"
   from(inputDir) {
-    exclude '**/*.gif'
-    exclude '**/*.jpg'
-    exclude '**/*.png'
+    include('**/*.txt')
+    include('**/*.md')
+    include('**/*.html')
+    include('**/*.hs')
+    include('**/*.xml')
+    include('**/*.jhm')
     filter(ReplaceTokens,
       beginToken: '$$',
       endToken: '$$',
@@ -1012,9 +1172,12 @@ task copyHelp(type: Copy) {
     )
   }
   from(inputDir) {
-    include '**/*.gif'
-    include '**/*.jpg'
-    include '**/*.png'
+    exclude('**/*.txt')
+    exclude('**/*.md')
+    exclude('**/*.html')
+    exclude('**/*.hs')
+    exclude('**/*.xml')
+    exclude('**/*.jhm')
   }
   into outputDir
 
@@ -1024,39 +1187,113 @@ task copyHelp(type: Copy) {
 }
 
 
-task syncLib(type: Sync) {
-  def syncDir = "${resourceClassesDir}/${libDistDir}"
-  from fileTree("${jalviewDir}/${libDistDir}")
-  into syncDir
+task copyResources(type: Copy) {
+  group = "build"
+  description = "Copy (and make text substitutions in) the resources dir to the build area"
+
+  def inputDir = resourceDir
+  def outputDir = resourcesBuildDir
+  from(inputDir) {
+    include('**/*.txt')
+    include('**/*.md')
+    include('**/*.html')
+    include('**/*.xml')
+    filter(ReplaceTokens,
+      beginToken: '$$',
+      endToken: '$$',
+      tokens: [
+        'Version-Rel': JALVIEW_VERSION,
+        'Year-Rel': getDate("yyyy")
+      ]
+    )
+  }
+  from(inputDir) {
+    exclude('**/*.txt')
+    exclude('**/*.md')
+    exclude('**/*.html')
+    exclude('**/*.xml')
+  }
+  into outputDir
+
+  inputs.dir(inputDir)
+  outputs.dir(outputDir)
 }
 
+task copyChannelResources(type: Copy) {
+  dependsOn copyResources
+  group = "build"
+  description = "Copy the channel resources dir to the build resources area"
 
-task syncResources(type: Sync) {
-  from resourceDir
-  include "**/*.*"
-  into "${resourceClassesDir}"
-  preserve {
-    include "**"
-  }
+  def inputDir = "${channelDir}/${resource_dir}"
+  def outputDir = resourcesBuildDir
+  from inputDir
+  into outputDir
+
+  inputs.dir(inputDir)
+  outputs.dir(outputDir)
+}
+
+task createBuildProperties(type: WriteProperties) {
+  dependsOn copyResources
+  group = "build"
+  description = "Create the ${buildProperties} file"
+  
+  inputs.dir(sourceDir)
+  inputs.dir(resourcesBuildDir)
+  outputFile (buildProperties)
+  // taking time specific comment out to allow better incremental builds
+  comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd HH:mm:ss")
+  //comment "--Jalview Build Details--\n"+getDate("yyyy-MM-dd")
+  property "BUILD_DATE", getDate("HH:mm:ss dd MMMM yyyy")
+  property "VERSION", JALVIEW_VERSION
+  property "INSTALLATION", INSTALLATION+" git-commit:"+gitHash+" ["+gitBranch+"]"
+  outputs.file(outputFile)
 }
 
 
+task buildIndices(type: JavaExec) {
+  dependsOn copyHelp
+  classpath = sourceSets.main.compileClasspath
+  main = "com.sun.java.help.search.Indexer"
+  workingDir = "${helpBuildDir}/${help_dir}"
+  def argDir = "html"
+  args = [ argDir ]
+  inputs.dir("${workingDir}/${argDir}")
+
+  outputs.dir("${classesDir}/doc")
+  outputs.dir("${classesDir}/help")
+  outputs.file("${workingDir}/JavaHelpSearch/DOCS")
+  outputs.file("${workingDir}/JavaHelpSearch/DOCS.TAB")
+  outputs.file("${workingDir}/JavaHelpSearch/OFFSETS")
+  outputs.file("${workingDir}/JavaHelpSearch/POSITIONS")
+  outputs.file("${workingDir}/JavaHelpSearch/SCHEMA")
+  outputs.file("${workingDir}/JavaHelpSearch/TMAP")
+}
+
 task prepare {
-  dependsOn syncResources
-  dependsOn syncDocs
+  dependsOn copyResources
+  dependsOn copyDocs
   dependsOn copyHelp
+  dependsOn createBuildProperties
+  dependsOn copyChannelResources
+  dependsOn convertMdFiles
+  dependsOn buildIndices
 }
 
 
+compileJava.dependsOn prepare
+run.dependsOn compileJava
+//run.dependsOn prepare
+
+
 //testReportDirName = "test-reports" // note that test workingDir will be $jalviewDir
 test {
   dependsOn prepare
-  //dependsOn compileJava ////? DELETE
 
   if (useClover) {
     dependsOn cloverClasses
    } else { //?
-     dependsOn compileJava //?
+    dependsOn compileJava //?
   }
 
   useTestNG() {
@@ -1069,39 +1306,28 @@ test {
   maxHeapSize = "1024m"
 
   workingDir = jalviewDir
-  //systemProperties 'clover.jar' System.properties.clover.jar
+  def testLaf = project.findProperty("test_laf")
+  if (testLaf != null) {
+    println("Setting Test LaF to '${testLaf}'")
+    systemProperty "laf", testLaf
+  }
+  def testHiDPIScale = project.findProperty("test_HiDPIScale")
+  if (testHiDPIScale != null) {
+    println("Setting Test HiDPI Scale to '${testHiDPIScale}'")
+    systemProperty "sun.java2d.uiScale", testHiDPIScale
+  }
   sourceCompatibility = compile_source_compatibility
   targetCompatibility = compile_target_compatibility
   jvmArgs += additional_compiler_args
 
   doFirst {
     if (useClover) {
-      print("Running tests " + (useClover?"WITH":"WITHOUT") + " clover [clover="+useClover+"]\n")
+      println("Running tests " + (useClover?"WITH":"WITHOUT") + " clover")
     }
   }
 }
 
 
-task buildIndices(type: JavaExec) {
-  dependsOn copyHelp
-  classpath = sourceSets.main.compileClasspath
-  main = "com.sun.java.help.search.Indexer"
-  workingDir = "${classesDir}/${help_dir}"
-  def argDir = "html"
-  args = [ argDir ]
-  inputs.dir("${workingDir}/${argDir}")
-
-  outputs.dir("${classesDir}/doc")
-  outputs.dir("${classesDir}/help")
-  outputs.file("${workingDir}/JavaHelpSearch/DOCS")
-  outputs.file("${workingDir}/JavaHelpSearch/DOCS.TAB")
-  outputs.file("${workingDir}/JavaHelpSearch/OFFSETS")
-  outputs.file("${workingDir}/JavaHelpSearch/POSITIONS")
-  outputs.file("${workingDir}/JavaHelpSearch/SCHEMA")
-  outputs.file("${workingDir}/JavaHelpSearch/TMAP")
-}
-
-
 task compileLinkCheck(type: JavaCompile) {
   options.fork = true
   classpath = files("${jalviewDir}/${utils_dir}")
@@ -1116,13 +1342,14 @@ task compileLinkCheck(type: JavaCompile) {
 
 
 task linkCheck(type: JavaExec) {
-  dependsOn prepare, compileLinkCheck
+  dependsOn prepare
+  dependsOn compileLinkCheck
 
   def helpLinksCheckerOutFile = file("${jalviewDir}/${utils_dir}/HelpLinksChecker.out")
   classpath = files("${jalviewDir}/${utils_dir}")
   main = "HelpLinksChecker"
   workingDir = jalviewDir
-  args = [ "${classesDir}/${help_dir}", "-nointernet" ]
+  args = [ "${helpBuildDir}/${help_dir}", "-nointernet" ]
 
   def outFOS = new FileOutputStream(helpLinksCheckerOutFile, false) // false == don't append
   def errFOS = outFOS
@@ -1133,13 +1360,14 @@ task linkCheck(type: JavaExec) {
     outFOS,
     errorOutput)
 
-  inputs.dir("${classesDir}/${help_dir}")
+  inputs.dir(helpBuildDir)
   outputs.file(helpLinksCheckerOutFile)
 }
 
+
 // import the pubhtmlhelp target
 ant.properties.basedir = "${jalviewDir}"
-ant.properties.helpBuildDir = "${jalviewDirAbsolutePath}/${classes_dir}/${help_dir}"
+ant.properties.helpBuildDir = "${helpBuildDir}/${help_dir}"
 ant.importBuild "${utils_dir}/publishHelp.xml"
 
 
@@ -1149,20 +1377,22 @@ task cleanPackageDir(type: Delete) {
   }
 }
 
+
 jar {
+  dependsOn prepare
   dependsOn linkCheck
-  dependsOn buildIndices
-  dependsOn createBuildProperties
 
   manifest {
     attributes "Main-Class": main_class,
     "Permissions": "all-permissions",
-    "Application-Name": "Jalview Desktop",
-    "Codebase": application_codebase
+    "Application-Name": install4jApplicationName,
+    "Codebase": application_codebase,
+    "Implementation-Version": JALVIEW_VERSION
   }
 
-  destinationDir = file("${jalviewDir}/${package_dir}")
-  archiveName = rootProject.name+".jar"
+  def outputDir = "${jalviewDir}/${package_dir}"
+  destinationDirectory = file(outputDir)
+  archiveFileName = rootProject.name+".jar"
 
   exclude "cache*/**"
   exclude "*.jar"
@@ -1170,8 +1400,11 @@ jar {
   exclude "**/*.jar"
   exclude "**/*.jar.*"
 
-  inputs.dir(classesDir)
-  outputs.file("${jalviewDir}/${package_dir}/${archiveName}")
+  inputs.dir(sourceSets.main.java.outputDir)
+  sourceSets.main.resources.srcDirs.each{ dir ->
+    inputs.dir(dir)
+  }
+  outputs.file("${outputDir}/${archiveFileName}")
 }
 
 
@@ -1183,10 +1416,11 @@ task copyJars(type: Copy) {
 
 // doing a Sync instead of Copy as Copy doesn't deal with "outputs" very well
 task syncJars(type: Sync) {
+  dependsOn jar
   from fileTree(dir: "${jalviewDir}/${libDistDir}", include: "**/*.jar").files
   into "${jalviewDir}/${package_dir}"
   preserve {
-    include jar.archiveName
+    include jar.archiveFileName.getOrNull()
   }
 }
 
@@ -1210,8 +1444,10 @@ task cleanDist {
   dependsOn clean
 }
 
+
 shadowJar {
   group = "distribution"
+  description = "Create a single jar file with all dependency libraries merged. Can be run with java -jar"
   if (buildDist) {
     dependsOn makeDist
   }
@@ -1219,7 +1455,8 @@ shadowJar {
     include("*.jar")
   }
   manifest {
-    attributes 'Implementation-Version': JALVIEW_VERSION
+    attributes "Implementation-Version": JALVIEW_VERSION,
+    "Application-Name": install4jApplicationName
   }
   mainClassName = shadow_jar_main_class
   mergeServiceFiles()
@@ -1263,6 +1500,14 @@ task getdownWebsite() {
     if (getdownAltMultiJavaLocation != null && getdownAltMultiJavaLocation.length() > 0) {
       props.put("getdown_txt_multi_java_location", getdownAltMultiJavaLocation)
     }
+    if (getdownImagesDir != null && file(getdownImagesDir).exists()) {
+      props.put("getdown_txt_ui.background_image", "${getdownImagesDir}/${getdown_background_image}")
+      props.put("getdown_txt_ui.instant_background_image", "${getdownImagesDir}/${getdown_instant_background_image}")
+      props.put("getdown_txt_ui.error_background", "${getdownImagesDir}/${getdown_error_background}")
+      props.put("getdown_txt_ui.progress_image", "${getdownImagesDir}/${getdown_progress_image}")
+      props.put("getdown_txt_ui.icon", "${getdownImagesDir}/${getdown_icon}")
+      props.put("getdown_txt_ui.mac_dock_icon", "${getdownImagesDir}/${getdown_mac_dock_icon}")
+    }
 
     props.put("getdown_txt_title", jalview_name)
     props.put("getdown_txt_ui.name", install4jApplicationName)
@@ -1350,7 +1595,7 @@ task getdownWebsite() {
     // getdown-launcher.jar should not be in main application class path so the main application can move it when updated.  Listed as a resource so it gets updated.
     //getdownTextString += "class = " + file(getdownLauncher).getName() + "\n"
     getdownTextString += "resource = ${getdown_launcher_new}\n"
-    getdownTextString += "class = ${mainClass}\n"
+    getdownTextString += "class = ${main_class}\n"
 
     def getdown_txt = file("${getdownWebsiteDir}/getdown.txt")
     getdown_txt.write(getdownTextString)
@@ -1470,6 +1715,11 @@ task getdown() {
 }
 
 
+tasks.withType(JavaCompile) {
+	options.encoding = 'UTF-8'
+}
+
+
 clean {
   doFirst {
     delete getdownWebsiteDir
@@ -1582,7 +1832,6 @@ clean {
 task installers(type: com.install4j.gradle.Install4jTask) {
   group = "distribution"
   description = "Create the install4j installers"
-  dependsOn setGitVals
   dependsOn getdown
   dependsOn copyInstall4jTemplate
 
@@ -1626,7 +1875,7 @@ task installers(type: com.install4j.gradle.Install4jTask) {
     'BUNDLE_ID': install4jBundleId,
     'INTERNAL_ID': install4jInternalId,
     'WINDOWS_APPLICATION_ID': install4jWinApplicationId,
-    'MACOS_DS_STORE': install4jDSStore,
+    'MACOS_DMG_DS_STORE': install4jDMGDSStore,
     'MACOS_DMG_BG_IMAGE': install4jDMGBackgroundImage,
     'INSTALLER_NAME': install4jInstallerName,
     'INSTALL4J_UTILS_DIR': install4j_utils_dir,
@@ -1643,6 +1892,11 @@ task installers(type: com.install4j.gradle.Install4jTask) {
     'UNIX_APPLICATION_FOLDER': install4jUnixApplicationFolder,
     'EXECUTABLE_NAME': install4jExecutableName,
     'EXTRA_SCHEME': install4jExtraScheme,
+    'MAC_ICONS_FILE': install4jMacIconsFile,
+    'WINDOWS_ICONS_FILE': install4jWindowsIconsFile,
+    'PNG_ICON_FILE': install4jPngIconFile,
+    'BACKGROUND': install4jBackground,
+
   ]
 
   //println("INSTALL4J VARIABLES:")
@@ -1673,16 +1927,22 @@ task installers(type: com.install4j.gradle.Install4jTask) {
 }
 
 
+spotless {
+  java {
+    eclipse().configFile(eclipse_codestyle_file)
+  }
+}
+
+
 task sourceDist(type: Tar) {
+  group "distribution"
+  description "Create a source .tar.gz file for distribution"
   
+  dependsOn convertMdFiles
+
   def VERSION_UNDERSCORES = JALVIEW_VERSION.replaceAll("\\.", "_")
   def outputFileName = "${project.name}_${VERSION_UNDERSCORES}.tar.gz"
-  // cater for buildship < 3.1 [3.0.1 is max version in eclipse 2018-09]
-  try {
-    archiveFileName = outputFileName
-  } catch (Exception e) {
-    archiveName = outputFileName
-  }
+  archiveFileName = outputFileName
   
   compression Compression.GZIP
   
@@ -1754,7 +2014,7 @@ task sourceDist(type: Tar) {
     exclude (getdown_website_dir)
 
     // exluding these as not using jars as modules yet
-    exclude ("$j11modDir/**/*.jar")
+    exclude ("${j11modDir}/**/*.jar")
   }
   from(jalviewDir) {
     include(INCLUDE_FILES)
@@ -1772,10 +2032,1041 @@ task helppages {
   dependsOn copyHelp
   dependsOn pubhtmlhelp
   
-  inputs.dir("${classesDir}/${help_dir}")
+  inputs.dir("${helpBuildDir}/${help_dir}")
   outputs.dir("${buildDir}/distributions/${help_dir}")
 }
 
-// LARGE AMOUNT OF JALVIEWJS STUFF DELETED HERE
-task eclipseAutoBuildTask {}
-task eclipseSynchronizationTask {}
+
+task j2sSetHeadlessBuild {
+  doFirst {
+    IN_ECLIPSE = false
+  }
+}
+
+
+task jalviewjsSetEclipseWorkspace {
+  def propKey = "jalviewjs_eclipse_workspace"
+  def propVal = null
+  if (project.hasProperty(propKey)) {
+    propVal = project.getProperty(propKey)
+    if (propVal.startsWith("~/")) {
+      propVal = System.getProperty("user.home") + propVal.substring(1)
+    }
+  }
+  def propsFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_workspace_location_file}"
+  def propsFile = file(propsFileName)
+  def eclipseWsDir = propVal
+  def props = new Properties()
+
+  def writeProps = true
+  if (( eclipseWsDir == null || !file(eclipseWsDir).exists() ) && propsFile.exists()) {
+    def ins = new FileInputStream(propsFileName)
+    props.load(ins)
+    ins.close()
+    if (props.getProperty(propKey, null) != null) {
+      eclipseWsDir = props.getProperty(propKey)
+      writeProps = false
+    }
+  }
+
+  if (eclipseWsDir == null || !file(eclipseWsDir).exists()) {
+    def tempDir = File.createTempDir()
+    eclipseWsDir = tempDir.getAbsolutePath()
+    writeProps = true
+  }
+  eclipseWorkspace = file(eclipseWsDir)
+
+  doFirst {
+    // do not run a headless transpile when we claim to be in Eclipse
+    if (IN_ECLIPSE) {
+      println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+      throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
+    } else {
+      println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+    }
+
+    if (writeProps) {
+      props.setProperty(propKey, eclipseWsDir)
+      propsFile.parentFile.mkdirs()
+      def bytes = new ByteArrayOutputStream()
+      props.store(bytes, null)
+      def propertiesString = bytes.toString()
+      propsFile.text = propertiesString
+      print("NEW ")
+    } else {
+      print("EXISTING ")
+    }
+
+    println("ECLIPSE WORKSPACE: "+eclipseWorkspace.getPath())
+  }
+
+  //inputs.property(propKey, eclipseWsDir) // eclipseWsDir only gets set once this task runs, so will be out-of-date
+  outputs.file(propsFileName)
+  outputs.upToDateWhen { eclipseWorkspace.exists() && propsFile.exists() }
+}
+
+
+task jalviewjsEclipsePaths {
+  def eclipseProduct
+
+  def eclipseRoot = jalviewjs_eclipse_root
+  if (eclipseRoot.startsWith("~/")) {
+    eclipseRoot = System.getProperty("user.home") + eclipseRoot.substring(1)
+  }
+  if (OperatingSystem.current().isMacOsX()) {
+    eclipseRoot += "/Eclipse.app"
+    eclipseBinary = "${eclipseRoot}/Contents/MacOS/eclipse"
+    eclipseProduct = "${eclipseRoot}/Contents/Eclipse/.eclipseproduct"
+  } else if (OperatingSystem.current().isWindows()) { // check these paths!!
+    if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
+      eclipseRoot += "/eclipse"
+    }
+    eclipseBinary = "${eclipseRoot}/eclipse.exe"
+    eclipseProduct = "${eclipseRoot}/.eclipseproduct"
+  } else { // linux or unix
+    if (file("${eclipseRoot}/eclipse").isDirectory() && file("${eclipseRoot}/eclipse/.eclipseproduct").exists()) {
+      eclipseRoot += "/eclipse"
+println("eclipseDir exists")
+    }
+    eclipseBinary = "${eclipseRoot}/eclipse"
+    eclipseProduct = "${eclipseRoot}/.eclipseproduct"
+  }
+
+  eclipseVersion = "4.13" // default
+  def assumedVersion = true
+  if (file(eclipseProduct).exists()) {
+    def fis = new FileInputStream(eclipseProduct)
+    def props = new Properties()
+    props.load(fis)
+    eclipseVersion = props.getProperty("version")
+    fis.close()
+    assumedVersion = false
+  }
+  
+  def propKey = "eclipse_debug"
+  eclipseDebug = (project.hasProperty(propKey) && project.getProperty(propKey).equals("true"))
+
+  doFirst {
+    // do not run a headless transpile when we claim to be in Eclipse
+    if (IN_ECLIPSE) {
+      println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+      throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
+    } else {
+      println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+    }
+
+    if (!assumedVersion) {
+      println("ECLIPSE VERSION=${eclipseVersion}")
+    }
+  }
+}
+
+
+task printProperties {
+  group "Debug"
+  description "Output to console all System.properties"
+  doFirst {
+    System.properties.each { key, val -> System.out.println("Property: ${key}=${val}") }
+  }
+}
+
+
+task eclipseSetup {
+  dependsOn eclipseProject
+  dependsOn eclipseClasspath
+  dependsOn eclipseJdt
+}
+
+
+// this version (type: Copy) will delete anything in the eclipse dropins folder that isn't in fromDropinsDir
+task jalviewjsEclipseCopyDropins(type: Copy) {
+  dependsOn jalviewjsEclipsePaths
+
+  def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_eclipse_dropins_dir}", include: "*.jar")
+  inputFiles += file("${jalviewDir}/${jalviewjsJ2sPlugin}")
+  def outputDir = "${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}"
+
+  from inputFiles
+  into outputDir
+}
+
+
+// this eclipse -clean doesn't actually work
+task jalviewjsCleanEclipse(type: Exec) {
+  dependsOn eclipseSetup
+  dependsOn jalviewjsEclipsePaths
+  dependsOn jalviewjsEclipseCopyDropins
+
+  executable(eclipseBinary)
+  args(["-nosplash", "--launcher.suppressErrors", "-data", eclipseWorkspace.getPath(), "-clean", "-console", "-consoleLog"])
+  if (eclipseDebug) {
+    args += "-debug"
+  }
+  args += "-l"
+
+  def inputString = """exit
+y
+"""
+  def inputByteStream = new ByteArrayInputStream(inputString.getBytes())
+  standardInput = inputByteStream
+}
+
+/* not really working yet
+jalviewjsEclipseCopyDropins.finalizedBy jalviewjsCleanEclipse
+*/
+
+
+task jalviewjsTransferUnzipSwingJs {
+  def file_zip = "${jalviewDir}/${jalviewjs_swingjs_zip}"
+
+  doLast {
+    copy {
+      from zipTree(file_zip)
+      into "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
+    }
+  }
+
+  inputs.file file_zip
+  outputs.dir "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
+}
+
+
+task jalviewjsTransferUnzipLib {
+  def zipFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_libjs_dir}", include: "*.zip")
+
+  doLast {
+    zipFiles.each { file_zip -> 
+      copy {
+        from zipTree(file_zip)
+        into "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
+      }
+    }
+  }
+
+  inputs.files zipFiles
+  outputs.dir "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
+}
+
+
+task jalviewjsTransferUnzipAllLibs {
+  dependsOn jalviewjsTransferUnzipSwingJs
+  dependsOn jalviewjsTransferUnzipLib
+}
+
+
+task jalviewjsCreateJ2sSettings(type: WriteProperties) {
+  group "JalviewJS"
+  description "Create the .j2s file from the j2s.* properties"
+
+  jalviewjsJ2sProps = project.properties.findAll { it.key.startsWith("j2s.") }.sort { it.key }
+  def siteDirProperty = "j2s.site.directory"
+  def setSiteDir = false
+  jalviewjsJ2sProps.each { prop, val ->
+    if (val != null) {
+      if (prop == siteDirProperty) {
+        if (!(val.startsWith('/') || val.startsWith("file://") )) {
+          val = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${val}"
+        }
+        setSiteDir = true
+      }
+      property(prop,val)
+    }
+    if (!setSiteDir) { // default site location, don't override specifically set property
+      property(siteDirProperty,"${jalviewDirRelativePath}/${jalviewjsTransferSiteJsDir}")
+    }
+  }
+  outputFile = jalviewjsJ2sSettingsFileName
+
+  if (! IN_ECLIPSE) {
+    inputs.properties(jalviewjsJ2sProps)
+    outputs.file(jalviewjsJ2sSettingsFileName)
+  }
+}
+
+
+task jalviewjsEclipseSetup {
+  dependsOn jalviewjsEclipseCopyDropins
+  dependsOn jalviewjsSetEclipseWorkspace
+  dependsOn jalviewjsCreateJ2sSettings
+}
+
+
+task jalviewjsSyncAllLibs (type: Sync) {
+  dependsOn jalviewjsTransferUnzipAllLibs
+  def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteLibDir}")
+  inputFiles += fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}")
+  def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
+
+  from inputFiles
+  into outputDir
+  def outputFiles = []
+  rename { filename ->
+    outputFiles += "${outputDir}/${filename}"
+    null
+  }
+  preserve {
+    include "**"
+  }
+  outputs.files outputFiles
+  inputs.files inputFiles
+}
+
+
+task jalviewjsSyncResources (type: Sync) {
+  def inputFiles = fileTree(dir: resourceDir)
+  def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
+
+  from inputFiles
+  into outputDir
+  def outputFiles = []
+  rename { filename ->
+    outputFiles += "${outputDir}/${filename}"
+    null
+  }
+  preserve {
+    include "**"
+  }
+  outputs.files outputFiles
+  inputs.files inputFiles
+}
+
+
+task jalviewjsSyncSiteResources (type: Sync) {
+  def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjs_site_resource_dir}")
+  def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
+
+  from inputFiles
+  into outputDir
+  def outputFiles = []
+  rename { filename ->
+    outputFiles += "${outputDir}/${filename}"
+    null
+  }
+  preserve {
+    include "**"
+  }
+  outputs.files outputFiles
+  inputs.files inputFiles
+}
+
+
+task jalviewjsSyncBuildProperties (type: Sync) {
+  dependsOn createBuildProperties
+  def inputFiles = [file(buildProperties)]
+  def outputDir = "${jalviewDir}/${jalviewjsSiteDir}/${jalviewjs_j2s_subdir}"
+
+  from inputFiles
+  into outputDir
+  def outputFiles = []
+  rename { filename ->
+    outputFiles += "${outputDir}/${filename}"
+    null
+  }
+  preserve {
+    include "**"
+  }
+  outputs.files outputFiles
+  inputs.files inputFiles
+}
+
+
+task jalviewjsProjectImport(type: Exec) {
+  dependsOn eclipseSetup
+  dependsOn jalviewjsEclipsePaths
+  dependsOn jalviewjsEclipseSetup
+
+  doFirst {
+    // do not run a headless import when we claim to be in Eclipse
+    if (IN_ECLIPSE) {
+      println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+      throw new StopExecutionException("Not running headless import whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
+    } else {
+      println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+    }
+  }
+
+  //def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview/org.eclipse.jdt.core"
+  def projdir = eclipseWorkspace.getPath()+"/.metadata/.plugins/org.eclipse.core.resources/.projects/jalview"
+  executable(eclipseBinary)
+  args(["-nosplash", "--launcher.suppressErrors", "-application", "com.seeq.eclipse.importprojects.headlessimport", "-data", eclipseWorkspace.getPath(), "-import", jalviewDirAbsolutePath])
+  if (eclipseDebug) {
+    args += "-debug"
+  }
+  args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
+  if (!IN_ECLIPSE) {
+    args += [ "-D${j2sHeadlessBuildProperty}=true" ]
+  }
+
+  inputs.file("${jalviewDir}/.project")
+  outputs.upToDateWhen { 
+    file(projdir).exists()
+  }
+}
+
+
+task jalviewjsTranspile(type: Exec) {
+  dependsOn jalviewjsEclipseSetup 
+  dependsOn jalviewjsProjectImport
+  dependsOn jalviewjsEclipsePaths
+
+  doFirst {
+    // do not run a headless transpile when we claim to be in Eclipse
+    if (IN_ECLIPSE) {
+      println("Skipping task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+      throw new StopExecutionException("Not running headless transpile whilst IN_ECLIPSE is '${IN_ECLIPSE}'")
+    } else {
+      println("Running task ${name} as IN_ECLIPSE=${IN_ECLIPSE}")
+    }
+  }
+
+  executable(eclipseBinary)
+  args(["-nosplash", "--launcher.suppressErrors", "-application", "org.eclipse.jdt.apt.core.aptBuild", "-data", eclipseWorkspace, "-${jalviewjs_eclipse_build_arg}", eclipse_project_name ])
+  if (eclipseDebug) {
+    args += "-debug"
+  }
+  args += [ "--launcher.appendVmargs", "-vmargs", "-Dorg.eclipse.equinox.p2.reconciler.dropins.directory=${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_eclipse_tmp_dropins_dir}" ]
+  if (!IN_ECLIPSE) {
+    args += [ "-D${j2sHeadlessBuildProperty}=true" ]
+  }
+
+  def stdout
+  def stderr
+  doFirst {
+    stdout = new ByteArrayOutputStream()
+    stderr = new ByteArrayOutputStream()
+
+    def logOutFileName = "${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}"
+    def logOutFile = file(logOutFileName)
+    logOutFile.createNewFile()
+    logOutFile.text = """ROOT: ${jalviewjs_eclipse_root}
+BINARY: ${eclipseBinary}
+VERSION: ${eclipseVersion}
+WORKSPACE: ${eclipseWorkspace}
+DEBUG: ${eclipseDebug}
+----
+"""
+    def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
+    // combine stdout and stderr
+    def logErrFOS = logOutFOS
+
+    if (jalviewjs_j2s_to_console.equals("true")) {
+      standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
+        new org.apache.tools.ant.util.TeeOutputStream(
+          logOutFOS,
+          stdout),
+        standardOutput)
+      errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
+        new org.apache.tools.ant.util.TeeOutputStream(
+          logErrFOS,
+          stderr),
+        errorOutput)
+    } else {
+      standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
+        logOutFOS,
+        stdout)
+      errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
+        logErrFOS,
+        stderr)
+    }
+  }
+
+  doLast {
+    if (stdout.toString().contains("Error processing ")) {
+      // j2s did not complete transpile
+      //throw new TaskExecutionException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
+      if (jalviewjs_ignore_transpile_errors.equals("true")) {
+        println("IGNORING TRANSPILE ERRORS")
+        println("See eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
+      } else {
+        throw new GradleException("Error during transpilation:\n${stderr}\nSee eclipse transpile log file '${jalviewDir}/${jalviewjsBuildDir}/${jalviewjs_j2s_transpile_stdout}'")
+      }
+    }
+  }
+
+  inputs.dir("${jalviewDir}/${sourceDir}")
+  outputs.dir("${jalviewDir}/${jalviewjsTransferSiteJsDir}")
+  outputs.upToDateWhen( { file("${jalviewDir}/${jalviewjsTransferSiteJsDir}${jalviewjs_server_resource}").exists() } )
+}
+
+
+def jalviewjsCallCore(String name, FileCollection list, String prefixFile, String suffixFile, String jsfile, String zjsfile, File logOutFile, Boolean logOutConsole) {
+
+  def stdout = new ByteArrayOutputStream()
+  def stderr = new ByteArrayOutputStream()
+
+  def coreFile = file(jsfile)
+  def msg = ""
+  msg = "Creating core for ${name}...\nGenerating ${jsfile}"
+  println(msg)
+  logOutFile.createNewFile()
+  logOutFile.append(msg+"\n")
+
+  def coreTop = file(prefixFile)
+  def coreBottom = file(suffixFile)
+  coreFile.getParentFile().mkdirs()
+  coreFile.createNewFile()
+  coreFile.write( coreTop.getText("UTF-8") )
+  list.each {
+    f ->
+    if (f.exists()) {
+      def t = f.getText("UTF-8")
+      t.replaceAll("Clazz\\.([^_])","Clazz_${1}")
+      coreFile.append( t )
+    } else {
+      msg = "...file '"+f.getPath()+"' does not exist, skipping"
+      println(msg)
+      logOutFile.append(msg+"\n")
+    }
+  }
+  coreFile.append( coreBottom.getText("UTF-8") )
+
+  msg = "Generating ${zjsfile}"
+  println(msg)
+  logOutFile.append(msg+"\n")
+  def logOutFOS = new FileOutputStream(logOutFile, true) // true == append
+  def logErrFOS = logOutFOS
+
+  javaexec {
+    classpath = files(["${jalviewDir}/${jalviewjs_closure_compiler}"])
+    main = "com.google.javascript.jscomp.CommandLineRunner"
+    jvmArgs = [ "-Dfile.encoding=UTF-8" ]
+    args = [ "--compilation_level", "SIMPLE_OPTIMIZATIONS", "--warning_level", "QUIET", "--charset", "UTF-8", "--js", jsfile, "--js_output_file", zjsfile ]
+    maxHeapSize = "2g"
+
+    msg = "\nRunning '"+commandLine.join(' ')+"'\n"
+    println(msg)
+    logOutFile.append(msg+"\n")
+
+    if (logOutConsole) {
+      standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
+        new org.apache.tools.ant.util.TeeOutputStream(
+          logOutFOS,
+          stdout),
+        standardOutput)
+        errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
+          new org.apache.tools.ant.util.TeeOutputStream(
+            logErrFOS,
+            stderr),
+          errorOutput)
+    } else {
+      standardOutput = new org.apache.tools.ant.util.TeeOutputStream(
+        logOutFOS,
+        stdout)
+        errorOutput = new org.apache.tools.ant.util.TeeOutputStream(
+          logErrFOS,
+          stderr)
+    }
+  }
+  msg = "--"
+  println(msg)
+  logOutFile.append(msg+"\n")
+}
+
+
+task jalviewjsBuildAllCores {
+  group "JalviewJS"
+  description "Build the core js lib closures listed in the classlists dir"
+  dependsOn jalviewjsTranspile
+  dependsOn jalviewjsTransferUnzipSwingJs
+
+  def j2sDir = "${jalviewDir}/${jalviewjsTransferSiteJsDir}/${jalviewjs_j2s_subdir}"
+  def swingJ2sDir = "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}/${jalviewjs_j2s_subdir}"
+  def libJ2sDir = "${jalviewDir}/${jalviewjsTransferSiteLibDir}/${jalviewjs_j2s_subdir}"
+  def jsDir = "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}/${jalviewjs_js_subdir}"
+  def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}/${jalviewjs_j2s_subdir}/core"
+  def prefixFile = "${jsDir}/core/coretop2.js"
+  def suffixFile = "${jsDir}/core/corebottom2.js"
+
+  inputs.file prefixFile
+  inputs.file suffixFile
+
+  def classlistFiles = []
+  // add the classlists found int the jalviewjs_classlists_dir
+  fileTree(dir: "${jalviewDir}/${jalviewjs_classlists_dir}", include: "*.txt").each {
+    file ->
+    def name = file.getName() - ".txt"
+    classlistFiles += [
+      'file': file,
+      'name': name
+    ]
+  }
+
+  // _jmol and _jalview cores. Add any other peculiar classlist.txt files here
+  //classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jmol}"), 'name': "_jvjmol" ]
+  classlistFiles += [ 'file': file("${jalviewDir}/${jalviewjs_classlist_jalview}"), 'name': jalviewjsJalviewCoreName ]
+
+  jalviewjsCoreClasslists = []
+
+  classlistFiles.each {
+    hash ->
+
+    def file = hash['file']
+    if (! file.exists()) {
+      //println("...classlist file '"+file.getPath()+"' does not exist, skipping")
+      return false // this is a "continue" in groovy .each closure
+    }
+    def name = hash['name']
+    if (name == null) {
+      name = file.getName() - ".txt"
+    }
+
+    def filelist = []
+    file.eachLine {
+      line ->
+        filelist += line
+    }
+    def list = fileTree(dir: j2sDir, includes: filelist)
+
+    def jsfile = "${outputDir}/core${name}.js"
+    def zjsfile = "${outputDir}/core${name}.z.js"
+
+    jalviewjsCoreClasslists += [
+      'jsfile': jsfile,
+      'zjsfile': zjsfile,
+      'list': list,
+      'name': name
+    ]
+
+    inputs.file(file)
+    inputs.files(list)
+    outputs.file(jsfile)
+    outputs.file(zjsfile)
+  }
+  
+  // _stevesoft core. add any cores without a classlist here (and the inputs and outputs)
+  def stevesoftClasslistName = "_stevesoft"
+  def stevesoftClasslist = [
+    'jsfile': "${outputDir}/core${stevesoftClasslistName}.js",
+    'zjsfile': "${outputDir}/core${stevesoftClasslistName}.z.js",
+    'list': fileTree(dir: j2sDir, include: "com/stevesoft/pat/**/*.js"),
+    'name': stevesoftClasslistName
+  ]
+  jalviewjsCoreClasslists += stevesoftClasslist
+  inputs.files(stevesoftClasslist['list'])
+  outputs.file(stevesoftClasslist['jsfile'])
+  outputs.file(stevesoftClasslist['zjsfile'])
+
+  // _all core
+  def allClasslistName = "_all"
+  def allJsFiles = fileTree(dir: j2sDir, include: "**/*.js")
+  allJsFiles += fileTree(
+    dir: libJ2sDir,
+    include: "**/*.js",
+    excludes: [
+      // these exlusions are files that the closure-compiler produces errors for. Should fix them
+      "**/org/jmol/jvxl/readers/IsoIntersectFileReader.js",
+      "**/org/jmol/export/JSExporter.js"
+    ]
+  )
+  allJsFiles += fileTree(
+    dir: swingJ2sDir,
+    include: "**/*.js",
+    excludes: [
+      // these exlusions are files that the closure-compiler produces errors for. Should fix them
+      "**/sun/misc/Unsafe.js",
+      "**/swingjs/jquery/jquery-editable-select.js",
+      "**/swingjs/jquery/j2sComboBox.js",
+      "**/sun/misc/FloatingDecimal.js"
+    ]
+  )
+  def allClasslist = [
+    'jsfile': "${outputDir}/core${allClasslistName}.js",
+    'zjsfile': "${outputDir}/core${allClasslistName}.z.js",
+    'list': allJsFiles,
+    'name': allClasslistName
+  ]
+  // not including this version of "all" core at the moment
+  //jalviewjsCoreClasslists += allClasslist
+  inputs.files(allClasslist['list'])
+  outputs.file(allClasslist['jsfile'])
+  outputs.file(allClasslist['zjsfile'])
+
+  doFirst {
+    def logOutFile = file("${jalviewDirAbsolutePath}/${jalviewjsBuildDir}/${jalviewjs_j2s_closure_stdout}")
+    logOutFile.getParentFile().mkdirs()
+    logOutFile.createNewFile()
+    logOutFile.write(getDate("yyyy-MM-dd HH:mm:ss")+" jalviewjsBuildAllCores\n----\n")
+
+    jalviewjsCoreClasslists.each {
+      jalviewjsCallCore(it.name, it.list, prefixFile, suffixFile, it.jsfile, it.zjsfile, logOutFile, jalviewjs_j2s_to_console.equals("true"))
+    }
+  }
+
+}
+
+
+def jalviewjsPublishCoreTemplate(String coreName, String templateName, File inputFile, String outputFile) {
+  copy {
+    from inputFile
+    into file(outputFile).getParentFile()
+    rename { filename ->
+      if (filename.equals(inputFile.getName())) {
+        return file(outputFile).getName()
+      }
+      return null
+    }
+    filter(ReplaceTokens,
+      beginToken: '_',
+      endToken: '_',
+      tokens: [
+        'MAIN': '"'+main_class+'"',
+        'CODE': "null",
+        'NAME': jalviewjsJalviewTemplateName+" [core ${coreName}]",
+        'COREKEY': jalviewjs_core_key,
+        'CORENAME': coreName
+      ]
+    )
+  }
+}
+
+
+task jalviewjsPublishCoreTemplates {
+  dependsOn jalviewjsBuildAllCores
+  def inputFileName = "${jalviewDir}/${j2s_coretemplate_html}"
+  def inputFile = file(inputFileName)
+  def outputDir = "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
+
+  def outputFiles = []
+  jalviewjsCoreClasslists.each { cl ->
+    def outputFile = "${outputDir}/${jalviewjsJalviewTemplateName}_${cl.name}.html"
+    cl['outputfile'] = outputFile
+    outputFiles += outputFile
+  }
+
+  doFirst {
+    jalviewjsCoreClasslists.each { cl ->
+      jalviewjsPublishCoreTemplate(cl.name, jalviewjsJalviewTemplateName, inputFile, cl.outputfile)
+    }
+  }
+  inputs.file(inputFile)
+  outputs.files(outputFiles)
+}
+
+
+task jalviewjsSyncCore (type: Sync) {
+  dependsOn jalviewjsBuildAllCores
+  dependsOn jalviewjsPublishCoreTemplates
+  def inputFiles = fileTree(dir: "${jalviewDir}/${jalviewjsTransferSiteCoreDir}")
+  def outputDir = "${jalviewDir}/${jalviewjsSiteDir}"
+
+  from inputFiles
+  into outputDir
+  def outputFiles = []
+  rename { filename ->
+    outputFiles += "${outputDir}/${filename}"
+    null
+  }
+  preserve {
+    include "**"
+  }
+  outputs.files outputFiles
+  inputs.files inputFiles
+}
+
+
+// this Copy version of TransferSiteJs will delete anything else in the target dir
+task jalviewjsCopyTransferSiteJs(type: Copy) {
+  dependsOn jalviewjsTranspile
+  from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
+  into "${jalviewDir}/${jalviewjsSiteDir}"
+}
+
+
+// this Sync version of TransferSite is used by buildship to keep the website automatically up to date when a file changes
+task jalviewjsSyncTransferSiteJs(type: Sync) {
+  from "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
+  include "**/*.*"
+  into "${jalviewDir}/${jalviewjsSiteDir}"
+  preserve {
+    include "**"
+  }
+}
+
+
+jalviewjsSyncAllLibs.mustRunAfter jalviewjsCopyTransferSiteJs
+jalviewjsSyncResources.mustRunAfter jalviewjsCopyTransferSiteJs
+jalviewjsSyncSiteResources.mustRunAfter jalviewjsCopyTransferSiteJs
+jalviewjsSyncBuildProperties.mustRunAfter jalviewjsCopyTransferSiteJs
+
+jalviewjsSyncAllLibs.mustRunAfter jalviewjsSyncTransferSiteJs
+jalviewjsSyncResources.mustRunAfter jalviewjsSyncTransferSiteJs
+jalviewjsSyncSiteResources.mustRunAfter jalviewjsSyncTransferSiteJs
+jalviewjsSyncBuildProperties.mustRunAfter jalviewjsSyncTransferSiteJs
+
+
+task jalviewjsPrepareSite {
+  group "JalviewJS"
+  description "Prepares the website folder including unzipping files and copying resources"
+  dependsOn jalviewjsSyncAllLibs
+  dependsOn jalviewjsSyncResources
+  dependsOn jalviewjsSyncSiteResources
+  dependsOn jalviewjsSyncBuildProperties
+  dependsOn jalviewjsSyncCore
+}
+
+
+task jalviewjsBuildSite {
+  group "JalviewJS"
+  description "Builds the whole website including transpiled code"
+  dependsOn jalviewjsCopyTransferSiteJs
+  dependsOn jalviewjsPrepareSite
+}
+
+
+task cleanJalviewjsTransferSite {
+  doFirst {
+    delete "${jalviewDir}/${jalviewjsTransferSiteJsDir}"
+    delete "${jalviewDir}/${jalviewjsTransferSiteLibDir}"
+    delete "${jalviewDir}/${jalviewjsTransferSiteSwingJsDir}"
+    delete "${jalviewDir}/${jalviewjsTransferSiteCoreDir}"
+  }
+}
+
+
+task cleanJalviewjsSite {
+  dependsOn cleanJalviewjsTransferSite
+  doFirst {
+    delete "${jalviewDir}/${jalviewjsSiteDir}"
+  }
+}
+
+
+task jalviewjsSiteTar(type: Tar) {
+  group "JalviewJS"
+  description "Creates a tar.gz file for the website"
+  dependsOn jalviewjsBuildSite
+  def outputFilename = "jalviewjs-site-${JALVIEW_VERSION}.tar.gz"
+  archiveFileName = outputFilename
+
+  compression Compression.GZIP
+
+  from "${jalviewDir}/${jalviewjsSiteDir}"
+  into jalviewjs_site_dir // this is inside the tar file
+
+  inputs.dir("${jalviewDir}/${jalviewjsSiteDir}")
+}
+
+
+task jalviewjsServer {
+  group "JalviewJS"
+  def filename = "jalviewjsTest.html"
+  description "Starts a webserver on localhost to test the website. See ${filename} to access local site on most recently used port."
+  def htmlFile = "${jalviewDirAbsolutePath}/${filename}"
+  doLast {
+
+    SimpleHttpFileServerFactory factory = new SimpleHttpFileServerFactory()
+    def port = Integer.valueOf(jalviewjs_server_port)
+    def start = port
+    def running = false
+    def url
+    def jalviewjsServer
+    while(port < start+1000 && !running) {
+      try {
+        def doc_root = new File("${jalviewDirAbsolutePath}/${jalviewjsSiteDir}")
+        jalviewjsServer = factory.start(doc_root, port)
+        running = true
+        url = jalviewjsServer.getResourceUrl(jalviewjs_server_resource)
+        println("SERVER STARTED with document root ${doc_root}.")
+        println("Go to "+url+" . Run  gradle --stop  to stop (kills all gradle daemons).")
+        println("For debug: "+url+"?j2sdebug")
+        println("For verbose: "+url+"?j2sverbose")
+      } catch (Exception e) {
+        port++;
+      }
+    }
+    def htmlText = """
+      <p><a href="${url}">JalviewJS Test. &lt;${url}&gt;</a></p>
+      <p><a href="${url}?j2sdebug">JalviewJS Test with debug. &lt;${url}?j2sdebug&gt;</a></p>
+      <p><a href="${url}?j2sverbose">JalviewJS Test with verbose. &lt;${url}?j2sdebug&gt;</a></p>
+      """
+    jalviewjsCoreClasslists.each { cl ->
+      def urlcore = jalviewjsServer.getResourceUrl(file(cl.outputfile).getName())
+      htmlText += """
+      <p><a href="${urlcore}">${jalviewjsJalviewTemplateName} [core ${cl.name}]. &lt;${urlcore}&gt;</a></p>
+      """
+      println("For core ${cl.name}: "+urlcore)
+    }
+
+    file(htmlFile).text = htmlText
+  }
+
+  outputs.file(htmlFile)
+  outputs.upToDateWhen({false})
+}
+
+
+task cleanJalviewjsAll {
+  group "JalviewJS"
+  description "Delete all configuration and build artifacts to do with JalviewJS build"
+  dependsOn cleanJalviewjsSite
+  dependsOn jalviewjsEclipsePaths
+  
+  doFirst {
+    delete "${jalviewDir}/${jalviewjsBuildDir}"
+    delete "${jalviewDir}/${eclipse_bin_dir}"
+    if (eclipseWorkspace != null && file(eclipseWorkspace.getAbsolutePath()+"/.metadata").exists()) {
+      delete file(eclipseWorkspace.getAbsolutePath()+"/.metadata")
+    }
+    delete "${jalviewDir}/${jalviewjs_j2s_settings}"
+  }
+
+  outputs.upToDateWhen( { false } )
+}
+
+
+task jalviewjsIDE_checkJ2sPlugin {
+  group "00 JalviewJS in Eclipse"
+  description "Compare the swingjs/net.sf.j2s.core(-j11)?.jar file with the Eclipse IDE's plugin version (found in the 'dropins' dir)"
+
+  doFirst {
+    def j2sPlugin = string("${jalviewDir}/${jalviewjsJ2sPlugin}")
+    def j2sPluginFile = file(j2sPlugin)
+    def eclipseHome = System.properties["eclipse.home.location"]
+    if (eclipseHome == null || ! IN_ECLIPSE) {
+      throw new StopExecutionException("Cannot find running Eclipse home from System.properties['eclipse.home.location']. Skipping J2S Plugin Check.")
+    }
+    def eclipseJ2sPluginDirs = [ "${eclipseHome}/dropins" ]
+    def altPluginsDir = System.properties["org.eclipse.equinox.p2.reconciler.dropins.directory"]
+    if (altPluginsDir != null && file(altPluginsDir).exists()) {
+      eclipseJ2sPluginDirs += altPluginsDir
+    }
+    def foundPlugin = false
+    def j2sPluginFileName = j2sPluginFile.getName()
+    def eclipseJ2sPlugin
+    def eclipseJ2sPluginFile
+    eclipseJ2sPluginDirs.any { dir ->
+      eclipseJ2sPlugin = "${dir}/${j2sPluginFileName}"
+      eclipseJ2sPluginFile = file(eclipseJ2sPlugin)
+      if (eclipseJ2sPluginFile.exists()) {
+        foundPlugin = true
+        return true
+      }
+    }
+    if (!foundPlugin) {
+      def msg = "Eclipse J2S Plugin is not installed (could not find '${j2sPluginFileName}' in\n"+eclipseJ2sPluginDirs.join("\n")+"\n)\nTry running task jalviewjsIDE_copyJ2sPlugin"
+      System.err.println(msg)
+      throw new StopExecutionException(msg)
+    }
+
+    def digest = MessageDigest.getInstance("MD5")
+
+    digest.update(j2sPluginFile.text.bytes)
+    def j2sPluginMd5 = new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
+
+    digest.update(eclipseJ2sPluginFile.text.bytes)
+    def eclipseJ2sPluginMd5 = new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
+     
+    if (j2sPluginMd5 != eclipseJ2sPluginMd5) {
+      def msg = "WARNING! Eclipse J2S Plugin '${eclipseJ2sPlugin}' is different to this commit's version '${j2sPlugin}'"
+      System.err.println(msg)
+      throw new StopExecutionException(msg)
+    } else {
+      def msg = "Eclipse J2S Plugin '${eclipseJ2sPlugin}' is the same as '${j2sPlugin}' (this is good)"
+      println(msg)
+    }
+  }
+}
+
+task jalviewjsIDE_copyJ2sPlugin {
+  group "00 JalviewJS in Eclipse"
+  description "Copy the swingjs/net.sf.j2s.core(-j11)?.jar file into the Eclipse IDE's 'dropins' dir"
+
+  doFirst {
+    def j2sPlugin = string("${jalviewDir}/${jalviewjsJ2sPlugin}")
+    def j2sPluginFile = file(j2sPlugin)
+    def eclipseHome = System.properties["eclipse.home.location"]
+    if (eclipseHome == null || ! IN_ECLIPSE) {
+      throw new StopExecutionException("Cannot find running Eclipse home from System.properties['eclipse.home.location']. NOT copying J2S Plugin.")
+    }
+    def eclipseJ2sPlugin = "${eclipseHome}/dropins/${j2sPluginFile.getName()}"
+    def eclipseJ2sPluginFile = file(eclipseJ2sPlugin)
+    def msg = "WARNING! Copying this commit's j2s plugin '${j2sPlugin}' to Eclipse J2S Plugin '${eclipseJ2sPlugin}'\n* May require an Eclipse restart"
+    System.err.println(msg)
+    copy {
+      from j2sPlugin
+      eclipseJ2sPluginFile.getParentFile().mkdirs()
+      into eclipseJ2sPluginFile.getParent()
+    }
+  }
+}
+
+
+task jalviewjsIDE_j2sFile {
+  group "00 JalviewJS in Eclipse"
+  description "Creates the .j2s file"
+  dependsOn jalviewjsCreateJ2sSettings
+}
+
+
+task jalviewjsIDE_SyncCore {
+  group "00 JalviewJS in Eclipse"
+  description "Build the core js lib closures listed in the classlists dir and publish core html from template"
+  dependsOn jalviewjsSyncCore
+}
+
+
+task jalviewjsIDE_SyncSiteAll {
+  dependsOn jalviewjsSyncAllLibs
+  dependsOn jalviewjsSyncResources
+  dependsOn jalviewjsSyncSiteResources
+  dependsOn jalviewjsSyncBuildProperties
+}
+
+
+cleanJalviewjsTransferSite.mustRunAfter jalviewjsIDE_SyncSiteAll
+
+
+task jalviewjsIDE_PrepareSite {
+  group "00 JalviewJS in Eclipse"
+  description "Sync libs and resources to site dir, but not closure cores"
+
+  dependsOn jalviewjsIDE_SyncSiteAll
+  //dependsOn cleanJalviewjsTransferSite // not sure why this clean is here -- will slow down a re-run of this task
+}
+
+
+task jalviewjsIDE_AssembleSite {
+  group "00 JalviewJS in Eclipse"
+  description "Assembles unzipped supporting zipfiles, resources, site resources and closure cores into the Eclipse transpiled site"
+  dependsOn jalviewjsPrepareSite
+}
+
+
+task jalviewjsIDE_SiteClean {
+  group "00 JalviewJS in Eclipse"
+  description "Deletes the Eclipse transpiled site"
+  dependsOn cleanJalviewjsSite
+}
+
+
+task jalviewjsIDE_Server {
+  group "00 JalviewJS in Eclipse"
+  description "Starts a webserver on localhost to test the website"
+  dependsOn jalviewjsServer
+}
+
+
+// buildship runs this at import or gradle refresh
+task eclipseSynchronizationTask {
+  //dependsOn eclipseSetup
+  dependsOn createBuildProperties
+  if (J2S_ENABLED) {
+    dependsOn jalviewjsIDE_j2sFile
+    dependsOn jalviewjsIDE_checkJ2sPlugin
+    dependsOn jalviewjsIDE_PrepareSite
+  }
+}
+
+
+// buildship runs this at build time or project refresh
+task eclipseAutoBuildTask {
+  //dependsOn jalviewjsIDE_checkJ2sPlugin
+  //dependsOn jalviewjsIDE_PrepareSite
+}
+
+
+task jalviewjs {
+  group "JalviewJS"
+  description "Build the site"
+  dependsOn jalviewjsBuildSite
+}