X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2FCommands.java;h=ba72831c4f402de84217a42bdad948a8cfd59c5d;hb=fd86db8856109e69c21a5f4102bc8dd94664ae1f;hp=61ee1be035007f54965f49da9fae084c9348f45a;hpb=09eebd8c6997a33049084e307078717cc1a693a6;p=jalview.git diff --git a/src/jalview/bin/Commands.java b/src/jalview/bin/Commands.java index 61ee1be..ba72831 100644 --- a/src/jalview/bin/Commands.java +++ b/src/jalview/bin/Commands.java @@ -1,6 +1,8 @@ package jalview.bin; import java.io.File; +import java.io.IOException; +import java.net.URISyntaxException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; @@ -11,141 +13,211 @@ import java.util.Locale; import java.util.Map; import jalview.analysis.AlignmentUtils; -import jalview.api.AlignmentViewPanel; -import jalview.bin.ArgParser.Arg; -import jalview.bin.ArgParser.ArgValues; -import jalview.bin.ArgParser.SubVal; -import jalview.datamodel.AlignmentAnnotation; +import jalview.api.structures.JalviewStructureDisplayI; +import jalview.bin.Jalview.ExitCode; +import jalview.bin.argparser.Arg; +import jalview.bin.argparser.ArgParser; +import jalview.bin.argparser.ArgParser.Position; +import jalview.bin.argparser.ArgValue; +import jalview.bin.argparser.ArgValuesMap; +import jalview.bin.argparser.SubVals; import jalview.datamodel.AlignmentI; import jalview.datamodel.SequenceI; import jalview.datamodel.annotations.AlphaFoldAnnotationRowBuilder; import jalview.gui.AlignFrame; import jalview.gui.AlignmentPanel; +import jalview.gui.AppJmol; import jalview.gui.Desktop; +import jalview.gui.Preferences; import jalview.gui.StructureChooser; +import jalview.gui.StructureViewer; +import jalview.gui.StructureViewer.ViewerType; import jalview.io.AppletFormatAdapter; +import jalview.io.BackupFiles; +import jalview.io.BioJsHTMLOutput; import jalview.io.DataSourceType; +import jalview.io.FileFormat; import jalview.io.FileFormatException; import jalview.io.FileFormatI; +import jalview.io.FileFormats; import jalview.io.FileLoader; import jalview.io.HtmlSvgOutput; import jalview.io.IdentifyFile; -import jalview.structure.StructureImportSettings; +import jalview.io.NewickFile; +import jalview.io.exceptions.ImageOutputException; +import jalview.schemes.ColourSchemeI; +import jalview.schemes.ColourSchemeProperty; import jalview.structure.StructureImportSettings.TFType; import jalview.structure.StructureSelectionManager; +import jalview.util.FileUtils; import jalview.util.HttpUtils; +import jalview.util.ImageMaker; +import jalview.util.ImageMaker.TYPE; import jalview.util.MessageManager; import jalview.util.Platform; -import jalview.ws.dbsources.EBIAlfaFold; +import jalview.util.imagemaker.BitmapImageSizing; public class Commands { Desktop desktop; - private static boolean headless; + private boolean headless; - private static ArgParser argParser; + private ArgParser argParser; private Map afMap; - public static boolean processArgs(ArgParser ap, boolean h) + private Map> svMap; + + private boolean commandArgsProvided = false; + + private boolean argsWereParsed = false; + + private List errors = new ArrayList<>(); + + public Commands(ArgParser argparser, boolean headless) + { + this(Desktop.instance, argparser, headless); + } + + public Commands(Desktop d, ArgParser argparser, boolean h) { - argParser = ap; + argParser = argparser; headless = h; - boolean argsWereParsed = false; - if (headless) + desktop = d; + afMap = new HashMap<>(); + } + + protected boolean processArgs() + { + if (argParser == null) { - System.setProperty("java.awt.headless", "true"); + return true; } - if (argParser != null && argParser.linkedIds() != null) + boolean theseArgsWereParsed = false; + + if (argParser != null && argParser.getLinkedIds() != null) { - for (String id : argParser.linkedIds()) + for (String id : argParser.getLinkedIds()) { - Console.debug("##### id=" + id); - Commands cmds = new Commands(); - if (id == null) + ArgValuesMap avm = argParser.getLinkedArgs(id); + theseArgsWereParsed = true; + boolean processLinkedOkay = processLinked(id); + theseArgsWereParsed &= processLinkedOkay; + + processGroovyScript(id); + + // wait around until alignFrame isn't busy + AlignFrame af = afMap.get(id); + while (af != null && af.getViewport().isCalcInProgress()) { - cmds.processUnlinked(id); + try + { + Thread.sleep(25); + } catch (Exception q) + { + } + ; } - else + + theseArgsWereParsed &= processImages(id); + + if (processLinkedOkay) { - cmds.processLinked(id); + theseArgsWereParsed &= processOutput(id); } - cmds.processImages(id); - argsWereParsed |= cmds.wereParsed(); + + // close ap + if (avm.getBoolean(Arg.CLOSE)) + { + af = afMap.get(id); + if (af != null) + { + af.closeMenuItem_actionPerformed(true); + } + } + } } - if (argParser.getBool(Arg.QUIT)) + + // report errors + Console.warn( + "The following errors and warnings occurred whilst processing files:\n" + + errorsToString()); + // gui errors reported in Jalview + + if (argParser.getBoolean(Arg.QUIT)) { - Jalview.getInstance().quit(); + Jalview.getInstance().exit( + "Exiting due to " + Arg.QUIT.argString() + " argument.", + ExitCode.OK); return true; } // carry on with jalview.bin.Jalview + argsWereParsed = theseArgsWereParsed; return argsWereParsed; } - boolean argsWereParsed = false; - - private boolean wereParsed() + public boolean commandArgsProvided() { - return argsWereParsed; + return commandArgsProvided; } - public Commands() + public boolean argsWereParsed() { - this(Desktop.instance); - } - - public Commands(Desktop d) - { - this.desktop = d; - afMap = new HashMap(); + return argsWereParsed; } - protected void processUnlinked(String id) + protected boolean processLinked(String id) { - Map m = argParser.linkedArgs(id); + boolean theseArgsWereParsed = false; + ArgValuesMap avm = argParser.getLinkedArgs(id); + if (avm == null) + { + return true; + } - processLinked(id); - } + Boolean isError = Boolean.valueOf(false); - protected void processLinked(String id) - { - Map m = argParser.linkedArgs(id); + // set wrap scope here so it can be applied after structures are opened + boolean wrap = false; - /* - // script to execute after all loading is completed one way or another - String groovyscript = m.get(Arg.GROOVY) == null ? null - : m.get(Arg.GROOVY).getValue(); - String file = m.get(Arg.OPEN) == null ? null - : m.get(Arg.OPEN).getValue(); - String data = null; - FileFormatI format = null; - DataSourceType protocol = null; - */ - if (ArgParser.getArgValues(m, Arg.OPEN) != null) + if (avm.containsArg(Arg.APPEND) || avm.containsArg(Arg.OPEN)) { + commandArgsProvided = true; long progress = -1; boolean first = true; + boolean progressBarSet = false; AlignFrame af; - for (String openFile : ArgParser.getValues(m, Arg.OPEN)) + // Combine the APPEND and OPEN files into one list, along with whether it + // was APPEND or OPEN + List openAvList = new ArrayList<>(); + openAvList.addAll(avm.getArgValueList(Arg.OPEN)); + openAvList.addAll(avm.getArgValueList(Arg.APPEND)); + // sort avlist based on av.getArgIndex() + Collections.sort(openAvList); + for (ArgValue av : openAvList) { + Arg a = av.getArg(); + SubVals sv = av.getSubVals(); + String openFile = av.getValue(); if (openFile == null) continue; - argsWereParsed = true; + theseArgsWereParsed = true; if (first) { first = false; - if (!headless) + if (!headless && desktop != null) { desktop.setProgressBar( MessageManager.getString( "status.processing_commandline_args"), progress = System.currentTimeMillis()); + progressBarSet = true; } } @@ -160,7 +232,9 @@ public class Commands { if (!(new File(openFile)).exists()) { - Console.warn("Can't find file '" + openFile + "'"); + addError("Can't find file '" + openFile + "'"); + isError = true; + continue; } } } @@ -174,105 +248,142 @@ public class Commands format = new IdentifyFile().identify(openFile, protocol); } catch (FileFormatException e1) { - Console.error("Unknown file format for '" + openFile + "'"); + addError("Unknown file format for '" + openFile + "'"); + isError = true; + continue; } af = afMap.get(id); - if (af == null) + // When to open a new AlignFrame + if (af == null || "true".equals(av.getSubVal("new")) + || a == Arg.OPEN || format == FileFormat.Jalview) { - /* - * this approach isn't working yet - // get default annotations before opening AlignFrame - if (m.get(Arg.SSANNOTATION) != null) + if (a == Arg.OPEN) { - Console.debug("***** SSANNOTATION=" - + m.get(Arg.SSANNOTATION).getBoolean()); + Jalview.testoutput(argParser, Arg.OPEN, "examples/uniref50.fa", + openFile); } - if (m.get(Arg.NOTEMPFAC) != null) + + Console.debug( + "Opening '" + openFile + "' in new alignment frame"); + FileLoader fileLoader = new FileLoader(!headless); + boolean xception = false; + try { - Console.debug( - "***** NOTEMPFAC=" + m.get(Arg.NOTEMPFAC).getBoolean()); - } - boolean showSecondaryStructure = (m.get(Arg.SSANNOTATION) != null) - ? m.get(Arg.SSANNOTATION).getBoolean() - : false; - boolean showTemperatureFactor = (m.get(Arg.NOTEMPFAC) != null) - ? !m.get(Arg.NOTEMPFAC).getBoolean() - : false; - Console.debug("***** tempfac=" + showTemperatureFactor - + ", showSS=" + showSecondaryStructure); - StructureSelectionManager ssm = StructureSelectionManager - .getStructureSelectionManager(Desktop.instance); - if (ssm != null) - { - ssm.setAddTempFacAnnot(showTemperatureFactor); - ssm.setProcessSecondaryStructure(showSecondaryStructure); + af = fileLoader.LoadFileWaitTillLoaded(openFile, protocol, + format); + } catch (Throwable thr) + { + xception = true; + addError("Couldn't open '" + openFile + "' as " + format + " " + + thr.getLocalizedMessage() + + " (Enable debug for full stack trace)"); + isError = true; + Console.debug("Exception when opening '" + openFile + "'", thr); + } finally + { + if (af == null && !xception) + { + addInfo("Ignoring '" + openFile + + "' - no alignment data found."); + continue; + } } - */ - // get kind of temperature factor annotation - StructureImportSettings.TFType tempfacType = TFType.DEFAULT; - if ((!ArgParser.getBoolean(m, Arg.NOTEMPFAC)) - && ArgParser.getArgValues(m, Arg.TEMPFAC) != null) + // colour alignment? + String colour = ArgParser.getFromSubValArgOrPref(avm, av, + Arg.COLOUR, sv, null, "DEFAULT_COLOUR_PROT", ""); + if ("" != colour) { - try + ColourSchemeI cs = ColourSchemeProperty.getColourScheme( + af.getViewport(), af.getViewport().getAlignment(), + colour); + + if (cs == null && !"None".equals(colour)) { - tempfacType = StructureImportSettings.TFType.valueOf(ArgParser - .getValue(m, Arg.TEMPFAC).toUpperCase(Locale.ROOT)); - Console.debug("Obtained Temperature Factor type of '" - + tempfacType + "'"); - } catch (IllegalArgumentException e) + addWarn("Couldn't parse '" + colour + "' as a colourscheme."); + } + else { - // Just an error message! - StringBuilder sb = new StringBuilder().append("Cannot set --") - .append(Arg.TEMPFAC.getName()).append(" to '") - .append(tempfacType) - .append("', ignoring. Valid values are: "); - Iterator it = Arrays - .stream(StructureImportSettings.TFType.values()) - .iterator(); - while (it.hasNext()) - { - sb.append(it.next().toString().toLowerCase(Locale.ROOT)); - if (it.hasNext()) - sb.append(", "); - } - Console.warn(sb.toString()); + af.changeColour(cs); } + Jalview.testoutput(argParser, Arg.COLOUR, "zappo", colour); } - Console.debug( - "Opening '" + openFile + "' in new alignment frame"); - FileLoader fileLoader = new FileLoader(!headless); - - StructureImportSettings.setTemperatureFactorType(tempfacType); + // Change alignment frame title + String title = ArgParser.getFromSubValArgOrPref(avm, av, + Arg.TITLE, sv, null, null, null); + if (title != null) + { + af.setTitle(title); + Jalview.testoutput(argParser, Arg.TITLE, "test title", title); + } - af = fileLoader.LoadFileWaitTillLoaded(openFile, protocol, - format); + // Add features + String featuresfile = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.FEATURES, sv); + if (featuresfile != null) + { + af.parseFeaturesFile(featuresfile, + AppletFormatAdapter.checkProtocol(featuresfile)); + Jalview.testoutput(argParser, Arg.FEATURES, + "examples/testdata/plantfdx.features", featuresfile); + } - // wrap alignment? - if (ArgParser.getBoolean(m, Arg.WRAP)) + // Add annotations from file + String annotationsfile = ArgParser.getValueFromSubValOrArg(avm, + av, Arg.ANNOTATIONS, sv); + if (annotationsfile != null) { - af.getCurrentView().setWrapAlignment(true); + af.loadJalviewDataFile(annotationsfile, null, null, null); + Jalview.testoutput(argParser, Arg.ANNOTATIONS, + "examples/testdata/plantfdx.annotations", + annotationsfile); } - // change alignment frame title - if (ArgParser.getValue(m, Arg.TITLE) != null) - af.setTitle(ArgParser.getValue(m, Arg.TITLE)); + // Set or clear the sortbytree flag + boolean sortbytree = ArgParser.getBoolFromSubValOrArg(avm, + Arg.SORTBYTREE, sv); + if (sortbytree) + { + af.getViewport().setSortByTree(true); + Jalview.testoutput(argParser, Arg.SORTBYTREE); + } - /* hacky approach to hiding the annotations */ - // show secondary structure annotations? - if (ArgParser.getBoolean(m, Arg.SSANNOTATION)) + // Load tree from file + String treefile = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.TREE, sv); + if (treefile != null) { - // do this better (annotation types?) - AlignmentUtils.showOrHideSequenceAnnotations( - af.getCurrentView().getAlignment(), - Collections.singleton("Secondary Structure"), null, - false, false); + try + { + NewickFile nf = new NewickFile(treefile, + AppletFormatAdapter.checkProtocol(treefile)); + af.getViewport().setCurrentTree( + af.showNewickTree(nf, treefile).getTree()); + Jalview.testoutput(argParser, Arg.TREE, + "examples/testdata/uniref50_test_tree", treefile); + } catch (IOException e) + { + addError("Couldn't add tree " + treefile, e); + isError = true; + } } + // Show secondary structure annotations? + boolean showSSAnnotations = ArgParser.getFromSubValArgOrPref(avm, + Arg.SHOWSSANNOTATIONS, av.getSubVals(), null, + "STRUCT_FROM_PDB", true); + af.setAnnotationsVisibility(showSSAnnotations, true, false); + + // Show sequence annotations? + boolean showAnnotations = ArgParser.getFromSubValArgOrPref(avm, + Arg.SHOWANNOTATIONS, av.getSubVals(), null, + "SHOW_ANNOTATIONS", true); + af.setAnnotationsVisibility(showAnnotations, false, true); + // show temperature factor annotations? - if (ArgParser.getBoolean(m, Arg.NOTEMPFAC)) + if (avm.getBoolean(Arg.NOTEMPFAC)) { // do this better (annotation types?) List hideThese = new ArrayList<>(); @@ -282,30 +393,12 @@ public class Commands af.getCurrentView().getAlignment(), hideThese, null, false, false); } - else - /* comment out hacky approach up to here and add this line: - if (showTemperatureFactor) - */ - { - if (ArgParser.getValue(m, Arg.TEMPFAC_LABEL) != null) - { - AlignmentAnnotation aa = AlignmentUtils - .getFirstSequenceAnnotationOfType( - af.getCurrentView().getAlignment(), - AlignmentAnnotation.LINE_GRAPH); - String label = ArgParser.getValue(m, Arg.TEMPFAC_LABEL); - if (aa != null) - { - aa.label = label; - } - else - { - Console.info( - "Could not find annotation to apply tempfac_label '" - + label); - } - } - } + + // wrap alignment? do this last for formatting reasons + wrap = ArgParser.getFromSubValArgOrPref(avm, Arg.WRAP, sv, null, + "WRAP_ALIGNMENT", false); + // af.setWrapFormat(wrap) is applied after structures are opened for + // annotation reasons // store the AlignFrame for this id afMap.put(id, af); @@ -317,110 +410,85 @@ public class Commands .getStructureSelectionManager(Desktop.instance); SequenceI seq = af.alignPanel.getAlignment().getSequenceAt(0); ssm.computeMapping(false, new SequenceI[] { seq }, null, - openFile, DataSourceType.FILE, null); + openFile, DataSourceType.FILE, null, null, null, false); } } else { Console.debug( "Opening '" + openFile + "' in existing alignment frame"); - af.getCurrentView().addFile(new File(openFile), format); + DataSourceType dst = HttpUtils.startsWithHttpOrHttps(openFile) + ? DataSourceType.URL + : DataSourceType.FILE; + FileLoader fileLoader = new FileLoader(!headless); + fileLoader.LoadFile(af.getCurrentView(), openFile, dst, null, + false); } - System.out - .println("Command " + Arg.OPEN + " executed successfully!"); + Console.debug("Command " + Arg.APPEND + " executed successfully!"); } if (first) // first=true means nothing opened { if (headless) { - Console.error("Could not open any files in headless mode"); - System.exit(1); + Jalview.exit("Could not open any files in headless mode", + ExitCode.NO_FILES); } - // TOREMOVE COMMENT - // @Ben assumed this was the GUI version of above, rather then the - // first==false state else { - Console.warn("No more files to open"); - if (desktop != null) - desktop.setProgressBar(null, progress); + Console.info("No more files to open"); } } + if (progressBarSet && desktop != null) + desktop.setProgressBar(null, progress); } - // load a pAE file if given - if (ArgParser.getValues(m, Arg.PAEMATRIX) != null) + // open the structure (from same PDB file or given PDBfile) + if (!avm.getBoolean(Arg.NOSTRUCTURE)) { AlignFrame af = afMap.get(id); - if (af != null) + if (avm.containsArg(Arg.STRUCTURE)) { - for (String val : ArgParser.getValues(m, Arg.PAEMATRIX)) + commandArgsProvided = true; + for (ArgValue av : avm.getArgValueList(Arg.STRUCTURE)) { - SubVal subVal = ArgParser.getSubVal(val); - File paeFile = new File(subVal.content); - String structId = "structid".equals(subVal.keyName) - ? subVal.keyValue - : null; - if (subVal.notSet()) - { - // take structid from pdbfilename - } - if ("structfile".equals(subVal.keyName)) - { - EBIAlfaFold.addAlphaFoldPAEToStructure( - af.getCurrentView().getAlignment(), paeFile, - subVal.index, subVal.keyValue, false); - } - else if ("structid".equals(subVal.keyName)) - { - EBIAlfaFold.addAlphaFoldPAEToStructure( - af.getCurrentView().getAlignment(), paeFile, - subVal.index, subVal.keyValue, true); - } - else - { - EBIAlfaFold.addAlphaFoldPAEToSequence( - af.getCurrentView().getAlignment(), paeFile, - subVal.index, - "seqid".equals(subVal.keyName) ? subVal.keyValue - : null); - // required to readjust the height and position of the pAE - // annotation - } - for (AlignmentViewPanel ap : af.getAlignPanels()) + String val = av.getValue(); + SubVals subVals = av.getSubVals(); + SequenceI seq = getSpecifiedSequence(af, avm, av); + if (seq == null) { - ap.adjustAnnotationHeight(); + // Could not find sequence from subId, let's assume the first + // sequence in the alignframe + AlignmentI al = af.getCurrentView().getAlignment(); + seq = al.getSequenceAt(0); } - } - } - } - // open the structure (from same PDB file or given PDBfile) - if (!ArgParser.getBoolean(m, Arg.NOSTRUCTURE)) - { - AlignFrame af = afMap.get(id); - if (ArgParser.getArgValues(m, Arg.STRUCTURE) != null) - { - for (String val : ArgParser.getValues(m, Arg.STRUCTURE)) - { - SubVal subId = new SubVal(val); - SequenceI seq = getSpecifiedSequence(af, subId); if (seq == null) { - Console.warn("Could not find sequence for argument --" - + Arg.STRUCTURE + "=" + val); - break STRUCTURE; + addWarn("Could not find sequence for argument " + + Arg.STRUCTURE.argString() + "=" + val); + continue; } File structureFile = null; - if (subId.content != null && subId.content.length() != 0) + if (subVals.getContent() != null + && subVals.getContent().length() != 0) { - structureFile = new File(subId.content); + structureFile = new File(subVals.getContent()); Console.debug("Using structure file (from argument) '" + structureFile.getAbsolutePath() + "'"); } + // TRY THIS + /* + * PDBEntry fileEntry = new AssociatePdbFileWithSeq() + * .associatePdbWithSeq(selectedPdbFileName, DataSourceType.FILE, + * selectedSequence, true, Desktop.instance); + * + * sViewer = launchStructureViewer(ssm, new PDBEntry[] { fileEntry }, ap, new + * SequenceI[] { selectedSequence }); + * + */ /* THIS DOESN'T WORK */ else if (seq.getAllPDBEntries() != null && seq.getAllPDBEntries().size() > 0) @@ -433,14 +501,14 @@ public class Commands if (structureFile == null) { - Console.warn("Not provided structure file with '" + val + "'"); + addWarn("Not provided structure file with '" + val + "'"); continue; } if (!structureFile.exists()) { - Console.warn("Structure file '" - + structureFile.getAbsoluteFile() + "' not found."); + addWarn("Structure file '" + structureFile.getAbsoluteFile() + + "' not found."); continue; } @@ -449,39 +517,309 @@ public class Commands // open structure view AlignmentPanel ap = af.alignPanel; - StructureChooser.openStructureFileForSequence(ap, seq, - structureFile); + if (headless) + { + Cache.setProperty(Preferences.STRUCTURE_DISPLAY, + StructureViewer.ViewerType.JMOL.toString()); + } + + String structureFilepath = structureFile.getAbsolutePath(); + + // get PAEMATRIX file and label from subvals or Arg.PAEMATRIX + String paeFilepath = ArgParser + .getFromSubValArgOrPrefWithSubstitutions(argParser, avm, + Arg.PAEMATRIX, Position.AFTER, av, subVals, null, + null, null); + if (paeFilepath != null) + { + File paeFile = new File(paeFilepath); + + try + { + paeFilepath = paeFile.getCanonicalPath(); + } catch (IOException e) + { + paeFilepath = paeFile.getAbsolutePath(); + addWarn("Problem with the PAE file path: '" + + paeFile.getPath() + "'"); + } + } + + // showing annotations from structure file or not + boolean ssFromStructure = ArgParser.getFromSubValArgOrPref(avm, + Arg.SHOWSSANNOTATIONS, subVals, null, "STRUCT_FROM_PDB", + true); + + // get TEMPFAC type from subvals or Arg.TEMPFAC in case user Adds + // reference annotations + String tftString = ArgParser + .getFromSubValArgOrPrefWithSubstitutions(argParser, avm, + Arg.TEMPFAC, Position.AFTER, av, subVals, null, + null, null); + boolean notempfac = ArgParser.getFromSubValArgOrPref(avm, + Arg.NOTEMPFAC, subVals, null, "ADD_TEMPFACT_ANN", false, + true); + TFType tft = notempfac ? null : TFType.DEFAULT; + if (tftString != null && !notempfac) + { + // get kind of temperature factor annotation + try + { + tft = TFType.valueOf(tftString.toUpperCase(Locale.ROOT)); + Console.debug("Obtained Temperature Factor type of '" + tft + + "' for structure '" + structureFilepath + "'"); + } catch (IllegalArgumentException e) + { + // Just an error message! + StringBuilder sb = new StringBuilder().append("Cannot set ") + .append(Arg.TEMPFAC.argString()).append(" to '") + .append(tft) + .append("', ignoring. Valid values are: "); + Iterator it = Arrays.stream(TFType.values()) + .iterator(); + while (it.hasNext()) + { + sb.append(it.next().toString().toLowerCase(Locale.ROOT)); + if (it.hasNext()) + sb.append(", "); + } + addWarn(sb.toString()); + } + } + + String sViewer = ArgParser.getFromSubValArgOrPref(avm, + Arg.STRUCTUREVIEWER, Position.AFTER, av, subVals, null, + null, "jmol"); + ViewerType viewerType = ViewerType.getFromString(sViewer); + + // TODO use ssFromStructure + StructureViewer sv = StructureChooser + .openStructureFileForSequence(null, null, ap, seq, false, + structureFilepath, tft, paeFilepath, false, + ssFromStructure, false, viewerType); + + if (sv == null) + { + addError("Failed to import and open structure view for file '" + + structureFile + "'."); + continue; + } + try + { + long tries = 1000; + while (sv.isBusy() && tries > 0) + { + Thread.sleep(25); + if (sv.isBusy()) + { + tries--; + Console.debug( + "Waiting for viewer for " + structureFilepath); + } + } + if (tries == 0 && sv.isBusy()) + { + addWarn("Gave up waiting for structure viewer to load file '" + + structureFile + + "'. Something may have gone wrong."); + } + } catch (Exception x) + { + addError("Exception whilst waiting for structure viewer " + + structureFilepath, x); + isError = true; + } + + // add StructureViewer to svMap list + if (svMap == null) + { + svMap = new HashMap<>(); + } + if (svMap.get(id) == null) + { + svMap.put(id, new ArrayList<>()); + } + svMap.get(id).add(sv); + + Console.debug( + "Successfully opened viewer for " + structureFilepath); + String structureImageFilename = ArgParser.getValueFromSubValOrArg( + avm, av, Arg.STRUCTUREIMAGE, subVals); + if (sv != null && structureImageFilename != null) + { + ArgValue siAv = avm.getClosestNextArgValueOfArg(av, + Arg.STRUCTUREIMAGE); + SubVals sisv = null; + if (structureImageFilename.equals(siAv.getValue())) + { + sisv = siAv.getSubVals(); + } + File structureImageFile = new File(structureImageFilename); + String width = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.STRUCTUREIMAGEWIDTH, sisv); + String height = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.STRUCTUREIMAGEHEIGHT, sisv); + String scale = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.STRUCTUREIMAGESCALE, sisv); + String renderer = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.STRUCTUREIMAGETEXTRENDERER, sisv); + String typeS = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.STRUCTUREIMAGETYPE, sisv); + if (typeS == null || typeS.length() == 0) + { + typeS = FileUtils.getExtension(structureImageFile); + } + TYPE imageType; + try + { + imageType = Enum.valueOf(TYPE.class, + typeS.toUpperCase(Locale.ROOT)); + } catch (IllegalArgumentException e) + { + addWarn("Do not know image format '" + typeS + + "', using PNG"); + imageType = TYPE.PNG; + } + BitmapImageSizing userBis = ImageMaker + .parseScaleWidthHeightStrings(scale, width, height); + // TODO MAKE THIS VIEWER INDEPENDENT!! + switch (StructureViewer.getViewerType()) + { + case JMOL: + JalviewStructureDisplayI sview = sv + .getJalviewStructureDisplay(); + if (sview instanceof AppJmol) + { + AppJmol jmol = (AppJmol) sview; + try + { + boolean success = this.checksBeforeWritingToFile(avm, + subVals, false, structureImageFilename, + "structure image", isError); + if (!success) + { + continue; + } + + Console.debug("Rendering image to " + structureImageFile); + jmol.makePDBImage(structureImageFile, imageType, renderer, + userBis); + Console.debug("Finished Rendering image to " + + structureImageFile); + + } catch (ImageOutputException ioexc) + { + addError("Unexpected error whilst exporting image to " + + structureImageFile, ioexc); + isError = true; + continue; + } + + } + break; + default: + addWarn("Cannot export image for structure viewer " + + sv.getViewerType() + " yet"); + continue; + } + } } } } + + if (wrap) + { + AlignFrame af = afMap.get(id); + if (af != null) + { + af.setWrapFormat(wrap, true); + } + } + + /* + boolean doShading = avm.getBoolean(Arg.TEMPFAC_SHADING); + if (doShading) + { + AlignFrame af = afMap.get(id); + for (AlignmentAnnotation aa : af.alignPanel.getAlignment() + .findAnnotation(PDBChain.class.getName().toString())) + { + AnnotationColourGradient acg = new AnnotationColourGradient(aa, + af.alignPanel.av.getGlobalColourScheme(), 0); + acg.setSeqAssociated(true); + af.changeColour(acg); + Console.info("Changed colour " + acg.toString()); + } + } + */ + + return theseArgsWereParsed && !isError; } - protected void processImages(String id) + protected void processGroovyScript(String id) { - Map m = argParser.linkedArgs(id); + ArgValuesMap avm = argParser.getLinkedArgs(id); AlignFrame af = afMap.get(id); if (af == null) { - Console.warn("Did not have an alignment window for id=" + id); + addWarn("Did not have an alignment window for id=" + id); return; } - if (ArgParser.getValues(m, Arg.IMAGE) != null) + if (avm.containsArg(Arg.GROOVY)) { - for (String val : ArgParser.getValues(m, Arg.IMAGE)) + String groovyscript = avm.getValue(Arg.GROOVY); + if (groovyscript != null) { - SubVal subVal = new SubVal(val); - String type = "png"; // default - String fileName = subVal.content; + // Execute the groovy script after we've done all the rendering stuff + // and before any images or figures are generated. + Console.info("Executing script " + groovyscript); + Jalview.getInstance().executeGroovyScript(groovyscript, af); + } + } + } + + protected boolean processImages(String id) + { + ArgValuesMap avm = argParser.getLinkedArgs(id); + AlignFrame af = afMap.get(id); + + if (af == null) + { + addWarn("Did not have an alignment window for id=" + id); + return false; + } + + Boolean isError = Boolean.valueOf(false); + if (avm.containsArg(Arg.IMAGE)) + { + for (ArgValue av : avm.getArgValueList(Arg.IMAGE)) + { + String val = av.getValue(); + SubVals subVal = av.getSubVals(); + String fileName = subVal.getContent(); File file = new File(fileName); - if ("type".equals(subVal.keyName)) - { - type = subVal.keyValue; - } - else if (fileName != null) + String name = af.getName(); + String renderer = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.TEXTRENDERER, subVal); + if (renderer == null) + renderer = "text"; + String type = "png"; // default + + String scale = ArgParser.getValueFromSubValOrArg(avm, av, Arg.SCALE, + subVal); + String width = ArgParser.getValueFromSubValOrArg(avm, av, Arg.WIDTH, + subVal); + String height = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.HEIGHT, subVal); + BitmapImageSizing userBis = ImageMaker + .parseScaleWidthHeightStrings(scale, width, height); + + type = ArgParser.getValueFromSubValOrArg(avm, av, Arg.TYPE, subVal); + if (type == null && fileName != null) { - for (String ext : new String[] { "svg", "png", "html" }) + for (String ext : new String[] { "svg", "png", "html", "eps" }) { if (fileName.toLowerCase(Locale.ROOT).endsWith("." + ext)) { @@ -493,40 +831,336 @@ public class Commands Cache.setPropsAreReadOnly(true); Cache.setProperty("EXPORT_EMBBED_BIOJSON", "false"); - switch (type) + Console.info("Writing " + file); + + boolean success = checksBeforeWritingToFile(avm, subVal, false, + fileName, "image", isError); + if (!success) + { + continue; + } + + try + { + switch (type) + { + + case "svg": + Console.debug("Outputting type '" + type + "' to " + fileName); + af.createSVG(file, renderer); + break; + + case "png": + Console.debug("Outputting type '" + type + "' to " + fileName); + af.createPNG(file, null, userBis); + break; + + case "html": + Console.debug("Outputting type '" + type + "' to " + fileName); + HtmlSvgOutput htmlSVG = new HtmlSvgOutput(af.alignPanel); + htmlSVG.exportHTML(fileName, renderer); + break; + + case "biojs": + Console.debug( + "Outputting BioJS MSA Viwer HTML file: " + fileName); + try + { + BioJsHTMLOutput.refreshVersionInfo( + BioJsHTMLOutput.BJS_TEMPLATES_LOCAL_DIRECTORY); + } catch (URISyntaxException e) + { + e.printStackTrace(); + } + BioJsHTMLOutput bjs = new BioJsHTMLOutput(af.alignPanel); + bjs.exportHTML(fileName); + break; + + case "eps": + Console.debug("Outputting EPS file: " + fileName); + af.createEPS(file, renderer); + break; + + case "imagemap": + Console.debug("Outputting ImageMap file: " + fileName); + af.createImageMap(file, name); + break; + + default: + addWarn(Arg.IMAGE.argString() + " type '" + type + + "' not known. Ignoring"); + break; + } + } catch (Exception ioex) + { + addError("Unexpected error during export to '" + fileName + "'", + ioex); + isError = true; + } + } + } + return !isError; + } + + protected boolean processOutput(String id) + { + ArgValuesMap avm = argParser.getLinkedArgs(id); + AlignFrame af = afMap.get(id); + + if (af == null) + { + addWarn("Did not have an alignment window for id=" + id); + return false; + } + + Boolean isError = Boolean.valueOf(false); + + if (avm.containsArg(Arg.OUTPUT)) + { + for (ArgValue av : avm.getArgValueList(Arg.OUTPUT)) + { + String val = av.getValue(); + SubVals subVals = av.getSubVals(); + String fileName = subVals.getContent(); + boolean stdout = ArgParser.STDOUTFILENAME.equals(fileName); + File file = new File(fileName); + + String name = af.getName(); + String format = ArgParser.getValueFromSubValOrArg(avm, av, + Arg.FORMAT, subVals); + FileFormats ffs = FileFormats.getInstance(); + List validFormats = ffs.getWritableFormats(false); + + FileFormatI ff = null; + if (format == null && fileName != null) + { + FORMAT: for (String fname : validFormats) + { + FileFormatI tff = ffs.forName(fname); + String[] extensions = tff.getExtensions().split(","); + for (String ext : extensions) + { + if (fileName.toLowerCase(Locale.ROOT).endsWith("." + ext)) + { + ff = tff; + format = ff.getName(); + break FORMAT; + } + } + } + } + if (ff == null && format != null) + { + ff = ffs.forName(format); + } + if (ff == null) + { + if (stdout) + { + ff = FileFormat.Fasta; + } + else + { + StringBuilder validSB = new StringBuilder(); + for (String f : validFormats) + { + if (validSB.length() > 0) + validSB.append(", "); + validSB.append(f); + FileFormatI tff = ffs.forName(f); + validSB.append(" ("); + validSB.append(tff.getExtensions()); + validSB.append(")"); + } + + addError("No valid format specified for " + + Arg.OUTPUT.argString() + ". Valid formats are " + + validSB.toString() + "."); + continue; + } + } + + boolean success = checksBeforeWritingToFile(avm, subVals, true, + fileName, ff.getName(), isError); + if (!success) + { + continue; + } + + boolean backups = ArgParser.getFromSubValArgOrPref(avm, Arg.BACKUPS, + subVals, null, + Platform.isHeadless() ? null : BackupFiles.ENABLED, + !Platform.isHeadless()); + + Console.info("Writing " + fileName); + + af.saveAlignment(fileName, ff, stdout, backups); + if (af.isSaveAlignmentSuccessful()) { - case "svg": - Console.debug("Outputting type '" + type + "' to " + fileName); - af.createSVG(file); - break; - case "png": - Console.debug("Outputting type '" + type + "' to " + fileName); - af.createPNG(file); - break; - case "html": - Console.debug("Outputting type '" + type + "' to " + fileName); - HtmlSvgOutput htmlSVG = new HtmlSvgOutput(af.alignPanel); - htmlSVG.exportHTML(fileName); - break; - default: - Console.warn("--image type '" + type + "' not known. Ignoring"); - break; + Console.debug("Written alignment '" + name + "' in " + + ff.getName() + " format to '" + file + "'"); } + else + { + addError("Error writing file '" + file + "' in " + ff.getName() + + " format!"); + isError = true; + continue; + } + } } + return !isError; } - private SequenceI getSpecifiedSequence(AlignFrame af, SubVal subId) + private SequenceI getSpecifiedSequence(AlignFrame af, ArgValuesMap avm, + ArgValue av) { + SubVals subVals = av.getSubVals(); + ArgValue idAv = avm.getClosestNextArgValueOfArg(av, Arg.SEQID); + SequenceI seq = null; + if (subVals == null && idAv == null) + return null; + if (af == null || af.getCurrentView() == null) + { + return null; + } AlignmentI al = af.getCurrentView().getAlignment(); - if (-1 < subId.index && subId.index < al.getSequences().size()) + if (al == null) + { + return null; + } + if (subVals != null) + { + if (subVals.has(Arg.SEQID.getName())) + { + seq = al.findName(subVals.get(Arg.SEQID.getName())); + } + else if (-1 < subVals.getIndex() + && subVals.getIndex() < al.getSequences().size()) + { + seq = al.getSequenceAt(subVals.getIndex()); + } + } + if (seq == null && idAv != null) + { + seq = al.findName(idAv.getValue()); + } + return seq; + } + + public AlignFrame[] getAlignFrames() + { + AlignFrame[] afs = null; + if (afMap != null) + { + afs = (AlignFrame[]) afMap.values().toArray(); + } + + return afs; + } + + public List getStructureViewers() + { + List svs = null; + if (svMap != null) + { + for (List svList : svMap.values()) + { + if (svs == null) + { + svs = new ArrayList<>(); + } + svs.addAll(svList); + } + } + return svs; + } + + private void addInfo(String errorMessage) + { + Console.info(errorMessage); + errors.add(errorMessage); + } + + private void addWarn(String errorMessage) + { + Console.warn(errorMessage); + errors.add(errorMessage); + } + + private void addError(String errorMessage) + { + addError(errorMessage, null); + } + + private void addError(String errorMessage, Exception e) + { + Console.error(errorMessage, e); + errors.add(errorMessage); + } + + private boolean checksBeforeWritingToFile(ArgValuesMap avm, + SubVals subVal, boolean includeBackups, String filename, + String adjective, Boolean isError) + { + File file = new File(filename); + + boolean overwrite = ArgParser.getFromSubValArgOrPref(avm, Arg.OVERWRITE, + subVal, null, "OVERWRITE_OUTPUT", false); + boolean stdout = false; + boolean backups = false; + if (includeBackups) + { + stdout = ArgParser.STDOUTFILENAME.equals(filename); + // backups. Use the Arg.BACKUPS or subval "backups" setting first, + // otherwise if headless assume false, if not headless use the user + // preference with default true. + backups = ArgParser.getFromSubValArgOrPref(avm, Arg.BACKUPS, subVal, + null, Platform.isHeadless() ? null : BackupFiles.ENABLED, + !Platform.isHeadless()); + } + + if (file.exists() && !(overwrite || backups || stdout)) { - return al.getSequenceAt(subId.index); + addWarn("Won't overwrite file '" + filename + "' without " + + Arg.OVERWRITE.argString() + + (includeBackups ? " or " + Arg.BACKUPS.argString() : "") + + " set"); + return false; } - else if ("id".equals(subId.keyName)) + + boolean mkdirs = ArgParser.getFromSubValArgOrPref(avm, Arg.MKDIRS, + subVal, null, "MKDIRS_OUTPUT", false); + + if (!FileUtils.checkParentDir(file, mkdirs)) + { + addError("Directory '" + + FileUtils.getParentDir(file).getAbsolutePath() + + "' does not exist for " + adjective + " file '" + filename + + "'." + + (mkdirs ? "" : " Try using " + Arg.MKDIRS.argString())); + isError = true; + return false; + } + + return true; + } + + public List getErrors() + { + return errors; + } + + public String errorsToString() + { + StringBuilder sb = new StringBuilder(); + for (String error : errors) { - return al.findName(subId.keyValue); + if (sb.length() > 0) + sb.append("\n"); + sb.append("- " + error); } - return null; + return sb.toString(); } }