X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FJalview2XML.java;h=dcf65b73c0233660c8073f5c2ac2d10b61f49bb2;hb=b2f9a8d7bce642ff4011bc6d49e02bb0569fbb11;hp=9bf6a21ac6077f79826e39ecc1c90c9e0a4542da;hpb=65b8fbcfb6380b445b49354c27b374aada635c08;p=jalview.git diff --git a/src/jalview/gui/Jalview2XML.java b/src/jalview/gui/Jalview2XML.java old mode 100755 new mode 100644 index 9bf6a21..dcf65b7 --- a/src/jalview/gui/Jalview2XML.java +++ b/src/jalview/gui/Jalview2XML.java @@ -1,56 +1,238 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.1) + * Copyright (C) 2014 The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.gui; +import java.awt.Rectangle; import java.io.*; +import java.lang.reflect.InvocationTargetException; import java.net.*; import java.util.*; +import java.util.Map.Entry; import java.util.jar.*; import javax.swing.*; import org.exolab.castor.xml.*; + +import jalview.bin.Cache; +import jalview.datamodel.Alignment; +import jalview.datamodel.AlignmentAnnotation; +import jalview.datamodel.AlignmentI; +import jalview.datamodel.SequenceI; import jalview.schemabinding.version2.*; import jalview.schemes.*; -import jalview.structure.StructureSelectionManager; +import jalview.util.Platform; +import jalview.util.jarInputStreamProvider; +import jalview.viewmodel.AlignmentViewport; +import jalview.ws.jws2.Jws2Discoverer; +import jalview.ws.jws2.dm.AAConSettings; +import jalview.ws.jws2.jabaws2.Jws2Instance; +import jalview.ws.params.ArgumentI; +import jalview.ws.params.AutoCalcSetting; +import jalview.ws.params.WsParamSetI; /** - * DOCUMENT ME! - * + * Write out the current jalview desktop state as a Jalview XML stream. + * + * Note: the vamsas objects referred to here are primitive versions of the + * VAMSAS project schema elements - they are not the same and most likely never + * will be :) + * * @author $author$ - * @version $Revision$ + * @version $Revision: 1.134 $ */ public class Jalview2XML { + /** + * create/return unique hash string for sq + * + * @param sq + * @return new or existing unique string for sq + */ + String seqHash(SequenceI sq) + { + if (seqsToIds == null) + { + initSeqRefs(); + } + if (seqsToIds.containsKey(sq)) + { + return (String) seqsToIds.get(sq); + } + else + { + // create sequential key + String key = "sq" + (seqsToIds.size() + 1); + key = makeHashCode(sq, key); // check we don't have an external reference + // for it already. + seqsToIds.put(sq, key); + return key; + } + } + + void clearSeqRefs() + { + if (_cleartables) + { + if (seqRefIds != null) + { + seqRefIds.clear(); + } + if (seqsToIds != null) + { + seqsToIds.clear(); + } + // seqRefIds = null; + // seqsToIds = null; + } + else + { + // do nothing + warn("clearSeqRefs called when _cleartables was not set. Doing nothing."); + // seqRefIds = new Hashtable(); + // seqsToIds = new IdentityHashMap(); + } + } + + void initSeqRefs() + { + if (seqsToIds == null) + { + seqsToIds = new IdentityHashMap(); + } + if (seqRefIds == null) + { + seqRefIds = new Hashtable(); + } + } + + /** + * SequenceI reference -> XML ID string in jalview XML. Populated as XML reps + * of sequence objects are created. + */ + java.util.IdentityHashMap seqsToIds = null; + + /** + * jalview XML Sequence ID to jalview sequence object reference (both dataset + * and alignment sequences. Populated as XML reps of sequence objects are + * created.) + */ + java.util.Hashtable seqRefIds = null; // key->SequenceI resolution + + Vector frefedSequence = null; - Hashtable seqRefIds; + boolean raiseGUI = true; // whether errors are raised in dialog boxes or not + + public Jalview2XML() + { + } + + public Jalview2XML(boolean raiseGUI) + { + this.raiseGUI = raiseGUI; + } + + public void resolveFrefedSequences() + { + if (frefedSequence.size() > 0) + { + int r = 0, rSize = frefedSequence.size(); + while (r < rSize) + { + Object[] ref = (Object[]) frefedSequence.elementAt(r); + if (ref != null) + { + String sref = (String) ref[0]; + if (seqRefIds.containsKey(sref)) + { + if (ref[1] instanceof jalview.datamodel.Mapping) + { + SequenceI seq = (SequenceI) seqRefIds.get(sref); + while (seq.getDatasetSequence() != null) + { + seq = seq.getDatasetSequence(); + } + ((jalview.datamodel.Mapping) ref[1]).setTo(seq); + } + else + { + if (ref[1] instanceof jalview.datamodel.AlignedCodonFrame) + { + SequenceI seq = (SequenceI) seqRefIds.get(sref); + while (seq.getDatasetSequence() != null) + { + seq = seq.getDatasetSequence(); + } + if (ref[2] != null + && ref[2] instanceof jalview.datamodel.Mapping) + { + jalview.datamodel.Mapping mp = (jalview.datamodel.Mapping) ref[2]; + ((jalview.datamodel.AlignedCodonFrame) ref[1]).addMap( + seq, mp.getTo(), mp.getMap()); + } + else + { + System.err + .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for AlcodonFrames involving " + + ref[2].getClass() + " type objects."); + } + } + else + { + System.err + .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for " + + ref[1].getClass() + " type objects."); + } + } + frefedSequence.remove(r); + rSize--; + } + else + { + System.err + .println("IMPLEMENTATION WARNING: Unresolved forward reference for hash string " + + ref[0] + + " with objecttype " + + ref[1].getClass()); + r++; + } + } + else + { + // empty reference + frefedSequence.remove(r); + rSize--; + } + } + } + } /** - * This maintains a list of viewports, the key being the - * seqSetId. Important to set historyItem and redoList - * for multiple views + * This maintains a list of viewports, the key being the seqSetId. Important + * to set historyItem and redoList for multiple views */ Hashtable viewportsAdded; Hashtable annotationIds = new Hashtable(); String uniqueSetSuffix = ""; + /** * List of pdbfiles added to Jar */ @@ -59,6 +241,37 @@ public class Jalview2XML // SAVES SEVERAL ALIGNMENT WINDOWS TO SAME JARFILE public void SaveState(File statefile) { + try + { + FileOutputStream fos = new FileOutputStream(statefile); + JarOutputStream jout = new JarOutputStream(fos); + SaveState(jout); + + } catch (Exception e) + { + // TODO: inform user of the problem - they need to know if their data was + // not saved ! + if (errorMessage == null) + { + errorMessage = "Couldn't write Jalview Archive to output file '" + + statefile + "' - See console error log for details"; + } + else + { + errorMessage += "(output file was '" + statefile + "')"; + } + e.printStackTrace(); + } + reportErrors(); + } + + /** + * Writes a jalview project archive to the given Jar output stream. + * + * @param jout + */ + public void SaveState(JarOutputStream jout) + { JInternalFrame[] frames = Desktop.desktop.getAllFrames(); if (frames == null) @@ -66,31 +279,38 @@ public class Jalview2XML return; } + Hashtable dsses = new Hashtable(); + try { - FileOutputStream fos = new FileOutputStream(statefile); - JarOutputStream jout = new JarOutputStream(fos); - //NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS - //////////////////////////////////////////////////// - PrintWriter out = new PrintWriter(new OutputStreamWriter(jout, - "UTF-8")); + // NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS + // ////////////////////////////////////////////////// + // NOTE ALSO new PrintWriter must be used for each new JarEntry + PrintWriter out = null; Vector shortNames = new Vector(); - //REVERSE ORDER + // REVERSE ORDER for (int i = frames.length - 1; i > -1; i--) { if (frames[i] instanceof AlignFrame) { AlignFrame af = (AlignFrame) frames[i]; + // skip ? + if (skipList != null + && skipList.containsKey(af.getViewport() + .getSequenceSetId())) + { + continue; + } String shortName = af.getTitle(); if (shortName.indexOf(File.separatorChar) > -1) { - shortName = shortName.substring(shortName.lastIndexOf( - File.separatorChar) + 1); + shortName = shortName.substring(shortName + .lastIndexOf(File.separatorChar) + 1); } int count = 1; @@ -99,8 +319,8 @@ public class Jalview2XML { if (shortName.endsWith("_" + (count - 1))) { - shortName = shortName.substring(0, - shortName.lastIndexOf("_")); + shortName = shortName + .substring(0, shortName.lastIndexOf("_")); } shortName = shortName.concat("_" + count); @@ -115,77 +335,154 @@ public class Jalview2XML } int ap, apSize = af.alignPanels.size(); + for (ap = 0; ap < apSize; ap++) { - AlignmentPanel apanel = (AlignmentPanel) af.alignPanels. - elementAt(ap); + AlignmentPanel apanel = (AlignmentPanel) af.alignPanels + .elementAt(ap); + String fileName = apSize == 1 ? shortName : ap + shortName; + if (!fileName.endsWith(".xml")) + { + fileName = fileName + ".xml"; + } + + SaveState(apanel, fileName, jout); + + String dssid = getDatasetIdRef(af.getViewport().getAlignment() + .getDataset()); + if (!dsses.containsKey(dssid)) + { + dsses.put(dssid, af); + } - SaveState(apanel, - apSize == 1 ? shortName : ap + shortName, - jout, out); } } } - out.close(); + writeDatasetFor(dsses, "" + jout.hashCode() + " " + uniqueSetSuffix, + jout); + + try + { + jout.flush(); + } catch (Exception foo) + { + } + ; jout.close(); - } - catch (Exception ex) + } catch (Exception ex) { + // TODO: inform user of the problem - they need to know if their data was + // not saved ! + if (errorMessage == null) + { + errorMessage = "Couldn't write Jalview Archive - see error output for details"; + } ex.printStackTrace(); } } // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW public boolean SaveAlignment(AlignFrame af, String jarFile, - String fileName) + String fileName) { try { int ap, apSize = af.alignPanels.size(); FileOutputStream fos = new FileOutputStream(jarFile); JarOutputStream jout = new JarOutputStream(fos); - PrintWriter out = new PrintWriter(new OutputStreamWriter(jout, - "UTF-8")); + Hashtable dsses = new Hashtable(); for (ap = 0; ap < apSize; ap++) { - AlignmentPanel apanel = (AlignmentPanel) af.alignPanels.elementAt(ap); - - SaveState(apanel, - apSize == 1 ? fileName : fileName + ap, - jout, out); + AlignmentPanel apanel = (AlignmentPanel) af.alignPanels + .elementAt(ap); + String jfileName = apSize == 1 ? fileName : fileName + ap; + if (!jfileName.endsWith(".xml")) + { + jfileName = jfileName + ".xml"; + } + SaveState(apanel, jfileName, jout); + String dssid = getDatasetIdRef(af.getViewport().getAlignment() + .getDataset()); + if (!dsses.containsKey(dssid)) + { + dsses.put(dssid, af); + } } - - out.close(); + writeDatasetFor(dsses, fileName, jout); + try + { + jout.flush(); + } catch (Exception foo) + { + } + ; jout.close(); return true; - } - catch (Exception ex) + } catch (Exception ex) { + errorMessage = "Couldn't Write alignment view to Jalview Archive - see error output for details"; ex.printStackTrace(); return false; } } - /** - * DOCUMENT ME! - * - * @param af DOCUMENT ME! - * @param timeStamp DOCUMENT ME! - * @param fileName DOCUMENT ME! - * @param jout DOCUMENT ME! - * @param out DOCUMENT ME! - */ - public JalviewModel SaveState(AlignmentPanel ap, - String fileName, - JarOutputStream jout, - PrintWriter out) + private void writeDatasetFor(Hashtable dsses, + String fileName, JarOutputStream jout) { - if (seqRefIds == null) + + for (String dssids : dsses.keySet()) { - seqRefIds = new Hashtable(); + AlignFrame _af = dsses.get(dssids); + String jfileName = fileName + " Dataset for " + _af.getTitle(); + if (!jfileName.endsWith(".xml")) + { + jfileName = jfileName + ".xml"; + } + SaveState(_af.alignPanel, jfileName, true, jout); } + } + + /** + * create a JalviewModel from an algnment view and marshall it to a + * JarOutputStream + * + * @param ap + * panel to create jalview model for + * @param fileName + * name of alignment panel written to output stream + * @param jout + * jar output stream + * @param out + * jar entry name + */ + public JalviewModel SaveState(AlignmentPanel ap, String fileName, + JarOutputStream jout) + { + return SaveState(ap, fileName, false, jout); + } + /** + * create a JalviewModel from an algnment view and marshall it to a + * JarOutputStream + * + * @param ap + * panel to create jalview model for + * @param fileName + * name of alignment panel written to output stream + * @param storeDS + * when true, only write the dataset for the alignment, not the data + * associated with the view. + * @param jout + * jar output stream + * @param out + * jar entry name + */ + public JalviewModel SaveState(AlignmentPanel ap, String fileName, + boolean storeDS, JarOutputStream jout) + { + initSeqRefs(); + Vector jmolViewIds = new Vector(); // Vector userColours = new Vector(); AlignViewport av = ap.av; @@ -194,11 +491,12 @@ public class Jalview2XML object.setVamsasModel(new jalview.schemabinding.version2.VamsasModel()); object.setCreationDate(new java.util.Date(System.currentTimeMillis())); - object.setVersion(jalview.bin.Cache.getProperty("VERSION")); + object.setVersion(jalview.bin.Cache.getDefault("VERSION", + "Development Build")); - jalview.datamodel.AlignmentI jal = av.alignment; + jalview.datamodel.AlignmentI jal = av.getAlignment(); - if (av.hasHiddenRows) + if (av.hasHiddenRows()) { jal = jal.getHiddenSequences().getFullAlignment(); } @@ -209,10 +507,20 @@ public class Jalview2XML vamsasSet.setGapChar(jal.getGapCharacter() + ""); - if(jal.getProperties()!=null) + if (jal.getDataset() != null) + { + // dataset id is the dataset's hashcode + vamsasSet.setDatasetId(getDatasetIdRef(jal.getDataset())); + if (storeDS) + { + // switch jal and the dataset + jal = jal.getDataset(); + } + } + if (jal.getProperties() != null) { Enumeration en = jal.getProperties().keys(); - while(en.hasMoreElements()) + while (en.hasMoreElements()) { String key = en.nextElement().toString(); SequenceSetProperties ssp = new SequenceSetProperties(); @@ -223,44 +531,39 @@ public class Jalview2XML } JSeq jseq; + Set calcIdSet = new HashSet(); - //SAVE SEQUENCES - int id = 0; - jalview.datamodel.SequenceI jds; + // SAVE SEQUENCES + String id = ""; + jalview.datamodel.SequenceI jds, jdatasq; for (int i = 0; i < jal.getHeight(); i++) { jds = jal.getSequenceAt(i); - id = jds.hashCode(); + jdatasq = jds.getDatasetSequence() == null ? jds : jds + .getDatasetSequence(); + id = seqHash(jds); - if (seqRefIds.get(id + "") != null) + if (seqRefIds.get(id) != null) { - + // This happens for two reasons: 1. multiple views are being serialised. + // 2. the hashCode has collided with another sequence's code. This DOES + // HAPPEN! (PF00072.15.stk does this) + // JBPNote: Uncomment to debug writing out of files that do not read + // back in due to ArrayOutOfBoundExceptions. + // System.err.println("vamsasSeq backref: "+id+""); + // System.err.println(jds.getName()+" + // "+jds.getStart()+"-"+jds.getEnd()+" "+jds.getSequenceAsString()); + // System.err.println("Hashcode: "+seqHash(jds)); + // SequenceI rsq = (SequenceI) seqRefIds.get(id + ""); + // System.err.println(rsq.getName()+" + // "+rsq.getStart()+"-"+rsq.getEnd()+" "+rsq.getSequenceAsString()); + // System.err.println("Hashcode: "+seqHash(rsq)); } else { - vamsasSeq = new Sequence(); - vamsasSeq.setId(id + ""); - vamsasSeq.setName(jds.getName()); - vamsasSeq.setSequence(jds.getSequenceAsString()); - vamsasSeq.setDescription(jds.getDescription()); - - if (jds.getDatasetSequence().getDBRef() != null) - { - jalview.datamodel.DBRefEntry[] dbrefs = - jds.getDatasetSequence().getDBRef(); - - for (int d = 0; d < dbrefs.length; d++) - { - DBRef dbref = new DBRef(); - dbref.setSource(dbrefs[d].getSource()); - dbref.setVersion(dbrefs[d].getVersion()); - dbref.setAccessionId(dbrefs[d].getAccessionId()); - vamsasSeq.addDBRef(dbref); - } - } - + vamsasSeq = createVamsasSequence(id, jds); vamsasSet.addSequence(vamsasSeq); - seqRefIds.put(id + "", jal.getSequenceAt(i)); + seqRefIds.put(id, jds); } jseq = new JSeq(); @@ -268,36 +571,36 @@ public class Jalview2XML jseq.setEnd(jds.getEnd()); jseq.setColour(av.getSequenceColour(jds).getRGB()); - jseq.setId(id); - - if (av.hasHiddenRows) + jseq.setId(id); // jseq id should be a string not a number + if (!storeDS) { - jseq.setHidden(av.alignment.getHiddenSequences().isHidden(jds)); - - if (av.hiddenRepSequences != null - && av.hiddenRepSequences.containsKey(jal.getSequenceAt(i))) + // Store any sequences this sequence represents + if (av.hasHiddenRows()) { - jalview.datamodel.SequenceI[] reps = - ( (jalview.datamodel.SequenceGroup) - av.hiddenRepSequences.get( - jal.getSequenceAt(i))).getSequencesInOrder(jal); + jseq.setHidden(av.getAlignment().getHiddenSequences() + .isHidden(jds)); - for (int h = 0; h < reps.length; h++) + if (av.isHiddenRepSequence(jal.getSequenceAt(i))) { - if (reps[h] != jal.getSequenceAt(i)) + jalview.datamodel.SequenceI[] reps = av + .getRepresentedSequences(jal.getSequenceAt(i)) + .getSequencesInOrder(jal); + + for (int h = 0; h < reps.length; h++) { - jseq.addHiddenSequences( - jal.findIndex(reps[h]) - ); + if (reps[h] != jal.getSequenceAt(i)) + { + jseq.addHiddenSequences(jal.findIndex(reps[h])); + } } } } } - if (jds.getDatasetSequence().getSequenceFeatures() != null) + if (jdatasq.getSequenceFeatures() != null) { - jalview.datamodel.SequenceFeature[] sf - = jds.getDatasetSequence().getSequenceFeatures(); + jalview.datamodel.SequenceFeature[] sf = jdatasq + .getSequenceFeatures(); int index = 0; while (index < sf.length) { @@ -328,8 +631,7 @@ public class Jalview2XML key = keys.nextElement().toString(); OtherData keyValue = new OtherData(); keyValue.setKey(key); - keyValue.setValue( - sf[index].otherDetails.get(key).toString()); + keyValue.setValue(sf[index].otherDetails.get(key).toString()); features.addOtherData(keyValue); } } @@ -339,56 +641,101 @@ public class Jalview2XML } } - if (jds.getDatasetSequence().getPDBId() != null) + if (jdatasq.getPDBId() != null) { - Enumeration en = jds.getDatasetSequence().getPDBId().elements(); + Enumeration en = jdatasq.getPDBId().elements(); while (en.hasMoreElements()) { Pdbids pdb = new Pdbids(); - jalview.datamodel.PDBEntry entry - = (jalview.datamodel.PDBEntry) en.nextElement(); + jalview.datamodel.PDBEntry entry = (jalview.datamodel.PDBEntry) en + .nextElement(); pdb.setId(entry.getId()); pdb.setType(entry.getType()); - + // + // store any JMol views associated with this seqeunce + // this section copes with duplicate entries in the project, so a + // dataset only view *should* be coped with sensibly AppJmol jmol; - //This must have been loaded, is it still visible? + // This must have been loaded, is it still visible? JInternalFrame[] frames = Desktop.desktop.getAllFrames(); + String matchedFile = null; for (int f = frames.length - 1; f > -1; f--) { if (frames[f] instanceof AppJmol) { jmol = (AppJmol) frames[f]; - if (!jmol.pdbentry.getId().equals(entry.getId())) - continue; - - - StructureState state = new StructureState(); - state.setVisible(true); - state.setXpos(jmol.getX()); - state.setYpos(jmol.getY()); - state.setWidth(jmol.getWidth()); - state.setHeight(jmol.getHeight()); - - String statestring = jmol.viewer.getStateInfo(); - if(state!=null) - { - state.setContent(statestring.replaceAll("\n", "")); - } - for (int s = 0; s < jmol.sequence.length; s++) + for (int peid = 0; peid < jmol.jmb.pdbentry.length; peid++) { - if (jal.findIndex(jmol.sequence[s]) > -1) + if (!jmol.jmb.pdbentry[peid].getId().equals(entry.getId()) + && !(entry.getId().length() > 4 && entry + .getId() + .toLowerCase() + .startsWith( + jmol.jmb.pdbentry[peid].getId() + .toLowerCase()))) + continue; + if (matchedFile == null) + { + matchedFile = jmol.jmb.pdbentry[peid].getFile(); + } + else if (!matchedFile.equals(jmol.jmb.pdbentry[peid] + .getFile())) + { + Cache.log + .warn("Probably lost some PDB-Sequence mappings for this structure file (which apparently has same PDB Entry code): " + + jmol.jmb.pdbentry[peid].getFile()); + ; // record the + } + // file so we + // can get at it if the ID + // match is ambiguous (e.g. + // 1QIP==1qipA) + String statestring = jmol.jmb.viewer.getStateInfo(); + + for (int smap = 0; smap < jmol.jmb.sequence[peid].length; smap++) { - pdb.addStructureState(state); + // if (jal.findIndex(jmol.jmb.sequence[peid][smap]) > -1) + if (jds == jmol.jmb.sequence[peid][smap]) + { + StructureState state = new StructureState(); + state.setVisible(true); + state.setXpos(jmol.getX()); + state.setYpos(jmol.getY()); + state.setWidth(jmol.getWidth()); + state.setHeight(jmol.getHeight()); + state.setViewId(jmol.getViewId()); + state.setAlignwithAlignPanel(jmol.isUsedforaligment(ap)); + state.setColourwithAlignPanel(jmol + .isUsedforcolourby(ap)); + state.setColourByJmol(jmol.isColouredByJmol()); + if (!jmolViewIds.contains(state.getViewId())) + { + // Make sure we only store a Jmol state once in each XML + // document. + jmolViewIds.addElement(state.getViewId()); + state.setContent(statestring.replaceAll("\n", "")); + } + else + { + state.setContent("# duplicate state"); + } + pdb.addStructureState(state); + } + } } } } - - if (entry.getFile() != null) + if (matchedFile != null || entry.getFile() != null) { - pdb.setFile(entry.getFile()); + if (entry.getFile() != null) + { + // use entry's file + matchedFile = entry.getFile(); + } + pdb.setFile(matchedFile); // entry.getFile()); if (pdbfiles == null) { pdbfiles = new Vector(); @@ -399,23 +746,23 @@ public class Jalview2XML pdbfiles.addElement(entry.getId()); try { - File file = new File(entry.getFile()); + File file = new File(matchedFile); if (file.exists() && jout != null) { - byte[] data = new byte[ (int) file.length()]; + byte[] data = new byte[(int) file.length()]; jout.putNextEntry(new JarEntry(entry.getId())); - DataInputStream dis = new DataInputStream(new - FileInputStream(file)); + DataInputStream dis = new DataInputStream( + new FileInputStream(file)); dis.readFully(data); DataOutputStream dout = new DataOutputStream(jout); dout.write(data, 0, data.length); + dout.flush(); jout.closeEntry(); } - } - catch (Exception ex) + } catch (Exception ex) { - ex.printStackTrace(); + ex.printStackTrace(); } } @@ -444,14 +791,51 @@ public class Jalview2XML jms.addJSeq(jseq); } - if (av.hasHiddenRows) + if (!storeDS && av.hasHiddenRows()) { - jal = av.alignment; + jal = av.getAlignment(); + } + // SAVE MAPPINGS + if (jal.getCodonFrames() != null && jal.getCodonFrames().length > 0) + { + jalview.datamodel.AlignedCodonFrame[] jac = jal.getCodonFrames(); + for (int i = 0; i < jac.length; i++) + { + AlcodonFrame alc = new AlcodonFrame(); + vamsasSet.addAlcodonFrame(alc); + for (int p = 0; p < jac[i].aaWidth; p++) + { + Alcodon cmap = new Alcodon(); + if (jac[i].codons[p] != null) + { + // Null codons indicate a gapped column in the translated peptide + // alignment. + cmap.setPos1(jac[i].codons[p][0]); + cmap.setPos2(jac[i].codons[p][1]); + cmap.setPos3(jac[i].codons[p][2]); + } + alc.addAlcodon(cmap); + } + if (jac[i].getProtMappings() != null + && jac[i].getProtMappings().length > 0) + { + SequenceI[] dnas = jac[i].getdnaSeqs(); + jalview.datamodel.Mapping[] pmaps = jac[i].getProtMappings(); + for (int m = 0; m < pmaps.length; m++) + { + AlcodMap alcmap = new AlcodMap(); + alcmap.setDnasq(seqHash(dnas[m])); + alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null, + false)); + alc.addAlcodMap(alcmap); + } + } + } } - //SAVE TREES - /////////////////////////////////// - if (av.currentTree != null) + // SAVE TREES + // ///////////////////////////////// + if (!storeDS && av.currentTree != null) { // FIND ANY ASSOCIATED TREES // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT @@ -465,11 +849,11 @@ public class Jalview2XML { TreePanel tp = (TreePanel) frames[t]; - if (tp.treeCanvas.av.alignment == jal) + if (tp.treeCanvas.av.getAlignment() == jal) { Tree tree = new Tree(); tree.setTitle(tp.getTitle()); - tree.setCurrentTree( (av.currentTree == tp.getTree())); + tree.setCurrentTree((av.currentTree == tp.getTree())); tree.setNewick(tp.getTree().toString()); tree.setThreshold(tp.treeCanvas.threshold); @@ -486,127 +870,59 @@ public class Jalview2XML tree.setWidth(tp.getWidth()); tree.setXpos(tp.getX()); tree.setYpos(tp.getY()); - + tree.setId(makeHashCode(tp, null)); jms.addTree(tree); } } } } } - - //SAVE ANNOTATIONS - if (jal.getAlignmentAnnotation() != null) + // SAVE ANNOTATIONS + /** + * store forward refs from an annotationRow to any groups + */ + IdentityHashMap groupRefs = new IdentityHashMap(); + if (storeDS) { - jalview.datamodel.AlignmentAnnotation[] aa = jal.getAlignmentAnnotation(); - - for (int i = 0; i < aa.length; i++) + for (SequenceI sq : jal.getSequences()) { - Annotation an = new Annotation(); - - if (aa[i].annotationId != null) - { - annotationIds.put(aa[i].annotationId, aa[i]); - } - - an.setId(aa[i].annotationId); - - if (aa[i] == av.quality || - aa[i] == av.conservation || - aa[i] == av.consensus) - { - an.setLabel(aa[i].label); - an.setGraph(true); - vamsasSet.addAnnotation(an); - continue; - } - - an.setDescription(aa[i].description); - - if (aa[i].sequenceRef != null) - { - an.setSequenceRef(aa[i].sequenceRef.getName()); - } - - if (aa[i].graph > 0) - { - an.setGraph(true); - an.setGraphType(aa[i].graph); - an.setGraphGroup(aa[i].graphGroup); - if (aa[i].getThreshold() != null) - { - ThresholdLine line = new ThresholdLine(); - line.setLabel(aa[i].getThreshold().label); - line.setValue(aa[i].getThreshold().value); - line.setColour(aa[i].getThreshold().colour.getRGB()); - an.setThresholdLine(line); - } - } - else - { - an.setGraph(false); - } - - an.setLabel(aa[i].label); - if (aa[i].hasScore()) + // Store annotation on dataset sequences only + jalview.datamodel.AlignmentAnnotation[] aa = sq.getAnnotation(); + if (aa != null && aa.length > 0) { - an.setScore(aa[i].getScore()); + storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS, + vamsasSet); } - AnnotationElement ae; - if (aa[i].annotations!=null) - { - an.setScoreOnly(false); - for (int a = 0; a < aa[i].annotations.length; a++) - { - if ((aa[i] == null) || (aa[i].annotations[a] == null)) - { - continue; - } - - ae = new AnnotationElement(); - if (aa[i].annotations[a].description != null) - ae.setDescription(aa[i].annotations[a].description); - if(aa[i].annotations[a].displayCharacter!=null) - ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter); - - if (!Float.isNaN(aa[i].annotations[a].value)) - ae.setValue(aa[i].annotations[a].value); - - ae.setPosition(a); - if (aa[i].annotations[a].secondaryStructure != ' ' - && aa[i].annotations[a].secondaryStructure != '\0') - ae.setSecondaryStructure(aa[i].annotations[a].secondaryStructure - + ""); - - if (aa[i].annotations[a].colour!=null - && aa[i].annotations[a].colour != java.awt.Color.black) - { - ae.setColour(aa[i].annotations[a].colour.getRGB()); - } - - an.addAnnotationElement(ae); - } - } else { - an.setScoreOnly(true); - } - vamsasSet.addAnnotation(an); } } - - //SAVE GROUPS + else + { + if (jal.getAlignmentAnnotation() != null) + { + // Store the annotation shown on the alignment. + jalview.datamodel.AlignmentAnnotation[] aa = jal + .getAlignmentAnnotation(); + storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS, + vamsasSet); + } + } + // SAVE GROUPS if (jal.getGroups() != null) { JGroup[] groups = new JGroup[jal.getGroups().size()]; - - for (int i = 0; i < groups.length; i++) + int i = -1; + for (jalview.datamodel.SequenceGroup sg : jal.getGroups()) { - groups[i] = new JGroup(); + groups[++i] = new JGroup(); - jalview.datamodel.SequenceGroup sg = (jalview.datamodel.SequenceGroup) - jal.getGroups() - .elementAt(i); groups[i].setStart(sg.getStartRes()); groups[i].setEnd(sg.getEndRes()); groups[i].setName(sg.getName()); + if (groupRefs.containsKey(sg)) + { + // group has references so set it's ID field + groups[i].setId(groupRefs.get(sg).toString()); + } if (sg.cs != null) { if (sg.cs.conservationApplied()) @@ -615,32 +931,30 @@ public class Jalview2XML if (sg.cs instanceof jalview.schemes.UserColourScheme) { - groups[i].setColour(SetUserColourScheme(sg.cs, - userColours, - jms)); + groups[i].setColour(SetUserColourScheme(sg.cs, userColours, + jms)); } else { - groups[i].setColour(ColourSchemeProperty.getColourName(sg. - cs)); + groups[i] + .setColour(ColourSchemeProperty.getColourName(sg.cs)); } } else if (sg.cs instanceof jalview.schemes.AnnotationColourGradient) { - groups[i].setColour( - ColourSchemeProperty.getColourName( - ( (jalview.schemes.AnnotationColourGradient) sg.cs). - getBaseColour())); + groups[i].setColour("AnnotationColourGradient"); + groups[i].setAnnotationColours(constructAnnotationColours( + (jalview.schemes.AnnotationColourGradient) sg.cs, + userColours, jms)); } else if (sg.cs instanceof jalview.schemes.UserColourScheme) { - groups[i].setColour(SetUserColourScheme(sg.cs, userColours, - jms)); + groups[i] + .setColour(SetUserColourScheme(sg.cs, userColours, jms)); } else { - groups[i].setColour(ColourSchemeProperty.getColourName( - sg.cs)); + groups[i].setColour(ColourSchemeProperty.getColourName(sg.cs)); } groups[i].setPidThreshold(sg.cs.getThreshold()); @@ -653,256 +967,742 @@ public class Jalview2XML groups[i].setTextCol1(sg.textColour.getRGB()); groups[i].setTextCol2(sg.textColour2.getRGB()); groups[i].setTextColThreshold(sg.thresholdTextColour); - + groups[i].setShowUnconserved(sg.getShowNonconserved()); + groups[i].setIgnoreGapsinConsensus(sg.getIgnoreGapsConsensus()); + groups[i].setShowConsensusHistogram(sg.isShowConsensusHistogram()); + groups[i].setShowSequenceLogo(sg.isShowSequenceLogo()); + groups[i].setNormaliseSequenceLogo(sg.isNormaliseSequenceLogo()); for (int s = 0; s < sg.getSize(); s++) { - jalview.datamodel.Sequence seq = - (jalview.datamodel.Sequence) sg.getSequenceAt(s); - groups[i].addSeq(seq.hashCode()); + jalview.datamodel.Sequence seq = (jalview.datamodel.Sequence) sg + .getSequenceAt(s); + groups[i].addSeq(seqHash(seq)); } } jms.setJGroup(groups); } + if (!storeDS) + { + // /////////SAVE VIEWPORT + Viewport view = new Viewport(); + view.setTitle(ap.alignFrame.getTitle()); + view.setSequenceSetId(makeHashCode(av.getSequenceSetId(), + av.getSequenceSetId())); + view.setId(av.getViewId()); + view.setViewName(av.viewName); + view.setGatheredViews(av.gatherViewsHere); + + if (ap.av.explodedPosition != null) + { + view.setXpos(av.explodedPosition.x); + view.setYpos(av.explodedPosition.y); + view.setWidth(av.explodedPosition.width); + view.setHeight(av.explodedPosition.height); + } + else + { + view.setXpos(ap.alignFrame.getBounds().x); + view.setYpos(ap.alignFrame.getBounds().y); + view.setWidth(ap.alignFrame.getBounds().width); + view.setHeight(ap.alignFrame.getBounds().height); + } - ///////////SAVE VIEWPORT - Viewport view = new Viewport(); - view.setTitle(ap.alignFrame.getTitle()); - view.setSequenceSetId(av.getSequenceSetId()); - view.setViewName(av.viewName); - view.setGatheredViews(av.gatherViewsHere); + view.setStartRes(av.startRes); + view.setStartSeq(av.startSeq); + if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme) + { + view.setBgColour(SetUserColourScheme(av.getGlobalColourScheme(), + userColours, jms)); + } + else if (av.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient) + { + AnnotationColours ac = constructAnnotationColours( + (jalview.schemes.AnnotationColourGradient) av + .getGlobalColourScheme(), + userColours, jms); + view.setAnnotationColours(ac); + view.setBgColour("AnnotationColourGradient"); + } + else + { + view.setBgColour(ColourSchemeProperty.getColourName(av + .getGlobalColourScheme())); + } - if (ap.av.explodedPosition != null) - { - view.setXpos(av.explodedPosition.x); - view.setYpos(av.explodedPosition.y); - view.setWidth(av.explodedPosition.width); - view.setHeight(av.explodedPosition.height); - } - else - { - view.setXpos(ap.alignFrame.getBounds().x); - view.setYpos(ap.alignFrame.getBounds().y); - view.setWidth(ap.alignFrame.getBounds().width); - view.setHeight(ap.alignFrame.getBounds().height); - } + ColourSchemeI cs = av.getGlobalColourScheme(); + + if (cs != null) + { + if (cs.conservationApplied()) + { + view.setConsThreshold(cs.getConservationInc()); + if (cs instanceof jalview.schemes.UserColourScheme) + { + view.setBgColour(SetUserColourScheme(cs, userColours, jms)); + } + } - view.setStartRes(av.startRes); - view.setStartSeq(av.startSeq); + if (cs instanceof ResidueColourScheme) + { + view.setPidThreshold(cs.getThreshold()); + } + } - if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme) - { - view.setBgColour(SetUserColourScheme(av.getGlobalColourScheme(), - userColours, jms)); - } - else if (av.getGlobalColourScheme() instanceof jalview.schemes. - AnnotationColourGradient) - { - jalview.schemes.AnnotationColourGradient acg - = (jalview.schemes.AnnotationColourGradient) av.getGlobalColourScheme(); + view.setConservationSelected(av.getConservationSelected()); + view.setPidSelected(av.getAbovePIDThreshold()); + view.setFontName(av.font.getName()); + view.setFontSize(av.font.getSize()); + view.setFontStyle(av.font.getStyle()); + view.setRenderGaps(av.renderGaps); + view.setShowAnnotation(av.getShowAnnotation()); + view.setShowBoxes(av.getShowBoxes()); + view.setShowColourText(av.getColourText()); + view.setShowFullId(av.getShowJVSuffix()); + view.setRightAlignIds(av.rightAlignIds); + view.setShowSequenceFeatures(av.showSequenceFeatures); + view.setShowText(av.getShowText()); + view.setShowUnconserved(av.getShowUnconserved()); + view.setWrapAlignment(av.getWrapAlignment()); + view.setTextCol1(av.textColour.getRGB()); + view.setTextCol2(av.textColour2.getRGB()); + view.setTextColThreshold(av.thresholdTextColour); + view.setShowConsensusHistogram(av.isShowConsensusHistogram()); + view.setShowSequenceLogo(av.isShowSequenceLogo()); + view.setNormaliseSequenceLogo(av.isNormaliseSequenceLogo()); + view.setShowGroupConsensus(av.isShowGroupConsensus()); + view.setShowGroupConservation(av.isShowGroupConservation()); + view.setShowNPfeatureTooltip(av.isShowNpFeats()); + view.setShowDbRefTooltip(av.isShowDbRefs()); + view.setFollowHighlight(av.followHighlight); + view.setFollowSelection(av.followSelection); + view.setIgnoreGapsinConsensus(av.getIgnoreGapsConsensus()); + if (av.featuresDisplayed != null) + { + jalview.schemabinding.version2.FeatureSettings fs = new jalview.schemabinding.version2.FeatureSettings(); + + String[] renderOrder = ap.seqPanel.seqCanvas.getFeatureRenderer().renderOrder; + + Vector settingsAdded = new Vector(); + Object gstyle = null; + GraduatedColor gcol = null; + if (renderOrder != null) + { + for (int ro = 0; ro < renderOrder.length; ro++) + { + gstyle = ap.seqPanel.seqCanvas.getFeatureRenderer() + .getFeatureStyle(renderOrder[ro]); + Setting setting = new Setting(); + setting.setType(renderOrder[ro]); + if (gstyle instanceof GraduatedColor) + { + gcol = (GraduatedColor) gstyle; + setting.setColour(gcol.getMaxColor().getRGB()); + setting.setMincolour(gcol.getMinColor().getRGB()); + setting.setMin(gcol.getMin()); + setting.setMax(gcol.getMax()); + setting.setColourByLabel(gcol.isColourByLabel()); + setting.setAutoScale(gcol.isAutoScale()); + setting.setThreshold(gcol.getThresh()); + setting.setThreshstate(gcol.getThreshType()); + } + else + { + setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer() + .getColour(renderOrder[ro]).getRGB()); + } + + setting.setDisplay(av.featuresDisplayed + .containsKey(renderOrder[ro])); + float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer() + .getOrder(renderOrder[ro]); + if (rorder > -1) + { + setting.setOrder(rorder); + } + fs.addSetting(setting); + settingsAdded.addElement(renderOrder[ro]); + } + } + + // Make sure we save none displayed feature settings + Iterator en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureColours + .keySet().iterator(); + while (en.hasNext()) + { + String key = en.next().toString(); + if (settingsAdded.contains(key)) + { + continue; + } + + Setting setting = new Setting(); + setting.setType(key); + setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer() + .getColour(key).getRGB()); + + setting.setDisplay(false); + float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer() + .getOrder(key); + if (rorder > -1) + { + setting.setOrder(rorder); + } + fs.addSetting(setting); + settingsAdded.addElement(key); + } + en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups + .keySet().iterator(); + Vector groupsAdded = new Vector(); + while (en.hasNext()) + { + String grp = en.next().toString(); + if (groupsAdded.contains(grp)) + { + continue; + } + Group g = new Group(); + g.setName(grp); + g.setDisplay(((Boolean) ap.seqPanel.seqCanvas + .getFeatureRenderer().featureGroups.get(grp)) + .booleanValue()); + fs.addGroup(g); + groupsAdded.addElement(grp); + } + jms.setFeatureSettings(fs); + + } - AnnotationColours ac = new AnnotationColours(); - ac.setAboveThreshold(acg.getAboveThreshold()); - ac.setThreshold(acg.getAnnotationThreshold()); - ac.setAnnotation(acg.getAnnotation()); - if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme) + if (av.hasHiddenColumns()) { - ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(), - userColours, jms)); + if (av.getColumnSelection() == null + || av.getColumnSelection().getHiddenColumns() == null) + { + warn("REPORT BUG: avoided null columnselection bug (DMAM reported). Please contact Jim about this."); + } + else + { + for (int c = 0; c < av.getColumnSelection().getHiddenColumns() + .size(); c++) + { + int[] region = (int[]) av.getColumnSelection() + .getHiddenColumns().elementAt(c); + HiddenColumns hc = new HiddenColumns(); + hc.setStart(region[0]); + hc.setEnd(region[1]); + view.addHiddenColumns(hc); + } + } } - else + if (calcIdSet.size() > 0) + { + for (String calcId : calcIdSet) + { + if (calcId.trim().length() > 0) + { + CalcIdParam cidp = createCalcIdParam(calcId, av); + // Some calcIds have no parameters. + if (cidp != null) + { + view.addCalcIdParam(cidp); + } + } + } + } + + jms.addViewport(view); + } + object.setJalviewModelSequence(jms); + object.getVamsasModel().addSequenceSet(vamsasSet); + + if (jout != null && fileName != null) + { + // We may not want to write the object to disk, + // eg we can copy the alignViewport to a new view object + // using save and then load + try + { + JarEntry entry = new JarEntry(fileName); + jout.putNextEntry(entry); + PrintWriter pout = new PrintWriter(new OutputStreamWriter(jout, + "UTF-8")); + org.exolab.castor.xml.Marshaller marshaller = new org.exolab.castor.xml.Marshaller( + pout); + marshaller.marshal(object); + pout.flush(); + jout.closeEntry(); + } catch (Exception ex) { - ac.setColourScheme(ColourSchemeProperty.getColourName(acg.getBaseColour())); + // TODO: raise error in GUI if marshalling failed. + ex.printStackTrace(); } + } + return object; + } - ac.setMaxColour(acg.getMaxColour().getRGB()); - ac.setMinColour(acg.getMinColour().getRGB()); - view.setAnnotationColours(ac); - view.setBgColour("AnnotationColourGradient"); + private AnnotationColours constructAnnotationColours( + AnnotationColourGradient acg, Vector userColours, + JalviewModelSequence jms) + { + AnnotationColours ac = new AnnotationColours(); + ac.setAboveThreshold(acg.getAboveThreshold()); + ac.setThreshold(acg.getAnnotationThreshold()); + ac.setAnnotation(acg.getAnnotation()); + if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme) + { + ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(), + userColours, jms)); } else { - view.setBgColour(ColourSchemeProperty.getColourName( - av.getGlobalColourScheme())); + ac.setColourScheme(ColourSchemeProperty.getColourName(acg + .getBaseColour())); } - ColourSchemeI cs = av.getGlobalColourScheme(); + ac.setMaxColour(acg.getMaxColour().getRGB()); + ac.setMinColour(acg.getMinColour().getRGB()); + ac.setPerSequence(acg.isSeqAssociated()); + ac.setPredefinedColours(acg.isPredefinedColours()); + return ac; + } + + private void storeAlignmentAnnotation(AlignmentAnnotation[] aa, + IdentityHashMap groupRefs, AlignmentViewport av, + Set calcIdSet, boolean storeDS, SequenceSet vamsasSet) + { - if (cs != null) + for (int i = 0; i < aa.length; i++) { - if (cs.conservationApplied()) + Annotation an = new Annotation(); + + if (aa[i].annotationId != null) + { + annotationIds.put(aa[i].annotationId, aa[i]); + } + + an.setId(aa[i].annotationId); + + an.setVisible(aa[i].visible); + + an.setDescription(aa[i].description); + + if (aa[i].sequenceRef != null) + { + // TODO later annotation sequenceRef should be the XML ID of the + // sequence rather than its display name + an.setSequenceRef(aa[i].sequenceRef.getName()); + } + if (aa[i].groupRef != null) { - view.setConsThreshold(cs.getConservationInc()); - if (cs instanceof jalview.schemes.UserColourScheme) + Object groupIdr = groupRefs.get(aa[i].groupRef); + if (groupIdr == null) { - view.setBgColour(SetUserColourScheme(cs, userColours, jms)); + // make a locally unique String + groupRefs.put(aa[i].groupRef, + groupIdr = ("" + System.currentTimeMillis() + + aa[i].groupRef.getName() + groupRefs.size())); } + an.setGroupRef(groupIdr.toString()); } - if (cs instanceof ResidueColourScheme) + // store all visualization attributes for annotation + an.setGraphHeight(aa[i].graphHeight); + an.setCentreColLabels(aa[i].centreColLabels); + an.setScaleColLabels(aa[i].scaleColLabel); + an.setShowAllColLabels(aa[i].showAllColLabels); + an.setBelowAlignment(aa[i].belowAlignment); + + if (aa[i].graph > 0) { - view.setPidThreshold(cs.getThreshold()); + an.setGraph(true); + an.setGraphType(aa[i].graph); + an.setGraphGroup(aa[i].graphGroup); + if (aa[i].getThreshold() != null) + { + ThresholdLine line = new ThresholdLine(); + line.setLabel(aa[i].getThreshold().label); + line.setValue(aa[i].getThreshold().value); + line.setColour(aa[i].getThreshold().colour.getRGB()); + an.setThresholdLine(line); + } + } + else + { + an.setGraph(false); } - } - view.setConservationSelected(av.getConservationSelected()); - view.setPidSelected(av.getAbovePIDThreshold()); - view.setFontName(av.font.getName()); - view.setFontSize(av.font.getSize()); - view.setFontStyle(av.font.getStyle()); - view.setRenderGaps(av.renderGaps); - view.setShowAnnotation(av.getShowAnnotation()); - view.setShowBoxes(av.getShowBoxes()); - view.setShowColourText(av.getColourText()); - view.setShowFullId(av.getShowJVSuffix()); - view.setRightAlignIds(av.rightAlignIds); - view.setShowSequenceFeatures(av.showSequenceFeatures); - view.setShowText(av.getShowText()); - view.setWrapAlignment(av.getWrapAlignment()); - view.setTextCol1(av.textColour.getRGB()); - view.setTextCol2(av.textColour2.getRGB()); - view.setTextColThreshold(av.thresholdTextColour); + an.setLabel(aa[i].label); - if (av.featuresDisplayed != null) - { - jalview.schemabinding.version2.FeatureSettings fs - = new jalview.schemabinding.version2.FeatureSettings(); + if (aa[i] == av.getAlignmentQualityAnnot() + || aa[i] == av.getAlignmentConservationAnnotation() + || aa[i] == av.getAlignmentConsensusAnnotation() + || aa[i].autoCalculated) + { + // new way of indicating autocalculated annotation - + an.setAutoCalculated(aa[i].autoCalculated); + } + if (aa[i].hasScore()) + { + an.setScore(aa[i].getScore()); + } - String[] renderOrder = - ap.seqPanel.seqCanvas.getFeatureRenderer().renderOrder; + if (aa[i].getCalcId() != null) + { + calcIdSet.add(aa[i].getCalcId()); + an.setCalcId(aa[i].getCalcId()); + } - Vector settingsAdded = new Vector(); - for (int ro = 0; ro < renderOrder.length; ro++) + AnnotationElement ae; + if (aa[i].annotations != null) { - Setting setting = new Setting(); - setting.setType(renderOrder[ro]); - setting.setColour( - ap.seqPanel.seqCanvas.getFeatureRenderer().getColour(renderOrder[ro]). - getRGB() - ); + an.setScoreOnly(false); + for (int a = 0; a < aa[i].annotations.length; a++) + { + if ((aa[i] == null) || (aa[i].annotations[a] == null)) + { + continue; + } - setting.setDisplay( - av.featuresDisplayed.containsKey(renderOrder[ro]) - ); - float rorder=ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(renderOrder[ro]); - if (rorder>-1) { - setting.setOrder(rorder); + ae = new AnnotationElement(); + if (aa[i].annotations[a].description != null) + ae.setDescription(aa[i].annotations[a].description); + if (aa[i].annotations[a].displayCharacter != null) + ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter); + + if (!Float.isNaN(aa[i].annotations[a].value)) + ae.setValue(aa[i].annotations[a].value); + + ae.setPosition(a); + if (aa[i].annotations[a].secondaryStructure != ' ' + && aa[i].annotations[a].secondaryStructure != '\0') + ae.setSecondaryStructure(aa[i].annotations[a].secondaryStructure + + ""); + + if (aa[i].annotations[a].colour != null + && aa[i].annotations[a].colour != java.awt.Color.black) + { + ae.setColour(aa[i].annotations[a].colour.getRGB()); + } + + an.addAnnotationElement(ae); + if (aa[i].autoCalculated) + { + // only write one non-null entry into the annotation row - + // sufficient to get the visualization attributes necessary to + // display data + continue; + } } - fs.addSetting(setting); - settingsAdded.addElement(renderOrder[ro]); } + else + { + an.setScoreOnly(true); + } + if (!storeDS || (storeDS && !aa[i].autoCalculated)) + { + // skip autocalculated annotation - these are only provided for + // alignments + vamsasSet.addAnnotation(an); + } + } - //Make sure we save none displayed feature settings - Enumeration en = - ap.seqPanel.seqCanvas.getFeatureRenderer().featureColours.keys(); - while (en.hasMoreElements()) + } + + private CalcIdParam createCalcIdParam(String calcId, AlignViewport av) + { + AutoCalcSetting settings = av.getCalcIdSettingsFor(calcId); + if (settings != null) + { + CalcIdParam vCalcIdParam = new CalcIdParam(); + vCalcIdParam.setCalcId(calcId); + vCalcIdParam.addServiceURL(settings.getServiceURI()); + // generic URI allowing a third party to resolve another instance of the + // service used for this calculation + for (String urls : settings.getServiceURLs()) { - String key = en.nextElement().toString(); - if (settingsAdded.contains(key)) + vCalcIdParam.addServiceURL(urls); + } + vCalcIdParam.setVersion("1.0"); + if (settings.getPreset() != null) + { + WsParamSetI setting = settings.getPreset(); + vCalcIdParam.setName(setting.getName()); + vCalcIdParam.setDescription(setting.getDescription()); + } + else + { + vCalcIdParam.setName(""); + vCalcIdParam.setDescription("Last used parameters"); + } + // need to be able to recover 1) settings 2) user-defined presets or + // recreate settings from preset 3) predefined settings provided by + // service - or settings that can be transferred (or discarded) + vCalcIdParam.setParameters(settings.getWsParamFile().replace("\n", + "|\\n|")); + vCalcIdParam.setAutoUpdate(settings.isAutoUpdate()); + // todo - decide if updateImmediately is needed for any projects. + + return vCalcIdParam; + } + return null; + } + + private boolean recoverCalcIdParam(CalcIdParam calcIdParam, + AlignViewport av) + { + if (calcIdParam.getVersion().equals("1.0")) + { + Jws2Instance service = Jws2Discoverer.getDiscoverer() + .getPreferredServiceFor(calcIdParam.getServiceURL()); + if (service != null) + { + WsParamSetI parmSet = null; + try { - continue; + parmSet = service.getParamStore().parseServiceParameterFile( + calcIdParam.getName(), calcIdParam.getDescription(), + calcIdParam.getServiceURL(), + calcIdParam.getParameters().replace("|\\n|", "\n")); + } catch (IOException x) + { + warn("Couldn't parse parameter data for " + + calcIdParam.getCalcId(), x); + return false; } - - Setting setting = new Setting(); - setting.setType(key); - setting.setColour( - ap.seqPanel.seqCanvas.getFeatureRenderer().getColour(key).getRGB() - ); - - setting.setDisplay(false); - float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer().getOrder(key); - if (rorder>-1) + List argList = null; + if (calcIdParam.getName().length() > 0) { - setting.setOrder(rorder); + parmSet = service.getParamStore() + .getPreset(calcIdParam.getName()); + if (parmSet != null) + { + // TODO : check we have a good match with settings in AACon - + // otherwise we'll need to create a new preset + } } - fs.addSetting(setting); - settingsAdded.addElement(key); - } - en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups.keys(); - Vector groupsAdded=new Vector(); - while (en.hasMoreElements()) - { - String grp = en.nextElement().toString(); - if (groupsAdded.contains(grp)) + else { - continue; + argList = parmSet.getArguments(); + parmSet = null; } - Group g = new Group(); - g.setName(grp); - g.setDisplay(((Boolean)ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups.get(grp)).booleanValue()); - fs.addGroup(g); - groupsAdded.addElement(grp); + AAConSettings settings = new AAConSettings( + calcIdParam.isAutoUpdate(), service, parmSet, argList); + av.setCalcIdSettingsFor(calcIdParam.getCalcId(), settings, + calcIdParam.isNeedsUpdate()); + return true; + } + else + { + warn("Cannot resolve a service for the parameters used in this project. Try configuring a JABAWS server."); + return false; } - jms.setFeatureSettings(fs); - } + throw new Error("Unsupported Version for calcIdparam " + + calcIdParam.toString()); + } + + /** + * External mapping between jalview objects and objects yielding a valid and + * unique object ID string. This is null for normal Jalview project IO, but + * non-null when a jalview project is being read or written as part of a + * vamsas session. + */ + IdentityHashMap jv2vobj = null; - if (av.hasHiddenColumns) + /** + * Construct a unique ID for jvobj using either existing bindings or if none + * exist, the result of the hashcode call for the object. + * + * @param jvobj + * jalview data object + * @return unique ID for referring to jvobj + */ + private String makeHashCode(Object jvobj, String altCode) + { + if (jv2vobj != null) { - for (int c = 0; c < av.getColumnSelection().getHiddenColumns().size(); c++) + Object id = jv2vobj.get(jvobj); + if (id != null) + { + return id.toString(); + } + // check string ID mappings + if (jvids2vobj != null && jvobj instanceof String) + { + id = jvids2vobj.get(jvobj); + } + if (id != null) { - int[] region = (int[]) av.getColumnSelection().getHiddenColumns(). - elementAt(c); - HiddenColumns hc = new HiddenColumns(); - hc.setStart(region[0]); - hc.setEnd(region[1]); - view.addHiddenColumns(hc); + return id.toString(); } + // give up and warn that something has gone wrong + warn("Cannot find ID for object in external mapping : " + jvobj); + } + return altCode; + } + + /** + * return local jalview object mapped to ID, if it exists + * + * @param idcode + * (may be null) + * @return null or object bound to idcode + */ + private Object retrieveExistingObj(String idcode) + { + if (idcode != null && vobj2jv != null) + { + return vobj2jv.get(idcode); } + return null; + } - jms.addViewport(view); + /** + * binding from ID strings from external mapping table to jalview data model + * objects. + */ + private Hashtable vobj2jv; - object.setJalviewModelSequence(jms); - object.getVamsasModel().addSequenceSet(vamsasSet); + private Sequence createVamsasSequence(String id, SequenceI jds) + { + return createVamsasSequence(true, id, jds, null); + } - if (out != null) + private Sequence createVamsasSequence(boolean recurse, String id, + SequenceI jds, SequenceI parentseq) + { + Sequence vamsasSeq = new Sequence(); + vamsasSeq.setId(id); + vamsasSeq.setName(jds.getName()); + vamsasSeq.setSequence(jds.getSequenceAsString()); + vamsasSeq.setDescription(jds.getDescription()); + jalview.datamodel.DBRefEntry[] dbrefs = null; + if (jds.getDatasetSequence() != null) { - //We may not want to right the object to disk, - //eg we can copy the alignViewport to a new view object - //using save and then load - try + vamsasSeq.setDsseqid(seqHash(jds.getDatasetSequence())); + if (jds.getDatasetSequence().getDBRef() != null) + { + dbrefs = jds.getDatasetSequence().getDBRef(); + } + } + else + { + vamsasSeq.setDsseqid(id); // so we can tell which sequences really are + // dataset sequences only + dbrefs = jds.getDBRef(); + } + if (dbrefs != null) + { + for (int d = 0; d < dbrefs.length; d++) { - if (!fileName.endsWith(".xml")) + DBRef dbref = new DBRef(); + dbref.setSource(dbrefs[d].getSource()); + dbref.setVersion(dbrefs[d].getVersion()); + dbref.setAccessionId(dbrefs[d].getAccessionId()); + if (dbrefs[d].hasMap()) { - fileName = fileName + ".xml"; + Mapping mp = createVamsasMapping(dbrefs[d].getMap(), parentseq, + jds, recurse); + dbref.setMapping(mp); } + vamsasSeq.addDBRef(dbref); + } + } + return vamsasSeq; + } - JarEntry entry = new JarEntry(fileName); - jout.putNextEntry(entry); + private Mapping createVamsasMapping(jalview.datamodel.Mapping jmp, + SequenceI parentseq, SequenceI jds, boolean recurse) + { + Mapping mp = null; + if (jmp.getMap() != null) + { + mp = new Mapping(); - object.marshal(out); + jalview.util.MapList mlst = jmp.getMap(); + int r[] = mlst.getFromRanges(); + for (int s = 0; s < r.length; s += 2) + { + MapListFrom mfrom = new MapListFrom(); + mfrom.setStart(r[s]); + mfrom.setEnd(r[s + 1]); + mp.addMapListFrom(mfrom); } - catch (Exception ex) + r = mlst.getToRanges(); + for (int s = 0; s < r.length; s += 2) { - ex.printStackTrace(); + MapListTo mto = new MapListTo(); + mto.setStart(r[s]); + mto.setEnd(r[s + 1]); + mp.addMapListTo(mto); + } + mp.setMapFromUnit(mlst.getFromRatio()); + mp.setMapToUnit(mlst.getToRatio()); + if (jmp.getTo() != null) + { + MappingChoice mpc = new MappingChoice(); + if (recurse + && (parentseq != jmp.getTo() || parentseq + .getDatasetSequence() != jmp.getTo())) + { + mpc.setSequence(createVamsasSequence(false, seqHash(jmp.getTo()), + jmp.getTo(), jds)); + } + else + { + String jmpid = ""; + SequenceI ps = null; + if (parentseq != jmp.getTo() + && parentseq.getDatasetSequence() != jmp.getTo()) + { + // chaining dbref rather than a handshaking one + jmpid = seqHash(ps = jmp.getTo()); + } + else + { + jmpid = seqHash(ps = parentseq); + } + mpc.setDseqFor(jmpid); + if (!seqRefIds.containsKey(mpc.getDseqFor())) + { + jalview.bin.Cache.log.debug("creatign new DseqFor ID"); + seqRefIds.put(mpc.getDseqFor(), ps); + } + else + { + jalview.bin.Cache.log.debug("reusing DseqFor ID"); + } + } + mp.setMappingChoice(mpc); } } - return object; + return mp; } String SetUserColourScheme(jalview.schemes.ColourSchemeI cs, - Vector userColours, JalviewModelSequence jms) + Vector userColours, JalviewModelSequence jms) { String id = null; - jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) - cs; - + jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs; + boolean newucs = false; if (!userColours.contains(ucs)) { userColours.add(ucs); - + newucs = true; + } + id = "ucs" + userColours.indexOf(ucs); + if (newucs) + { + // actually create the scheme's entry in the XML model java.awt.Color[] colours = ucs.getColours(); - jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding. - version2.UserColours(); - jalview.schemabinding.version2.UserColourScheme jbucs = new jalview. - schemabinding.version2.UserColourScheme(); + jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding.version2.UserColours(); + jalview.schemabinding.version2.UserColourScheme jbucs = new jalview.schemabinding.version2.UserColourScheme(); for (int i = 0; i < colours.length; i++) { - jalview.schemabinding.version2.Colour col = new jalview.schemabinding. - version2.Colour(); + jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour(); col.setName(ResidueProperties.aa[i]); col.setRGB(jalview.util.Format.getHexString(colours[i])); jbucs.addColour(col); @@ -912,15 +1712,13 @@ public class Jalview2XML colours = ucs.getLowerCaseColours(); for (int i = 0; i < colours.length; i++) { - jalview.schemabinding.version2.Colour col = new jalview.schemabinding. - version2.Colour(); + jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour(); col.setName(ResidueProperties.aa[i].toLowerCase()); col.setRGB(jalview.util.Format.getHexString(colours[i])); jbucs.addColour(col); } } - id = "ucs" + userColours.indexOf(ucs); uc.setId(id); uc.setUserColourScheme(jbucs); jms.addUserColours(uc); @@ -930,7 +1728,7 @@ public class Jalview2XML } jalview.schemes.UserColourScheme GetUserColourScheme( - JalviewModelSequence jms, String id) + JalviewModelSequence jms, String id) { UserColours[] uc = jms.getUserColours(); UserColours colours = null; @@ -949,20 +1747,20 @@ public class Jalview2XML for (int i = 0; i < 24; i++) { - newColours[i] = new java.awt.Color(Integer.parseInt( - colours.getUserColourScheme().getColour(i).getRGB(), 16)); + newColours[i] = new java.awt.Color(Integer.parseInt(colours + .getUserColourScheme().getColour(i).getRGB(), 16)); } - jalview.schemes.UserColourScheme ucs = - new jalview.schemes.UserColourScheme(newColours); + jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme( + newColours); if (colours.getUserColourScheme().getColourCount() > 24) { newColours = new java.awt.Color[23]; for (int i = 0; i < 23; i++) { - newColours[i] = new java.awt.Color(Integer.parseInt( - colours.getUserColourScheme().getColour(i + 24).getRGB(), 16)); + newColours[i] = new java.awt.Color(Integer.parseInt(colours + .getUserColourScheme().getColour(i + 24).getRGB(), 16)); } ucs.setLowerCaseColours(newColours); } @@ -971,48 +1769,142 @@ public class Jalview2XML } /** - * DOCUMENT ME! - * - * @param file DOCUMENT ME! + * contains last error message (if any) encountered by XML loader. + */ + String errorMessage = null; + + /** + * flag to control whether the Jalview2XML_V1 parser should be deferred to if + * exceptions are raised during project XML parsing + */ + public boolean attemptversion1parse = true; + + /** + * Load a jalview project archive from a jar file + * + * @param file + * - HTTP URL or filename */ public AlignFrame LoadJalviewAlign(final String file) { - uniqueSetSuffix = System.currentTimeMillis() % 100000 + ""; jalview.gui.AlignFrame af = null; - seqRefIds = new Hashtable(); - viewportsAdded = new Hashtable(); - - Hashtable gatherToThisFrame = new Hashtable(); - - String errorMessage = null; - try { - //UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING - URL url = null; - - if (file.startsWith("http://")) - { - url = new URL(file); - } + // create list to store references for any new Jmol viewers created + newStructureViewers = new Vector(); + // UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING + // Workaround is to make sure caller implements the JarInputStreamProvider + // interface + // so we can re-open the jar input stream for each entry. - JarInputStream jin = null; - JarEntry jarentry = null; - int entryCount = 1; + jarInputStreamProvider jprovider = createjarInputStreamProvider(file); + af = LoadJalviewAlign(jprovider); - do + } catch (MalformedURLException e) + { + errorMessage = "Invalid URL format for '" + file + "'"; + reportErrors(); + } finally + { + try { - if (url != null) + SwingUtilities.invokeAndWait(new Runnable() { - jin = new JarInputStream(url.openStream()); - } + public void run() + { + setLoadingFinishedForNewStructureViewers(); + }; + }); + } catch (Exception x) + { + + } + } + return af; + } + + private jarInputStreamProvider createjarInputStreamProvider( + final String file) throws MalformedURLException + { + URL url = null; + errorMessage = null; + uniqueSetSuffix = null; + seqRefIds = null; + viewportsAdded = null; + frefedSequence = null; + + if (file.startsWith("http://")) + { + url = new URL(file); + } + final URL _url = url; + return new jarInputStreamProvider() + { + + @Override + public JarInputStream getJarInputStream() throws IOException + { + if (_url != null) + { + return new JarInputStream(_url.openStream()); + } else { - jin = new JarInputStream(new FileInputStream(file)); + return new JarInputStream(new FileInputStream(file)); } + } + + @Override + public String getFilename() + { + return file; + } + }; + } + + /** + * Recover jalview session from a jalview project archive. Caller may + * initialise uniqueSetSuffix, seqRefIds, viewportsAdded and frefedSequence + * themselves. Any null fields will be initialised with default values, + * non-null fields are left alone. + * + * @param jprovider + * @return + */ + public AlignFrame LoadJalviewAlign(final jarInputStreamProvider jprovider) + { + errorMessage = null; + if (uniqueSetSuffix == null) + { + uniqueSetSuffix = System.currentTimeMillis() % 100000 + ""; + } + if (seqRefIds == null) + { + seqRefIds = new Hashtable(); + } + if (viewportsAdded == null) + { + viewportsAdded = new Hashtable(); + } + if (frefedSequence == null) + { + frefedSequence = new Vector(); + } + + jalview.gui.AlignFrame af = null, _af = null; + Hashtable gatherToThisFrame = new Hashtable(); + final String file = jprovider.getFilename(); + try + { + JarInputStream jin = null; + JarEntry jarentry = null; + int entryCount = 1; + do + { + jin = jprovider.getJarInputStream(); for (int i = 0; i < entryCount; i++) { jarentry = jin.getNextJarEntry(); @@ -1026,41 +1918,60 @@ public class Jalview2XML Unmarshaller unmar = new Unmarshaller(object); unmar.setValidation(false); object = (JalviewModel) unmar.unmarshal(in); - - af = LoadFromObject(object, file, true); - if (af.viewport.gatherViewsHere) + if (true) // !skipViewport(object)) { - gatherToThisFrame.put(af.viewport.getSequenceSetId(), af); + _af = LoadFromObject(object, file, true, jprovider); + if (object.getJalviewModelSequence().getViewportCount() > 0) + { + af = _af; + if (af.viewport.gatherViewsHere) + { + gatherToThisFrame.put(af.viewport.getSequenceSetId(), af); + } + } } entryCount++; } else if (jarentry != null) { - //Some other file here. + // Some other file here. entryCount++; } - } - while (jarentry != null); - } - catch(java.io.FileNotFoundException ex) + } while (jarentry != null); + resolveFrefedSequences(); + } catch (java.io.FileNotFoundException ex) { ex.printStackTrace(); - errorMessage = "Couldn't locate Jalview XML file : "+file; - System.err.println("Exception whilst loading jalview XML file : " + - ex + "\n"); - } - catch (java.net.UnknownHostException ex) + errorMessage = "Couldn't locate Jalview XML file : " + file; + System.err.println("Exception whilst loading jalview XML file : " + + ex + "\n"); + } catch (java.net.UnknownHostException ex) { ex.printStackTrace(); - errorMessage = "Couldn't locate Jalview XML file : " +file; - System.err.println("Exception whilst loading jalview XML file : " + - ex + "\n"); - } - catch (Exception ex) + errorMessage = "Couldn't locate Jalview XML file : " + file; + System.err.println("Exception whilst loading jalview XML file : " + + ex + "\n"); + } catch (Exception ex) { - //Is Version 1 Jar file? - af = new Jalview2XML_V1().LoadJalviewAlign(file); - + System.err.println("Parsing as Jalview Version 2 file failed."); + ex.printStackTrace(System.err); + if (attemptversion1parse) + { + // Is Version 1 Jar file? + try + { + af = new Jalview2XML_V1(raiseGUI).LoadJalviewAlign(jprovider); + } catch (Exception ex2) + { + System.err.println("Exception whilst loading as jalviewXMLV1:"); + ex2.printStackTrace(); + af = null; + } + } + if (Desktop.instance != null) + { + Desktop.instance.stopLoading(); + } if (af != null) { System.out.println("Successfully loaded archive file"); @@ -1068,8 +1979,14 @@ public class Jalview2XML } ex.printStackTrace(); - System.err.println("Exception whilst loading jalview XML file : " + - ex + "\n"); + System.err.println("Exception whilst loading jalview XML file : " + + ex + "\n"); + } catch (OutOfMemoryError e) + { + // Don't use the OOM Window here + errorMessage = "Out of memory loading jalview XML file"; + System.err.println("Out of memory whilst loading jalview XML file"); + e.printStackTrace(); } if (Desktop.instance != null) @@ -1078,32 +1995,64 @@ public class Jalview2XML } Enumeration en = gatherToThisFrame.elements(); - while(en.hasMoreElements()) + while (en.hasMoreElements()) + { + Desktop.instance.gatherViews((AlignFrame) en.nextElement()); + } + if (errorMessage != null) { - Desktop.instance.gatherViews( - (AlignFrame) en.nextElement()); + reportErrors(); } + return af; + } + + /** + * check errorMessage for a valid error message and raise an error box in the + * GUI or write the current errorMessage to stderr and then clear the error + * state. + */ + protected void reportErrors() + { + reportErrors(false); + } - if(errorMessage!=null) + protected void reportErrors(final boolean saving) + { + if (errorMessage != null) { final String finalErrorMessage = errorMessage; - javax.swing.SwingUtilities.invokeLater(new Runnable() + if (raiseGUI) { - public void run() + javax.swing.SwingUtilities.invokeLater(new Runnable() { - JOptionPane.showInternalMessageDialog(Desktop.desktop, - finalErrorMessage, - "Error loading Jalview file", - JOptionPane.WARNING_MESSAGE); - } - }); + @Override + public void run() + { + JOptionPane.showInternalMessageDialog(Desktop.desktop, + finalErrorMessage, "Error " + + (saving ? "saving" : "loading") + + " Jalview file", JOptionPane.WARNING_MESSAGE); + } + }); + } + else + { + System.err.println("Problem loading Jalview file: " + errorMessage); + } } - - return af; + errorMessage = null; } Hashtable alreadyLoadedPDB; - String loadPDBFile(String file, String pdbId) + + /** + * when set, local views will be updated from view stored in JalviewXML + * Currently (28th Sep 2008) things will go horribly wrong in vamsas document + * sync if this is set to true. + */ + private final boolean updateLocalViews = false; + + String loadPDBFile(jarInputStreamProvider jprovider, String pdbId) { if (alreadyLoadedPDB == null) alreadyLoadedPDB = new Hashtable(); @@ -1113,41 +2062,47 @@ public class Jalview2XML try { - JarInputStream jin = null; - - if (file.startsWith("http://")) - { - jin = new JarInputStream(new URL(file).openStream()); - } - else - { - jin = new JarInputStream(new FileInputStream(file)); - } + JarInputStream jin = jprovider.getJarInputStream(); + /* + * if (jprovider.startsWith("http://")) { jin = new JarInputStream(new + * URL(jprovider).openStream()); } else { jin = new JarInputStream(new + * FileInputStream(jprovider)); } + */ JarEntry entry = null; do { entry = jin.getNextJarEntry(); - } - while (!entry.getName().equals(pdbId)); - - BufferedReader in = new BufferedReader(new InputStreamReader(jin)); - File outFile = File.createTempFile("jalview_pdb", ".txt"); - outFile.deleteOnExit(); - PrintWriter out = new PrintWriter(new FileOutputStream(outFile)); - String data; + } while (entry != null && !entry.getName().equals(pdbId)); + if (entry != null) + { + BufferedReader in = new BufferedReader(new InputStreamReader(jin)); + File outFile = File.createTempFile("jalview_pdb", ".txt"); + outFile.deleteOnExit(); + PrintWriter out = new PrintWriter(new FileOutputStream(outFile)); + String data; - while ( (data = in.readLine()) != null) + while ((data = in.readLine()) != null) + { + out.println(data); + } + try + { + out.flush(); + } catch (Exception foo) + { + } + ; + out.close(); + String t = outFile.getAbsolutePath(); + alreadyLoadedPDB.put(pdbId, t); + return t; + } + else { - out.println(data); + warn("Couldn't find PDB file entry in Jalview Jar for " + pdbId); } - out.close(); - - alreadyLoadedPDB.put(pdbId, outFile.getAbsolutePath()); - return outFile.getAbsolutePath(); - - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); } @@ -1155,19 +2110,51 @@ public class Jalview2XML return null; } - AlignFrame LoadFromObject(JalviewModel object, - String file, - boolean loadTreesAndStructures) + private class JvAnnotRow + { + public JvAnnotRow(int i, AlignmentAnnotation jaa) + { + order = i; + template = jaa; + } + + /** + * persisted version of annotation row from which to take vis properties + */ + public jalview.datamodel.AlignmentAnnotation template; + + /** + * original position of the annotation row in the alignment + */ + public int order; + } + + /** + * Load alignment frame from jalview XML DOM object + * + * @param object + * DOM + * @param file + * filename source string + * @param loadTreesAndStructures + * when false only create Viewport + * @param jprovider + * data source provider + * @return alignment frame created from view stored in DOM + */ + AlignFrame LoadFromObject(JalviewModel object, String file, + boolean loadTreesAndStructures, jarInputStreamProvider jprovider) { SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0); Sequence[] vamsasSeq = vamsasSet.getSequence(); JalviewModelSequence jms = object.getJalviewModelSequence(); - Viewport view = jms.getViewport(0); + Viewport view = (jms.getViewportCount() > 0) ? jms.getViewport(0) + : null; - ////////////////////////////////// - //LOAD SEQUENCES + // //////////////////////////////// + // LOAD SEQUENCES Vector hiddenSeqs = null; jalview.datamodel.Sequence jseq; @@ -1177,24 +2164,27 @@ public class Jalview2XML boolean multipleView = false; JSeq[] JSEQ = object.getJalviewModelSequence().getJSeq(); + int vi = 0; // counter in vamsasSeq array for (int i = 0; i < JSEQ.length; i++) { - String seqId = JSEQ[i].getId() + ""; + String seqId = JSEQ[i].getId(); if (seqRefIds.get(seqId) != null) { - tmpseqs.add( (jalview.datamodel.Sequence) seqRefIds.get(seqId)); + tmpseqs.add(seqRefIds.get(seqId)); multipleView = true; } else { - jseq = new jalview.datamodel.Sequence(vamsasSeq[i].getName(), - vamsasSeq[i].getSequence()); - jseq.setDescription(vamsasSeq[i].getDescription()); + jseq = new jalview.datamodel.Sequence(vamsasSeq[vi].getName(), + vamsasSeq[vi].getSequence()); + jseq.setDescription(vamsasSeq[vi].getDescription()); jseq.setStart(JSEQ[i].getStart()); jseq.setEnd(JSEQ[i].getEnd()); - seqRefIds.put(vamsasSeq[i].getId(), jseq); + jseq.setVamsasId(uniqueSetSuffix + seqId); + seqRefIds.put(vamsasSeq[vi].getId(), jseq); tmpseqs.add(jseq); + vi++; } if (JSEQ[i].getHidden()) @@ -1204,40 +2194,49 @@ public class Jalview2XML hiddenSeqs = new Vector(); } - hiddenSeqs.addElement( - (jalview.datamodel.Sequence) seqRefIds.get(seqId)); + hiddenSeqs.addElement(seqRefIds.get(seqId)); } } - ///SequenceFeatures are added to the DatasetSequence, - // so we must create the dataset before loading features - ///////////////////////////////// - - - jalview.datamodel.Sequence[] orderedSeqs = new jalview.datamodel.Sequence[ - tmpseqs.size()]; + // / + // Create the alignment object from the sequence set + // /////////////////////////////// + jalview.datamodel.Sequence[] orderedSeqs = new jalview.datamodel.Sequence[tmpseqs + .size()]; tmpseqs.toArray(orderedSeqs); - jalview.datamodel.Alignment al = - new jalview.datamodel.Alignment(orderedSeqs); + jalview.datamodel.Alignment al = new jalview.datamodel.Alignment( + orderedSeqs); - for(int i=0; i 0) @@ -1245,11 +2244,10 @@ public class Jalview2XML Features[] features = JSEQ[i].getFeatures(); for (int f = 0; f < features.length; f++) { - jalview.datamodel.SequenceFeature sf - = new jalview.datamodel.SequenceFeature(features[f].getType(), - features[f].getDescription(), features[f].getStatus(), - features[f].getBegin(), features[f].getEnd(), - features[f].getFeatureGroup()); + jalview.datamodel.SequenceFeature sf = new jalview.datamodel.SequenceFeature( + features[f].getType(), features[f].getDescription(), + features[f].getStatus(), features[f].getBegin(), + features[f].getEnd(), features[f].getFeatureGroup()); sf.setScore(features[f].getScore()); for (int od = 0; od < features[f].getOtherDataCount(); od++) @@ -1269,21 +2267,23 @@ public class Jalview2XML al.getSequenceAt(i).getDatasetSequence().addSequenceFeature(sf); } } - + if (vamsasSeq[i].getDBRefCount() > 0) + { + addDBRefs(al.getSequenceAt(i).getDatasetSequence(), vamsasSeq[i]); + } if (JSEQ[i].getPdbidsCount() > 0) { Pdbids[] ids = JSEQ[i].getPdbids(); for (int p = 0; p < ids.length; p++) { - jalview.datamodel.PDBEntry entry = new jalview.datamodel. - PDBEntry(); + jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry(); entry.setId(ids[p].getId()); entry.setType(ids[p].getType()); if (ids[p].getFile() != null) { if (!pdbloaded.containsKey(ids[p].getFile())) { - entry.setFile(loadPDBFile(file, ids[p].getId())); + entry.setFile(loadPDBFile(jprovider, ids[p].getId())); } else { @@ -1294,29 +2294,79 @@ public class Jalview2XML al.getSequenceAt(i).getDatasetSequence().addPDBId(entry); } } - if (vamsasSeq[i].getDBRefCount() > 0) + } + } // end !multipleview + + // /////////////////////////////// + // LOAD SEQUENCE MAPPINGS + + if (vamsasSet.getAlcodonFrameCount() > 0) + { + // TODO Potentially this should only be done once for all views of an + // alignment + AlcodonFrame[] alc = vamsasSet.getAlcodonFrame(); + for (int i = 0; i < alc.length; i++) + { + jalview.datamodel.AlignedCodonFrame cf = new jalview.datamodel.AlignedCodonFrame( + alc[i].getAlcodonCount()); + if (alc[i].getAlcodonCount() > 0) { - for (int d = 0; d < vamsasSeq[i].getDBRefCount(); d++) + Alcodon[] alcods = alc[i].getAlcodon(); + for (int p = 0; p < cf.codons.length; p++) { - jalview.datamodel.DBRefEntry entry = - new jalview.datamodel.DBRefEntry( - vamsasSeq[i].getDBRef(d).getSource(), - vamsasSeq[i].getDBRef(d).getVersion(), - vamsasSeq[i].getDBRef(d).getAccessionId() - ); - al.getSequenceAt(i).getDatasetSequence().addDBRef(entry); + if (alcods[p].hasPos1() && alcods[p].hasPos2() + && alcods[p].hasPos3()) + { + // translated codons require three valid positions + cf.codons[p] = new int[3]; + cf.codons[p][0] = (int) alcods[p].getPos1(); + cf.codons[p][1] = (int) alcods[p].getPos2(); + cf.codons[p][2] = (int) alcods[p].getPos3(); + } + else + { + cf.codons[p] = null; + } + } + } + if (alc[i].getAlcodMapCount() > 0) + { + AlcodMap[] maps = alc[i].getAlcodMap(); + for (int m = 0; m < maps.length; m++) + { + SequenceI dnaseq = (SequenceI) seqRefIds + .get(maps[m].getDnasq()); + // Load Mapping + jalview.datamodel.Mapping mapping = null; + // attach to dna sequence reference. + if (maps[m].getMapping() != null) + { + mapping = addMapping(maps[m].getMapping()); + } + if (dnaseq != null) + { + cf.addMap(dnaseq, mapping.getTo(), mapping.getMap()); + } + else + { + // defer to later + frefedSequence.add(new Object[] + { maps[m].getDnasq(), cf, mapping }); + } } - } + al.addCodonFrame(cf); } + } - ///////////////////////////////// - ////////////////////////////////// - //LOAD ANNOTATIONS - boolean hideQuality = true, - hideConservation = true, - hideConsensus = true; + // //////////////////////////////// + // LOAD ANNOTATIONS + ArrayList autoAlan = new ArrayList(); + /** + * store any annotations which forward reference a group's ID + */ + Hashtable> groupAnnotRefs = new Hashtable>(); if (vamsasSet.getAnnotationCount() > 0) { @@ -1324,112 +2374,197 @@ public class Jalview2XML for (int i = 0; i < an.length; i++) { - if (an[i].getLabel().equals("Quality")) - { - hideQuality = false; - continue; - } - else if (an[i].getLabel().equals("Conservation")) + /** + * test if annotation is automatically calculated for this view only + */ + boolean autoForView = false; + if (an[i].getLabel().equals("Quality") + || an[i].getLabel().equals("Conservation") + || an[i].getLabel().equals("Consensus")) { - hideConservation = false; - continue; + // Kludge for pre 2.5 projects which lacked the autocalculated flag + autoForView = true; + if (!an[i].hasAutoCalculated()) + { + an[i].setAutoCalculated(true); + } } - else if (an[i].getLabel().equals("Consensus")) + if (autoForView + || (an[i].hasAutoCalculated() && an[i].isAutoCalculated())) { - hideConsensus = false; - continue; + // remove ID - we don't recover annotation from other views for + // view-specific annotation + an[i].setId(null); } + // set visiblity for other annotation in this view if (an[i].getId() != null - && annotationIds.containsKey(an[i].getId())) + && annotationIds.containsKey(an[i].getId())) { - al.addAnnotation( - (jalview.datamodel.AlignmentAnnotation) annotationIds.get(an[i]. - getId()) - ); + jalview.datamodel.AlignmentAnnotation jda = (jalview.datamodel.AlignmentAnnotation) annotationIds + .get(an[i].getId()); + // in principle Visible should always be true for annotation displayed + // in multiple views + if (an[i].hasVisible()) + jda.visible = an[i].getVisible(); + + al.addAnnotation(jda); continue; } - + // Construct new annotation from model. AnnotationElement[] ae = an[i].getAnnotationElement(); jalview.datamodel.Annotation[] anot = null; - + java.awt.Color firstColour = null; + int anpos; if (!an[i].getScoreOnly()) { - anot = new jalview.datamodel.Annotation[ - al.getWidth()]; - + anot = new jalview.datamodel.Annotation[al.getWidth()]; for (int aa = 0; aa < ae.length && aa < anot.length; aa++) { - anot[ae[aa].getPosition()] = new jalview.datamodel.Annotation( + anpos = ae[aa].getPosition(); - ae[aa].getDisplayCharacter(), - ae[aa].getDescription(), - (ae[aa].getSecondaryStructure()==null || ae[aa].getSecondaryStructure().length() == 0) ? ' ' : - ae[aa].getSecondaryStructure().charAt(0), - ae[aa].getValue() + if (anpos >= anot.length) + continue; - ); + anot[anpos] = new jalview.datamodel.Annotation( + ae[aa].getDisplayCharacter(), ae[aa].getDescription(), + (ae[aa].getSecondaryStructure() == null || ae[aa] + .getSecondaryStructure().length() == 0) ? ' ' + : ae[aa].getSecondaryStructure().charAt(0), + ae[aa].getValue() - anot[ae[aa].getPosition()].colour = new java.awt.Color(ae[aa]. - getColour()); + ); + // JBPNote: Consider verifying dataflow for IO of secondary + // structure annotation read from Stockholm files + // this was added to try to ensure that + // if (anot[ae[aa].getPosition()].secondaryStructure>' ') + // { + // anot[ae[aa].getPosition()].displayCharacter = ""; + // } + anot[anpos].colour = new java.awt.Color(ae[aa].getColour()); + if (firstColour == null) + { + firstColour = anot[anpos].colour; + } } } jalview.datamodel.AlignmentAnnotation jaa = null; if (an[i].getGraph()) { + float llim = 0, hlim = 0; + // if (autoForView || an[i].isAutoCalculated()) { + // hlim=11f; + // } jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(), - an[i].getDescription(), anot, 0, 0, - an[i].getGraphType()); + an[i].getDescription(), anot, llim, hlim, + an[i].getGraphType()); jaa.graphGroup = an[i].getGraphGroup(); - + jaa._linecolour = firstColour; if (an[i].getThresholdLine() != null) { - jaa.setThreshold(new jalview.datamodel.GraphLine( - an[i].getThresholdLine().getValue(), - an[i].getThresholdLine().getLabel(), - new java.awt.Color(an[i].getThresholdLine().getColour())) - ); + jaa.setThreshold(new jalview.datamodel.GraphLine(an[i] + .getThresholdLine().getValue(), an[i] + .getThresholdLine().getLabel(), new java.awt.Color( + an[i].getThresholdLine().getColour()))); } - + if (autoForView || an[i].isAutoCalculated()) + { + // Hardwire the symbol display line to ensure that labels for + // histograms are displayed + jaa.hasText = true; + } } else { jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(), - an[i].getDescription(), anot); + an[i].getDescription(), anot); + jaa._linecolour = firstColour; } - + // register new annotation if (an[i].getId() != null) { annotationIds.put(an[i].getId(), jaa); jaa.annotationId = an[i].getId(); } - + // recover sequence association if (an[i].getSequenceRef() != null) { - jaa.createSequenceMapping( - al.findName(an[i].getSequenceRef()), 1, true - ); - al.findName(an[i].getSequenceRef()).addAlignmentAnnotation(jaa); + if (al.findName(an[i].getSequenceRef()) != null) + { + jaa.createSequenceMapping(al.findName(an[i].getSequenceRef()), + 1, true); + al.findName(an[i].getSequenceRef()).addAlignmentAnnotation(jaa); + } + } + // and make a note of any group association + if (an[i].getGroupRef() != null && an[i].getGroupRef().length() > 0) + { + ArrayList aal = groupAnnotRefs + .get(an[i].getGroupRef()); + if (aal == null) + { + aal = new ArrayList(); + groupAnnotRefs.put(an[i].getGroupRef(), aal); + } + aal.add(jaa); } + if (an[i].hasScore()) { jaa.setScore(an[i].getScore()); } - al.addAnnotation(jaa); + if (an[i].hasVisible()) + jaa.visible = an[i].getVisible(); + + if (an[i].hasCentreColLabels()) + jaa.centreColLabels = an[i].getCentreColLabels(); + + if (an[i].hasScaleColLabels()) + { + jaa.scaleColLabel = an[i].getScaleColLabels(); + } + if (an[i].hasAutoCalculated() && an[i].isAutoCalculated()) + { + // newer files have an 'autoCalculated' flag and store calculation + // state in viewport properties + jaa.autoCalculated = true; // means annotation will be marked for + // update at end of load. + } + if (an[i].hasGraphHeight()) + { + jaa.graphHeight = an[i].getGraphHeight(); + } + if (an[i].hasBelowAlignment()) + { + jaa.belowAlignment = an[i].isBelowAlignment(); + } + jaa.setCalcId(an[i].getCalcId()); + + if (jaa.autoCalculated) + { + autoAlan.add(new JvAnnotRow(i, jaa)); + } + else + // if (!autoForView) + { + // add autocalculated group annotation and any user created annotation + // for the view + al.addAnnotation(jaa); + } } } - - ///////////////////////// - //LOAD GROUPS + // /////////////////////// + // LOAD GROUPS + // Create alignment markup and styles for this view if (jms.getJGroupCount() > 0) { JGroup[] groups = jms.getJGroup(); - + boolean addAnnotSchemeGroup = false; for (int i = 0; i < groups.length; i++) { ColourSchemeI cs = null; @@ -1440,10 +2575,15 @@ public class Jalview2XML { cs = GetUserColourScheme(jms, groups[i].getColour()); } + else if (groups[i].getColour().equals("AnnotationColourGradient") + && groups[i].getAnnotationColours() != null) + { + addAnnotSchemeGroup = true; + cs = null; + } else { - cs = ColourSchemeProperty.getColour(al, - groups[i].getColour()); + cs = ColourSchemeProperty.getColour(al, groups[i].getColour()); } if (cs != null) @@ -1457,8 +2597,8 @@ public class Jalview2XML for (int s = 0; s < groups[i].getSeqCount(); s++) { String seqId = groups[i].getSeq(s) + ""; - jalview.datamodel.SequenceI ts = (jalview.datamodel.SequenceI) - seqRefIds.get(seqId); + jalview.datamodel.SequenceI ts = (jalview.datamodel.SequenceI) seqRefIds + .get(seqId); if (ts != null) { @@ -1471,351 +2611,171 @@ public class Jalview2XML continue; } - jalview.datamodel.SequenceGroup sg = new jalview.datamodel. - SequenceGroup(seqs, - groups[i].getName(), cs, groups[i].getDisplayBoxes(), - groups[i].getDisplayText(), groups[i].getColourText(), - groups[i].getStart(), groups[i].getEnd()); + jalview.datamodel.SequenceGroup sg = new jalview.datamodel.SequenceGroup( + seqs, groups[i].getName(), cs, groups[i].getDisplayBoxes(), + groups[i].getDisplayText(), groups[i].getColourText(), + groups[i].getStart(), groups[i].getEnd()); - sg.setOutlineColour(new java.awt.Color( - groups[i].getOutlineColour())); + sg.setOutlineColour(new java.awt.Color(groups[i].getOutlineColour())); sg.textColour = new java.awt.Color(groups[i].getTextCol1()); sg.textColour2 = new java.awt.Color(groups[i].getTextCol2()); + sg.setShowNonconserved(groups[i].hasShowUnconserved() ? groups[i] + .isShowUnconserved() : false); sg.thresholdTextColour = groups[i].getTextColThreshold(); - + if (groups[i].hasShowConsensusHistogram()) + { + sg.setShowConsensusHistogram(groups[i].isShowConsensusHistogram()); + } + ; + if (groups[i].hasShowSequenceLogo()) + { + sg.setshowSequenceLogo(groups[i].isShowSequenceLogo()); + } + if (groups[i].hasNormaliseSequenceLogo()) + { + sg.setNormaliseSequenceLogo(groups[i].isNormaliseSequenceLogo()); + } + if (groups[i].hasIgnoreGapsinConsensus()) + { + sg.setIgnoreGapsConsensus(groups[i].getIgnoreGapsinConsensus()); + } if (groups[i].getConsThreshold() != 0) { jalview.analysis.Conservation c = new jalview.analysis.Conservation( - "All", - ResidueProperties.propHash, 3, sg.getSequences(null), 0, - sg.getWidth() - 1); + "All", ResidueProperties.propHash, 3, + sg.getSequences(null), 0, sg.getWidth() - 1); c.calculate(); c.verdict(false, 25); sg.cs.setConservation(c); } + if (groups[i].getId() != null && groupAnnotRefs.size() > 0) + { + // re-instate unique group/annotation row reference + ArrayList jaal = groupAnnotRefs + .get(groups[i].getId()); + if (jaal != null) + { + for (jalview.datamodel.AlignmentAnnotation jaa : jaal) + { + jaa.groupRef = sg; + if (jaa.autoCalculated) + { + // match up and try to set group autocalc alignment row for this + // annotation + if (jaa.label.startsWith("Consensus for ")) + { + sg.setConsensus(jaa); + } + // match up and try to set group autocalc alignment row for this + // annotation + if (jaa.label.startsWith("Conservation for ")) + { + sg.setConservationRow(jaa); + } + } + } + } + } al.addGroup(sg); + if (addAnnotSchemeGroup) + { + // reconstruct the annotation colourscheme + sg.cs = constructAnnotationColour( + groups[i].getAnnotationColours(), null, al, jms, false); + } } } - - ///////////////////////////////// - // LOAD VIEWPORT - - AlignFrame af = new AlignFrame(al, - view.getWidth(), - view.getHeight()); - - af.setFileName(file, "Jalview"); - - for (int i = 0; i < JSEQ.length; i++) + if (view == null) { - af.viewport.setSequenceColour( - af.viewport.alignment.getSequenceAt(i), - new java.awt.Color( - JSEQ[i].getColour())); + // only dataset in this model, so just return. + return null; } + // /////////////////////////////// + // LOAD VIEWPORT - //If we just load in the same jar file again, the sequenceSetId - //will be the same, and we end up with multiple references - //to the same sequenceSet. We must modify this id on load - //so that each load of the file gives a unique id + // If we just load in the same jar file again, the sequenceSetId + // will be the same, and we end up with multiple references + // to the same sequenceSet. We must modify this id on load + // so that each load of the file gives a unique id String uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix; - - af.viewport.gatherViewsHere = view.getGatheredViews(); - - if (view.getSequenceSetId() != null) + String viewId = (view.getId() == null ? null : view.getId() + + uniqueSetSuffix); + AlignFrame af = null; + AlignViewport av = null; + // now check to see if we really need to create a new viewport. + if (multipleView && viewportsAdded.size() == 0) { - jalview.gui.AlignViewport av = - (jalview.gui.AlignViewport) - viewportsAdded.get(uniqueSeqSetId); - - af.viewport.sequenceSetID = uniqueSeqSetId; - if (av != null) + // We recovered an alignment for which a viewport already exists. + // TODO: fix up any settings necessary for overlaying stored state onto + // state recovered from another document. (may not be necessary). + // we may need a binding from a viewport in memory to one recovered from + // XML. + // and then recover its containing af to allow the settings to be applied. + // TODO: fix for vamsas demo + System.err + .println("About to recover a viewport for existing alignment: Sequence set ID is " + + uniqueSeqSetId); + Object seqsetobj = retrieveExistingObj(uniqueSeqSetId); + if (seqsetobj != null) { + if (seqsetobj instanceof String) + { + uniqueSeqSetId = (String) seqsetobj; + System.err + .println("Recovered extant sequence set ID mapping for ID : New Sequence set ID is " + + uniqueSeqSetId); + } + else + { + System.err + .println("Warning : Collision between sequence set ID string and existing jalview object mapping."); + } - af.viewport.historyList = av.historyList; - af.viewport.redoList = av.redoList; - } - else - { - viewportsAdded.put(uniqueSeqSetId, af.viewport); } - - PaintRefresher.Register(af.alignPanel, uniqueSeqSetId); } - if (hiddenSeqs != null) + /** + * indicate that annotation colours are applied across all groups (pre + * Jalview 2.8.1 behaviour) + */ + boolean doGroupAnnColour = isVersionStringLaterThan("2.8.1", + object.getVersion()); + + AlignmentPanel ap = null; + boolean isnewview = true; + if (viewId != null) { - for (int s = 0; s < JSEQ.length; s++) + // Check to see if this alignment already has a view id == viewId + jalview.gui.AlignmentPanel views[] = Desktop + .getAlignmentPanels(uniqueSeqSetId); + if (views != null && views.length > 0) { - jalview.datamodel.SequenceGroup hidden = - new jalview.datamodel.SequenceGroup(); - - for (int r = 0; r < JSEQ[s].getHiddenSequencesCount(); r++) + for (int v = 0; v < views.length; v++) { - hidden.addSequence( - al.getSequenceAt(JSEQ[s].getHiddenSequences(r)) - , false - ); - } - af.viewport.hideRepSequences(al.getSequenceAt(s), hidden); - } - - jalview.datamodel.SequenceI[] hseqs = new - jalview.datamodel.SequenceI[hiddenSeqs.size()]; - - for (int s = 0; s < hiddenSeqs.size(); s++) - { - hseqs[s] = (jalview.datamodel.SequenceI) hiddenSeqs.elementAt(s); - } - - af.viewport.hideSequence(hseqs); - - } - - if ( (hideConsensus || hideQuality || hideConservation) - && al.getAlignmentAnnotation() != null) - { - int hSize = al.getAlignmentAnnotation().length; - for (int h = 0; h < hSize; h++) - { - if ( - (hideConsensus && - al.getAlignmentAnnotation()[h].label.equals("Consensus")) - || - (hideQuality && - al.getAlignmentAnnotation()[h].label.equals("Quality")) - || - (hideConservation && - al.getAlignmentAnnotation()[h].label.equals("Conservation"))) - { - al.deleteAnnotation(al.getAlignmentAnnotation()[h]); - hSize--; - h--; - } - } - af.alignPanel.adjustAnnotationHeight(); - } - - if (view.getViewName() != null) - { - af.viewport.viewName = view.getViewName(); - af.setInitialTabVisible(); - } - af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(), - view.getHeight()); - - af.viewport.setShowAnnotation(view.getShowAnnotation()); - af.viewport.setAbovePIDThreshold(view.getPidSelected()); - - af.viewport.setColourText(view.getShowColourText()); - - af.viewport.setConservationSelected(view.getConservationSelected()); - af.viewport.setShowJVSuffix(view.getShowFullId()); - af.viewport.rightAlignIds = view.getRightAlignIds(); - af.viewport.setFont(new java.awt.Font(view.getFontName(), - view.getFontStyle(), view.getFontSize())); - af.alignPanel.fontChanged(); - af.viewport.setRenderGaps(view.getRenderGaps()); - af.viewport.setWrapAlignment(view.getWrapAlignment()); - af.alignPanel.setWrapAlignment(view.getWrapAlignment()); - af.viewport.setShowAnnotation(view.getShowAnnotation()); - af.alignPanel.setAnnotationVisible(view.getShowAnnotation()); - - af.viewport.setShowBoxes(view.getShowBoxes()); - - af.viewport.setShowText(view.getShowText()); - - af.viewport.textColour = new java.awt.Color(view.getTextCol1()); - af.viewport.textColour2 = new java.awt.Color(view.getTextCol2()); - af.viewport.thresholdTextColour = view.getTextColThreshold(); - - af.viewport.setStartRes(view.getStartRes()); - af.viewport.setStartSeq(view.getStartSeq()); - - ColourSchemeI cs = null; - - if (view.getBgColour() != null) - { - if (view.getBgColour().startsWith("ucs")) - { - cs = GetUserColourScheme(jms, view.getBgColour()); - } - else if (view.getBgColour().startsWith("Annotation")) - { - //int find annotation - for (int i = 0; - i < af.viewport.alignment.getAlignmentAnnotation().length; i++) - { - if (af.viewport.alignment.getAlignmentAnnotation()[i].label. - equals(view.getAnnotationColours().getAnnotation())) + if (views[v].av.getViewId().equalsIgnoreCase(viewId)) { - if (af.viewport.alignment.getAlignmentAnnotation()[i]. - getThreshold() == null) - { - af.viewport.alignment.getAlignmentAnnotation()[i]. - setThreshold( - new jalview.datamodel.GraphLine( - view.getAnnotationColours().getThreshold(), - "Threshold", java.awt.Color.black) - - ); - } - - if (view.getAnnotationColours().getColourScheme().equals( - "None")) - { - cs = new AnnotationColourGradient( - af.viewport.alignment.getAlignmentAnnotation()[i], - new java.awt.Color(view.getAnnotationColours(). - getMinColour()), - new java.awt.Color(view.getAnnotationColours(). - getMaxColour()), - view.getAnnotationColours().getAboveThreshold()); - } - else if (view.getAnnotationColours().getColourScheme(). - startsWith("ucs")) - { - cs = new AnnotationColourGradient( - af.viewport.alignment.getAlignmentAnnotation()[i], - GetUserColourScheme(jms, view.getAnnotationColours(). - getColourScheme()), - view.getAnnotationColours().getAboveThreshold() - ); - } - else - { - cs = new AnnotationColourGradient( - af.viewport.alignment.getAlignmentAnnotation()[i], - ColourSchemeProperty.getColour(al, - view.getAnnotationColours(). - getColourScheme()), - view.getAnnotationColours().getAboveThreshold() - ); - } - - // Also use these settings for all the groups - if (al.getGroups() != null) - { - for (int g = 0; g < al.getGroups().size(); g++) - { - jalview.datamodel.SequenceGroup sg - = (jalview.datamodel.SequenceGroup) al.getGroups(). - elementAt(g); - - if (sg.cs == null) - { - continue; - } - - /* if (view.getAnnotationColours().getColourScheme().equals("None")) - { - sg.cs = new AnnotationColourGradient( - af.viewport.alignment.getAlignmentAnnotation()[i], - new java.awt.Color(view.getAnnotationColours(). - getMinColour()), - new java.awt.Color(view.getAnnotationColours(). - getMaxColour()), - view.getAnnotationColours().getAboveThreshold()); - } - else*/ - { - sg.cs = new AnnotationColourGradient( - af.viewport.alignment.getAlignmentAnnotation()[i], - sg.cs, - view.getAnnotationColours().getAboveThreshold() - ); - } - - } - } - - break; + // recover the existing alignpanel, alignframe, viewport + af = views[v].alignFrame; + av = views[v].av; + ap = views[v]; + // TODO: could even skip resetting view settings if we don't want to + // change the local settings from other jalview processes + isnewview = false; } - - } - } - else - { - cs = ColourSchemeProperty.getColour(al, view.getBgColour()); - } - - if (cs != null) - { - cs.setThreshold(view.getPidThreshold(), true); - cs.setConsensus(af.viewport.hconsensus); - } - } - - af.viewport.setGlobalColourScheme(cs); - af.viewport.setColourAppliesToAllGroups(false); - - if (view.getConservationSelected() && cs != null) - { - cs.setConservationInc(view.getConsThreshold()); - } - - af.changeColour(cs); - - af.viewport.setColourAppliesToAllGroups(true); - - if (view.getShowSequenceFeatures()) - { - af.viewport.showSequenceFeatures = true; - } - - if (jms.getFeatureSettings() != null) - { - af.viewport.featuresDisplayed = new Hashtable(); - String[] renderOrder = new String[jms.getFeatureSettings(). - getSettingCount()]; - for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++) - { - Setting setting = jms.getFeatureSettings().getSetting(fs); - - af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(setting. - getType(), - new java.awt.Color(setting.getColour())); - renderOrder[fs] = setting.getType(); - if (setting.hasOrder()) - af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(setting.getType(), setting.getOrder()); - else - af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(setting.getType(), fs/jms.getFeatureSettings().getSettingCount()); - if (setting.getDisplay()) - { - af.viewport.featuresDisplayed.put( - setting.getType(), new Integer(setting.getColour())); } } - af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder = - renderOrder; - Hashtable fgtable; - af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureGroups = fgtable=new Hashtable(); - for (int gs=0;gs 0) + if (isnewview) { - for (int c = 0; c < view.getHiddenColumnsCount(); c++) - { - af.viewport.hideColumns( - view.getHiddenColumns(c).getStart(), - view.getHiddenColumns(c).getEnd() //+1 - ); - } + af = loadViewport(file, JSEQ, hiddenSeqs, al, jms, view, + uniqueSeqSetId, viewId, autoAlan); + av = af.viewport; + ap = af.alignPanel; } - - af.setMenusFromViewport(af.viewport); - - Desktop.addInternalFrame(af, view.getTitle(), - view.getWidth(), view.getHeight()); - - //LOAD TREES - /////////////////////////////////////// + // LOAD TREES + // ///////////////////////////////////// if (loadTreesAndStructures && jms.getTreeCount() > 0) { try @@ -1825,25 +2785,52 @@ public class Jalview2XML Tree tree = jms.getTree(t); - TreePanel tp = af.ShowNewickTree(new jalview.io.NewickFile( - tree.getNewick()), tree.getTitle(), - tree.getWidth(), tree.getHeight(), - tree.getXpos(), tree.getYpos()); + TreePanel tp = (TreePanel) retrieveExistingObj(tree.getId()); + if (tp == null) + { + tp = af.ShowNewickTree( + new jalview.io.NewickFile(tree.getNewick()), + tree.getTitle(), tree.getWidth(), tree.getHeight(), + tree.getXpos(), tree.getYpos()); + if (tree.getId() != null) + { + // perhaps bind the tree id to something ? + } + } + else + { + // update local tree attributes ? + // TODO: should check if tp has been manipulated by user - if so its + // settings shouldn't be modified + tp.setTitle(tree.getTitle()); + tp.setBounds(new Rectangle(tree.getXpos(), tree.getYpos(), tree + .getWidth(), tree.getHeight())); + tp.av = av; // af.viewport; // TODO: verify 'associate with all + // views' + // works still + tp.treeCanvas.av = av; // af.viewport; + tp.treeCanvas.ap = ap; // af.alignPanel; + + } + if (tp == null) + { + warn("There was a problem recovering stored Newick tree: \n" + + tree.getNewick()); + continue; + } tp.fitToWindow.setState(tree.getFitToWindow()); tp.fitToWindow_actionPerformed(null); if (tree.getFontName() != null) { - tp.setTreeFont(new java.awt.Font(tree.getFontName(), - tree.getFontStyle(), - tree.getFontSize())); + tp.setTreeFont(new java.awt.Font(tree.getFontName(), tree + .getFontStyle(), tree.getFontSize())); } else { - tp.setTreeFont(new java.awt.Font(view.getFontName(), - view.getFontStyle(), - tree.getFontSize())); + tp.setTreeFont(new java.awt.Font(view.getFontName(), view + .getFontStyle(), tree.getFontSize())); } tp.showPlaceholders(tree.getMarkUnlinked()); @@ -1858,16 +2845,19 @@ public class Jalview2XML } } - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); } } - ////LOAD STRUCTURES - if(loadTreesAndStructures) + // //LOAD STRUCTURES + if (loadTreesAndStructures) { + // run through all PDB ids on the alignment, and collect mappings between + // jmol view ids and all sequences referring to it + Hashtable jmolViewIds = new Hashtable(); + for (int i = 0; i < JSEQ.length; i++) { if (JSEQ[i].getPdbidsCount() > 0) @@ -1877,9 +2867,15 @@ public class Jalview2XML { for (int s = 0; s < ids[p].getStructureStateCount(); s++) { + // check to see if we haven't already created this structure view + String sviewid = (ids[p].getStructureState(s).getViewId() == null) ? null + : ids[p].getStructureState(s).getViewId() + + uniqueSetSuffix; jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry(); - - jpdb.setFile(loadPDBFile(ids[p].getFile(), ids[p].getId())); + // Originally : ids[p].getFile() + // : TODO: verify external PDB file recovery still works in normal + // jalview project load + jpdb.setFile(loadPDBFile(jprovider, ids[p].getId())); jpdb.setId(ids[p].getId()); int x = ids[p].getStructureState(s).getXpos(); @@ -1887,105 +2883,1534 @@ public class Jalview2XML int width = ids[p].getStructureState(s).getWidth(); int height = ids[p].getStructureState(s).getHeight(); - java.awt.Component comp = null; + // Probably don't need to do this anymore... + // Desktop.desktop.getComponentAt(x, y); + // TODO: NOW: check that this recovers the PDB file correctly. + String pdbFile = loadPDBFile(jprovider, ids[p].getId()); + jalview.datamodel.SequenceI seq = (jalview.datamodel.SequenceI) seqRefIds + .get(JSEQ[i].getId() + ""); + if (sviewid == null) + { + sviewid = "_jalview_pre2_4_" + x + "," + y + "," + width + + "," + height; + } + if (!jmolViewIds.containsKey(sviewid)) + { + jmolViewIds.put(sviewid, new Object[] + { new int[] + { x, y, width, height }, "", + new Hashtable(), new boolean[] + { false, false, true } }); + // Legacy pre-2.7 conversion JAL-823 : + // do not assume any view has to be linked for colour by + // sequence + } - JInternalFrame [] frames = Desktop.desktop.getAllFrames(); - for(int f=0; f entry : jmolViewIds.entrySet()) { - if(!ap.av.alignment.getAlignmentAnnotation()[i].autoCalculated) + String sviewid = entry.getKey(); + Object[] svattrib = entry.getValue(); + int[] geom = (int[]) svattrib[0]; + String state = (String) svattrib[1]; + Hashtable oldFiles = (Hashtable) svattrib[2]; + final boolean useinJmolsuperpos = ((boolean[]) svattrib[3])[0], usetoColourbyseq = ((boolean[]) svattrib[3])[1], jmolColouring = ((boolean[]) svattrib[3])[2]; + int x = geom[0], y = geom[1], width = geom[2], height = geom[3]; + // collate the pdbfile -> sequence mappings from this view + Vector pdbfilenames = new Vector(); + Vector seqmaps = new Vector(); + Vector pdbids = new Vector(); + + // Search to see if we've already created this Jmol view + AppJmol comp = null; + JInternalFrame[] frames = null; + do + { + try + { + frames = Desktop.desktop.getAllFrames(); + } catch (ArrayIndexOutOfBoundsException e) + { + // occasional No such child exceptions are thrown here... + frames = null; + try + { + Thread.sleep(10); + } catch (Exception f) + { + } + ; + } + } while (frames == null); + // search for any Jmol windows already open from other + // alignment views that exactly match the stored structure state + for (int f = 0; comp == null && f < frames.length; f++) { - af.alignPanel.av.alignment.getAlignmentAnnotation()[i] = - ap.av.alignment.getAlignmentAnnotation()[i]; + if (frames[f] instanceof AppJmol) + { + if (sviewid != null + && ((AppJmol) frames[f]).getViewId().equals(sviewid)) + { + // post jalview 2.4 schema includes structure view id + comp = (AppJmol) frames[f]; + } + else if (frames[f].getX() == x && frames[f].getY() == y + && frames[f].getHeight() == height + && frames[f].getWidth() == width) + { + comp = (AppJmol) frames[f]; + } + } } - } - } */ - return af.alignPanel; - } + if (comp == null) + { + // create a new Jmol window. + // First parse the Jmol state to translate filenames loaded into the + // view, and record the order in which files are shown in the Jmol + // view, so we can add the sequence mappings in same order. + StringBuffer newFileLoc = null; + int cp = 0, ncp, ecp; + while ((ncp = state.indexOf("load ", cp)) > -1) + { + if (newFileLoc == null) + { + newFileLoc = new StringBuffer(); + } + do + { + // look for next filename in load statement + newFileLoc.append(state.substring(cp, + ncp = (state.indexOf("\"", ncp + 1) + 1))); + String oldfilenam = state.substring(ncp, + ecp = state.indexOf("\"", ncp)); + // recover the new mapping data for this old filename + // have to normalize filename - since Jmol and jalview do + // filename + // translation differently. + Object[] filedat = oldFiles.get(new File(oldfilenam)); + newFileLoc.append(Platform + .escapeString((String) filedat[0])); + pdbfilenames.addElement((String) filedat[0]); + pdbids.addElement((String) filedat[1]); + seqmaps.addElement(((Vector) filedat[2]) + .toArray(new SequenceI[0])); + newFileLoc.append("\""); + cp = ecp + 1; // advance beyond last \" and set cursor so we can + // look for next file statement. + } while ((ncp = state.indexOf("/*file*/", cp)) > -1); + } + if (cp > 0) + { + // just append rest of state + newFileLoc.append(state.substring(cp)); + } + else + { + System.err + .print("Ignoring incomplete Jmol state for PDB ids: "); + newFileLoc = new StringBuffer(state); + newFileLoc.append("; load append "); + for (File id : oldFiles.keySet()) + { + // add this and any other pdb files that should be present in + // the viewer + Object[] filedat = oldFiles.get(id); + String nfilename; + newFileLoc.append(((String) filedat[0])); + pdbfilenames.addElement((String) filedat[0]); + pdbids.addElement((String) filedat[1]); + seqmaps.addElement(((Vector) filedat[2]) + .toArray(new SequenceI[0])); + newFileLoc.append(" \""); + newFileLoc.append((String) filedat[0]); + newFileLoc.append("\""); + + } + newFileLoc.append(";"); + } + + if (newFileLoc != null) + { + int histbug = newFileLoc.indexOf("history = "); + histbug += 10; + int diff = histbug == -1 ? -1 : newFileLoc.indexOf(";", + histbug); + String val = (diff == -1) ? null : newFileLoc.substring( + histbug, diff); + if (val != null && val.length() >= 4) + { + if (val.contains("e")) + { + if (val.trim().equals("true")) + { + val = "1"; + } + else + { + val = "0"; + } + newFileLoc.replace(histbug, diff, val); + } + } + // TODO: assemble String[] { pdb files }, String[] { id for each + // file }, orig_fileloc, SequenceI[][] {{ seqs_file 1 }, { + // seqs_file 2}} from hash + final String[] pdbf = pdbfilenames + .toArray(new String[pdbfilenames.size()]), id = pdbids + .toArray(new String[pdbids.size()]); + final SequenceI[][] sq = seqmaps + .toArray(new SequenceI[seqmaps.size()][]); + final String fileloc = newFileLoc.toString(), vid = sviewid; + final AlignFrame alf = af; + final java.awt.Rectangle rect = new java.awt.Rectangle(x, y, + width, height); + try + { + javax.swing.SwingUtilities.invokeAndWait(new Runnable() + { + @Override + public void run() + { + AppJmol sview = null; + try + { + sview = new AppJmol(pdbf, id, sq, alf.alignPanel, + useinJmolsuperpos, usetoColourbyseq, + jmolColouring, fileloc, rect, vid); + addNewStructureViewer(sview); + } catch (OutOfMemoryError ex) + { + new OOMWarning("restoring structure view for PDB id " + + id, (OutOfMemoryError) ex.getCause()); + if (sview != null && sview.isVisible()) + { + sview.closeViewer(); + sview.setVisible(false); + sview.dispose(); + } + } + } + }); + } catch (InvocationTargetException ex) + { + warn("Unexpected error when opening Jmol view.", ex); + + } catch (InterruptedException e) + { + // e.printStackTrace(); + } + } + + } + else + // if (comp != null) + { + // NOTE: if the jalview project is part of a shared session then + // view synchronization should/could be done here. + + // add mapping for sequences in this view to an already open Jmol + // instance + for (File id : oldFiles.keySet()) + { + // add this and any other pdb files that should be present in the + // viewer + Object[] filedat = oldFiles.get(id); + String pdbFile = (String) filedat[0]; + SequenceI[] seq = ((Vector) filedat[2]) + .toArray(new SequenceI[0]); + comp.jmb.ssm.setMapping(seq, null, pdbFile, + jalview.io.AppletFormatAdapter.FILE); + comp.jmb.addSequenceForStructFile(pdbFile, seq); + } + // and add the AlignmentPanel's reference to the Jmol view + comp.addAlignmentPanel(ap); + if (useinJmolsuperpos) + { + comp.useAlignmentPanelForSuperposition(ap); + } + else + { + comp.excludeAlignmentPanelForSuperposition(ap); + } + if (usetoColourbyseq) + { + comp.useAlignmentPanelForColourbyseq(ap, !jmolColouring); + } + else + { + comp.excludeAlignmentPanelForColourbyseq(ap); + } + } + } + } + } + // and finally return. + return af; + } + + /** + * + * @param supported - minimum version we are comparing against + * @param version - version of data being processsed. + * @return true if version is development/null or evaluates to the same or + * later X.Y.Z (where X,Y,Z are like [0-9]+b?[0-9]*) + */ + private boolean isVersionStringLaterThan(String supported, String version) + { + if (version == null || version.equalsIgnoreCase("DEVELOPMENT BUILD") + || version.equalsIgnoreCase("Test") || version.equalsIgnoreCase("AUTOMATED BUILD")) + { + System.err.println("Assuming project file with " + + (version == null ? "null" : version) + + " is compatible with Jalview version " + supported); + return true; + } + else + { + StringTokenizer currentV = new StringTokenizer(supported, "."), fileV = new StringTokenizer( + version, "."); + while (currentV.hasMoreTokens() && fileV.hasMoreTokens()) + { + // convert b to decimal to catch bugfix releases within a series + String curT = currentV.nextToken().toLowerCase().replace('b', '.'); + String fileT = fileV.nextToken().toLowerCase().replace('b', '.'); + try + { + if (Float.valueOf(curT) > Float.valueOf(fileT)) + { + // current version is newer than the version that wrote the file + return false; + } + } catch (NumberFormatException nfe) + { + System.err + .println("** WARNING: Version comparison failed for tokens (" + + curT + + ") and (" + + fileT + + ")\n** Current: '" + + supported + "' and Version: '" + version + "'"); + } + } + if (currentV.hasMoreElements()) + { + // fileV has no minor version but identical series to current + return false; + } + } + return true; + } + + Vector newStructureViewers = null; + + protected void addNewStructureViewer(AppJmol sview) + { + if (newStructureViewers != null) + { + sview.jmb.setFinishedLoadingFromArchive(false); + newStructureViewers.add(sview); + } + } + + protected void setLoadingFinishedForNewStructureViewers() + { + if (newStructureViewers != null) + { + for (AppJmol sview : newStructureViewers) + { + sview.jmb.setFinishedLoadingFromArchive(true); + } + newStructureViewers.clear(); + newStructureViewers = null; + } + } + + AlignFrame loadViewport(String file, JSeq[] JSEQ, Vector hiddenSeqs, + Alignment al, JalviewModelSequence jms, Viewport view, + String uniqueSeqSetId, String viewId, + ArrayList autoAlan) + { + AlignFrame af = null; + af = new AlignFrame(al, view.getWidth(), view.getHeight(), + uniqueSeqSetId, viewId); + + af.setFileName(file, "Jalview"); + + for (int i = 0; i < JSEQ.length; i++) + { + af.viewport.setSequenceColour(af.viewport.getAlignment() + .getSequenceAt(i), new java.awt.Color(JSEQ[i].getColour())); + } + + af.viewport.gatherViewsHere = view.getGatheredViews(); + + if (view.getSequenceSetId() != null) + { + jalview.gui.AlignViewport av = (jalview.gui.AlignViewport) viewportsAdded + .get(uniqueSeqSetId); + + af.viewport.setSequenceSetId(uniqueSeqSetId); + if (av != null) + { + // propagate shared settings to this new view + af.viewport.historyList = av.historyList; + af.viewport.redoList = av.redoList; + } + else + { + viewportsAdded.put(uniqueSeqSetId, af.viewport); + } + // TODO: check if this method can be called repeatedly without + // side-effects if alignpanel already registered. + PaintRefresher.Register(af.alignPanel, uniqueSeqSetId); + } + // apply Hidden regions to view. + if (hiddenSeqs != null) + { + for (int s = 0; s < JSEQ.length; s++) + { + jalview.datamodel.SequenceGroup hidden = new jalview.datamodel.SequenceGroup(); + + for (int r = 0; r < JSEQ[s].getHiddenSequencesCount(); r++) + { + hidden.addSequence( + al.getSequenceAt(JSEQ[s].getHiddenSequences(r)), false); + } + af.viewport.hideRepSequences(al.getSequenceAt(s), hidden); + } + + jalview.datamodel.SequenceI[] hseqs = new jalview.datamodel.SequenceI[hiddenSeqs + .size()]; + + for (int s = 0; s < hiddenSeqs.size(); s++) + { + hseqs[s] = (jalview.datamodel.SequenceI) hiddenSeqs.elementAt(s); + } + + af.viewport.hideSequence(hseqs); + + } + // recover view properties and display parameters + if (view.getViewName() != null) + { + af.viewport.viewName = view.getViewName(); + af.setInitialTabVisible(); + } + af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(), + view.getHeight()); + + af.viewport.setShowAnnotation(view.getShowAnnotation()); + af.viewport.setAbovePIDThreshold(view.getPidSelected()); + + af.viewport.setColourText(view.getShowColourText()); + + af.viewport.setConservationSelected(view.getConservationSelected()); + af.viewport.setShowJVSuffix(view.getShowFullId()); + af.viewport.rightAlignIds = view.getRightAlignIds(); + af.viewport.setFont(new java.awt.Font(view.getFontName(), view + .getFontStyle(), view.getFontSize())); + af.alignPanel.fontChanged(); + af.viewport.setRenderGaps(view.getRenderGaps()); + af.viewport.setWrapAlignment(view.getWrapAlignment()); + af.alignPanel.setWrapAlignment(view.getWrapAlignment()); + af.viewport.setShowAnnotation(view.getShowAnnotation()); + af.alignPanel.setAnnotationVisible(view.getShowAnnotation()); + + af.viewport.setShowBoxes(view.getShowBoxes()); + + af.viewport.setShowText(view.getShowText()); + + af.viewport.textColour = new java.awt.Color(view.getTextCol1()); + af.viewport.textColour2 = new java.awt.Color(view.getTextCol2()); + af.viewport.thresholdTextColour = view.getTextColThreshold(); + af.viewport.setShowUnconserved(view.hasShowUnconserved() ? view + .isShowUnconserved() : false); + af.viewport.setStartRes(view.getStartRes()); + af.viewport.setStartSeq(view.getStartSeq()); + + ColourSchemeI cs = null; + // apply colourschemes + if (view.getBgColour() != null) + { + if (view.getBgColour().startsWith("ucs")) + { + cs = GetUserColourScheme(jms, view.getBgColour()); + } + else if (view.getBgColour().startsWith("Annotation")) + { + AnnotationColours viewAnnColour = view.getAnnotationColours(); + cs = constructAnnotationColour(viewAnnColour, af, al, jms, true); + + // annpos + + } + else + { + cs = ColourSchemeProperty.getColour(al, view.getBgColour()); + } + + if (cs != null) + { + cs.setThreshold(view.getPidThreshold(), true); + cs.setConsensus(af.viewport.getSequenceConsensusHash()); + } + } + + af.viewport.setGlobalColourScheme(cs); + af.viewport.setColourAppliesToAllGroups(false); + + if (view.getConservationSelected() && cs != null) + { + cs.setConservationInc(view.getConsThreshold()); + } + + af.changeColour(cs); + + af.viewport.setColourAppliesToAllGroups(true); + + if (view.getShowSequenceFeatures()) + { + af.viewport.showSequenceFeatures = true; + } + if (view.hasCentreColumnLabels()) + { + af.viewport.setCentreColumnLabels(view.getCentreColumnLabels()); + } + if (view.hasIgnoreGapsinConsensus()) + { + af.viewport.setIgnoreGapsConsensus(view.getIgnoreGapsinConsensus(), + null); + } + if (view.hasFollowHighlight()) + { + af.viewport.followHighlight = view.getFollowHighlight(); + } + if (view.hasFollowSelection()) + { + af.viewport.followSelection = view.getFollowSelection(); + } + if (view.hasShowConsensusHistogram()) + { + af.viewport.setShowConsensusHistogram(view + .getShowConsensusHistogram()); + } + else + { + af.viewport.setShowConsensusHistogram(true); + } + if (view.hasShowSequenceLogo()) + { + af.viewport.setShowSequenceLogo(view.getShowSequenceLogo()); + } + else + { + af.viewport.setShowSequenceLogo(false); + } + if (view.hasNormaliseSequenceLogo()) + { + af.viewport.setNormaliseSequenceLogo(view.getNormaliseSequenceLogo()); + } + if (view.hasShowDbRefTooltip()) + { + af.viewport.setShowDbRefs(view.getShowDbRefTooltip()); + } + if (view.hasShowNPfeatureTooltip()) + { + af.viewport.setShowNpFeats(view.hasShowNPfeatureTooltip()); + } + if (view.hasShowGroupConsensus()) + { + af.viewport.setShowGroupConsensus(view.getShowGroupConsensus()); + } + else + { + af.viewport.setShowGroupConsensus(false); + } + if (view.hasShowGroupConservation()) + { + af.viewport.setShowGroupConservation(view.getShowGroupConservation()); + } + else + { + af.viewport.setShowGroupConservation(false); + } + + // recover featre settings + if (jms.getFeatureSettings() != null) + { + af.viewport.featuresDisplayed = new Hashtable(); + String[] renderOrder = new String[jms.getFeatureSettings() + .getSettingCount()]; + for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++) + { + Setting setting = jms.getFeatureSettings().getSetting(fs); + if (setting.hasMincolour()) + { + GraduatedColor gc = setting.hasMin() ? new GraduatedColor( + new java.awt.Color(setting.getMincolour()), + new java.awt.Color(setting.getColour()), + setting.getMin(), setting.getMax()) : new GraduatedColor( + new java.awt.Color(setting.getMincolour()), + new java.awt.Color(setting.getColour()), 0, 1); + if (setting.hasThreshold()) + { + gc.setThresh(setting.getThreshold()); + gc.setThreshType(setting.getThreshstate()); + } + gc.setAutoScaled(true); // default + if (setting.hasAutoScale()) + { + gc.setAutoScaled(setting.getAutoScale()); + } + if (setting.hasColourByLabel()) + { + gc.setColourByLabel(setting.getColourByLabel()); + } + // and put in the feature colour table. + af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour( + setting.getType(), gc); + } + else + { + af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour( + setting.getType(), + new java.awt.Color(setting.getColour())); + } + renderOrder[fs] = setting.getType(); + if (setting.hasOrder()) + af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder( + setting.getType(), setting.getOrder()); + else + af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder( + setting.getType(), + fs / jms.getFeatureSettings().getSettingCount()); + if (setting.getDisplay()) + { + af.viewport.featuresDisplayed.put(setting.getType(), new Integer( + setting.getColour())); + } + } + af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder = renderOrder; + Hashtable fgtable; + af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureGroups = fgtable = new Hashtable(); + for (int gs = 0; gs < jms.getFeatureSettings().getGroupCount(); gs++) + { + Group grp = jms.getFeatureSettings().getGroup(gs); + fgtable.put(grp.getName(), new Boolean(grp.getDisplay())); + } + } + + if (view.getHiddenColumnsCount() > 0) + { + for (int c = 0; c < view.getHiddenColumnsCount(); c++) + { + af.viewport.hideColumns(view.getHiddenColumns(c).getStart(), view + .getHiddenColumns(c).getEnd() // +1 + ); + } + } + if (view.getCalcIdParam() != null) + { + for (CalcIdParam calcIdParam : view.getCalcIdParam()) + { + if (calcIdParam != null) + { + if (recoverCalcIdParam(calcIdParam, af.viewport)) + { + } + else + { + warn("Couldn't recover parameters for " + + calcIdParam.getCalcId()); + } + } + } + } + af.setMenusFromViewport(af.viewport); + // TODO: we don't need to do this if the viewport is aready visible. + Desktop.addInternalFrame(af, view.getTitle(), view.getWidth(), + view.getHeight()); + af.alignPanel.updateAnnotation(false, true); // recompute any autoannotation + reorderAutoannotation(af, al, autoAlan); + af.alignPanel.alignmentChanged(); + return af; + } + + private ColourSchemeI constructAnnotationColour( + AnnotationColours viewAnnColour, AlignFrame af, Alignment al, + JalviewModelSequence jms, boolean checkGroupAnnColour) + { + boolean propagateAnnColour = false; + ColourSchemeI cs = null; + AlignmentI annAlignment = af != null ? af.viewport.getAlignment() : al; + if (checkGroupAnnColour && al.getGroups() != null + && al.getGroups().size() > 0) + { + // pre 2.8.1 behaviour + // check to see if we should transfer annotation colours + propagateAnnColour = true; + for (jalview.datamodel.SequenceGroup sg : al.getGroups()) + { + if (sg.cs instanceof AnnotationColourGradient) + { + propagateAnnColour = false; + } + } + } + // int find annotation + if (annAlignment.getAlignmentAnnotation() != null) + { + for (int i = 0; i < annAlignment.getAlignmentAnnotation().length; i++) + { + if (annAlignment.getAlignmentAnnotation()[i].label + .equals(viewAnnColour.getAnnotation())) + { + if (annAlignment.getAlignmentAnnotation()[i].getThreshold() == null) + { + annAlignment.getAlignmentAnnotation()[i] + .setThreshold(new jalview.datamodel.GraphLine( + viewAnnColour.getThreshold(), "Threshold", + java.awt.Color.black) + + ); + } + + if (viewAnnColour.getColourScheme().equals("None")) + { + cs = new AnnotationColourGradient( + annAlignment.getAlignmentAnnotation()[i], + new java.awt.Color(viewAnnColour.getMinColour()), + new java.awt.Color(viewAnnColour.getMaxColour()), + viewAnnColour.getAboveThreshold()); + } + else if (viewAnnColour.getColourScheme().startsWith("ucs")) + { + cs = new AnnotationColourGradient( + annAlignment.getAlignmentAnnotation()[i], + GetUserColourScheme(jms, + viewAnnColour.getColourScheme()), + viewAnnColour.getAboveThreshold()); + } + else + { + cs = new AnnotationColourGradient( + annAlignment.getAlignmentAnnotation()[i], + ColourSchemeProperty.getColour(al, + viewAnnColour.getColourScheme()), + viewAnnColour.getAboveThreshold()); + } + if (viewAnnColour.hasPerSequence()) + { + ((AnnotationColourGradient) cs).setSeqAssociated(viewAnnColour + .isPerSequence()); + } + if (viewAnnColour.hasPredefinedColours()) + { + ((AnnotationColourGradient) cs) + .setPredefinedColours(viewAnnColour + .isPredefinedColours()); + } + if (propagateAnnColour && al.getGroups() != null) + { + // Also use these settings for all the groups + for (int g = 0; g < al.getGroups().size(); g++) + { + jalview.datamodel.SequenceGroup sg = al.getGroups().get(g); + + if (sg.cs == null) + { + continue; + } + + /* + * if (viewAnnColour.getColourScheme().equals("None" )) { sg.cs = + * new AnnotationColourGradient( + * annAlignment.getAlignmentAnnotation()[i], new + * java.awt.Color(viewAnnColour. getMinColour()), new + * java.awt.Color(viewAnnColour. getMaxColour()), + * viewAnnColour.getAboveThreshold()); } else + */ + { + sg.cs = new AnnotationColourGradient( + annAlignment.getAlignmentAnnotation()[i], sg.cs, + viewAnnColour.getAboveThreshold()); + if (cs instanceof AnnotationColourGradient) + { + if (viewAnnColour.hasPerSequence()) + { + ((AnnotationColourGradient) cs) + .setSeqAssociated(viewAnnColour.isPerSequence()); + } + if (viewAnnColour.hasPredefinedColours()) + { + ((AnnotationColourGradient) cs) + .setPredefinedColours(viewAnnColour + .isPredefinedColours()); + } + } + } + + } + } + + break; + } + + } + } + return cs; + } + + private void reorderAutoannotation(AlignFrame af, Alignment al, + ArrayList autoAlan) + { + // copy over visualization settings for autocalculated annotation in the + // view + if (al.getAlignmentAnnotation() != null) + { + /** + * Kludge for magic autoannotation names (see JAL-811) + */ + String[] magicNames = new String[] + { "Consensus", "Quality", "Conservation" }; + JvAnnotRow nullAnnot = new JvAnnotRow(-1, null); + Hashtable visan = new Hashtable(); + for (String nm : magicNames) + { + visan.put(nm, nullAnnot); + } + for (JvAnnotRow auan : autoAlan) + { + visan.put(auan.template.label + + (auan.template.getCalcId() == null ? "" : "\t" + + auan.template.getCalcId()), auan); + } + int hSize = al.getAlignmentAnnotation().length; + ArrayList reorder = new ArrayList(); + // work through any autoCalculated annotation already on the view + // removing it if it should be placed in a different location on the + // annotation panel. + List remains = new ArrayList(visan.keySet()); + for (int h = 0; h < hSize; h++) + { + jalview.datamodel.AlignmentAnnotation jalan = al + .getAlignmentAnnotation()[h]; + if (jalan.autoCalculated) + { + String k; + JvAnnotRow valan = visan.get(k = jalan.label); + if (jalan.getCalcId() != null) + { + valan = visan.get(k = jalan.label + "\t" + jalan.getCalcId()); + } + + if (valan != null) + { + // delete the auto calculated row from the alignment + al.deleteAnnotation(jalan, false); + remains.remove(k); + hSize--; + h--; + if (valan != nullAnnot) + { + if (jalan != valan.template) + { + // newly created autoannotation row instance + // so keep a reference to the visible annotation row + // and copy over all relevant attributes + if (valan.template.graphHeight >= 0) + + { + jalan.graphHeight = valan.template.graphHeight; + } + jalan.visible = valan.template.visible; + } + reorder.add(new JvAnnotRow(valan.order, jalan)); + } + } + } + } + // Add any (possibly stale) autocalculated rows that were not appended to + // the view during construction + for (String other : remains) + { + JvAnnotRow othera = visan.get(other); + if (othera != nullAnnot && othera.template.getCalcId() != null + && othera.template.getCalcId().length() > 0) + { + reorder.add(othera); + } + } + // now put the automatic annotation in its correct place + int s = 0, srt[] = new int[reorder.size()]; + JvAnnotRow[] rws = new JvAnnotRow[reorder.size()]; + for (JvAnnotRow jvar : reorder) + { + rws[s] = jvar; + srt[s++] = jvar.order; + } + reorder.clear(); + jalview.util.QuickSort.sort(srt, rws); + // and re-insert the annotation at its correct position + for (JvAnnotRow jvar : rws) + { + al.addAnnotation(jvar.template, jvar.order); + } + af.alignPanel.adjustAnnotationHeight(); + } + } + + Hashtable skipList = null; + + /** + * TODO remove this method + * + * @param view + * @return AlignFrame bound to sequenceSetId from view, if one exists. private + * AlignFrame getSkippedFrame(Viewport view) { if (skipList==null) { + * throw new Error("Implementation Error. No skipList defined for this + * Jalview2XML instance."); } return (AlignFrame) + * skipList.get(view.getSequenceSetId()); } + */ + + /** + * Check if the Jalview view contained in object should be skipped or not. + * + * @param object + * @return true if view's sequenceSetId is a key in skipList + */ + private boolean skipViewport(JalviewModel object) + { + if (skipList == null) + { + return false; + } + String id; + if (skipList.containsKey(id = object.getJalviewModelSequence() + .getViewport()[0].getSequenceSetId())) + { + if (Cache.log != null && Cache.log.isDebugEnabled()) + { + Cache.log.debug("Skipping seuqence set id " + id); + } + return true; + } + return false; + } + + public void AddToSkipList(AlignFrame af) + { + if (skipList == null) + { + skipList = new Hashtable(); + } + skipList.put(af.getViewport().getSequenceSetId(), af); + } + + public void clearSkipList() + { + if (skipList != null) + { + skipList.clear(); + skipList = null; + } + } + + private void recoverDatasetFor(SequenceSet vamsasSet, Alignment al) + { + jalview.datamodel.Alignment ds = getDatasetFor(vamsasSet.getDatasetId()); + Vector dseqs = null; + if (ds == null) + { + // create a list of new dataset sequences + dseqs = new Vector(); + } + for (int i = 0, iSize = vamsasSet.getSequenceCount(); i < iSize; i++) + { + Sequence vamsasSeq = vamsasSet.getSequence(i); + ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs); + } + // create a new dataset + if (ds == null) + { + SequenceI[] dsseqs = new SequenceI[dseqs.size()]; + dseqs.copyInto(dsseqs); + ds = new jalview.datamodel.Alignment(dsseqs); + debug("Created new dataset " + vamsasSet.getDatasetId() + + " for alignment " + System.identityHashCode(al)); + addDatasetRef(vamsasSet.getDatasetId(), ds); + } + // set the dataset for the newly imported alignment. + if (al.getDataset() == null) + { + al.setDataset(ds); + } + } + + /** + * + * @param vamsasSeq + * sequence definition to create/merge dataset sequence for + * @param ds + * dataset alignment + * @param dseqs + * vector to add new dataset sequence to + */ + private void ensureJalviewDatasetSequence(Sequence vamsasSeq, + AlignmentI ds, Vector dseqs) + { + // JBP TODO: Check this is called for AlCodonFrames to support recovery of + // xRef Codon Maps + jalview.datamodel.Sequence sq = (jalview.datamodel.Sequence) seqRefIds + .get(vamsasSeq.getId()); + jalview.datamodel.SequenceI dsq = null; + if (sq != null && sq.getDatasetSequence() != null) + { + dsq = sq.getDatasetSequence(); + } + + String sqid = vamsasSeq.getDsseqid(); + if (dsq == null) + { + // need to create or add a new dataset sequence reference to this sequence + if (sqid != null) + { + dsq = (jalview.datamodel.SequenceI) seqRefIds.get(sqid); + } + // check again + if (dsq == null) + { + // make a new dataset sequence + dsq = sq.createDatasetSequence(); + if (sqid == null) + { + // make up a new dataset reference for this sequence + sqid = seqHash(dsq); + } + dsq.setVamsasId(uniqueSetSuffix + sqid); + seqRefIds.put(sqid, dsq); + if (ds == null) + { + if (dseqs != null) + { + dseqs.addElement(dsq); + } + } + else + { + ds.addSequence(dsq); + } + } + else + { + if (sq != dsq) + { // make this dataset sequence sq's dataset sequence + sq.setDatasetSequence(dsq); + // and update the current dataset alignment + if (ds == null) + { + if (dseqs != null) + { + if (!dseqs.contains(dsq)) + { + dseqs.add(dsq); + } + } + else + { + if (ds.findIndex(dsq) < 0) + { + ds.addSequence(dsq); + } + } + } + } + } + } + // TODO: refactor this as a merge dataset sequence function + // now check that sq (the dataset sequence) sequence really is the union of + // all references to it + // boolean pre = sq.getStart() < dsq.getStart(); + // boolean post = sq.getEnd() > dsq.getEnd(); + // if (pre || post) + if (sq != dsq) + { + StringBuffer sb = new StringBuffer(); + String newres = jalview.analysis.AlignSeq.extractGaps( + jalview.util.Comparison.GapChars, sq.getSequenceAsString()); + if (!newres.equalsIgnoreCase(dsq.getSequenceAsString()) + && newres.length() > dsq.getLength()) + { + // Update with the longer sequence. + synchronized (dsq) + { + /* + * if (pre) { sb.insert(0, newres .substring(0, dsq.getStart() - + * sq.getStart())); dsq.setStart(sq.getStart()); } if (post) { + * sb.append(newres.substring(newres.length() - sq.getEnd() - + * dsq.getEnd())); dsq.setEnd(sq.getEnd()); } + */ + dsq.setSequence(newres); + } + // TODO: merges will never happen if we 'know' we have the real dataset + // sequence - this should be detected when id==dssid + System.err + .println("DEBUG Notice: Merged dataset sequence (if you see this often, post at http://issues.jalview.org/browse/JAL-1474)"); // (" + // + (pre ? "prepended" : "") + " " + // + (post ? "appended" : "")); + } + } + } + + java.util.Hashtable datasetIds = null; + + java.util.IdentityHashMap dataset2Ids = null; + + private Alignment getDatasetFor(String datasetId) + { + if (datasetIds == null) + { + datasetIds = new Hashtable(); + return null; + } + if (datasetIds.containsKey(datasetId)) + { + return (Alignment) datasetIds.get(datasetId); + } + return null; + } + + private void addDatasetRef(String datasetId, Alignment dataset) + { + if (datasetIds == null) + { + datasetIds = new Hashtable(); + } + datasetIds.put(datasetId, dataset); + } + + /** + * make a new dataset ID for this jalview dataset alignment + * + * @param dataset + * @return + */ + private String getDatasetIdRef(jalview.datamodel.Alignment dataset) + { + if (dataset.getDataset() != null) + { + warn("Serious issue! Dataset Object passed to getDatasetIdRef is not a Jalview DATASET alignment..."); + } + String datasetId = makeHashCode(dataset, null); + if (datasetId == null) + { + // make a new datasetId and record it + if (dataset2Ids == null) + { + dataset2Ids = new IdentityHashMap(); + } + else + { + datasetId = (String) dataset2Ids.get(dataset); + } + if (datasetId == null) + { + datasetId = "ds" + dataset2Ids.size() + 1; + dataset2Ids.put(dataset, datasetId); + } + } + return datasetId; + } + + private void addDBRefs(SequenceI datasetSequence, Sequence sequence) + { + for (int d = 0; d < sequence.getDBRefCount(); d++) + { + DBRef dr = sequence.getDBRef(d); + jalview.datamodel.DBRefEntry entry = new jalview.datamodel.DBRefEntry( + sequence.getDBRef(d).getSource(), sequence.getDBRef(d) + .getVersion(), sequence.getDBRef(d).getAccessionId()); + if (dr.getMapping() != null) + { + entry.setMap(addMapping(dr.getMapping())); + } + datasetSequence.addDBRef(entry); + } + } + + private jalview.datamodel.Mapping addMapping(Mapping m) + { + SequenceI dsto = null; + // Mapping m = dr.getMapping(); + int fr[] = new int[m.getMapListFromCount() * 2]; + Enumeration f = m.enumerateMapListFrom(); + for (int _i = 0; f.hasMoreElements(); _i += 2) + { + MapListFrom mf = (MapListFrom) f.nextElement(); + fr[_i] = mf.getStart(); + fr[_i + 1] = mf.getEnd(); + } + int fto[] = new int[m.getMapListToCount() * 2]; + f = m.enumerateMapListTo(); + for (int _i = 0; f.hasMoreElements(); _i += 2) + { + MapListTo mf = (MapListTo) f.nextElement(); + fto[_i] = mf.getStart(); + fto[_i + 1] = mf.getEnd(); + } + jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto, + fr, fto, (int) m.getMapFromUnit(), (int) m.getMapToUnit()); + if (m.getMappingChoice() != null) + { + MappingChoice mc = m.getMappingChoice(); + if (mc.getDseqFor() != null) + { + String dsfor = "" + mc.getDseqFor(); + if (seqRefIds.containsKey(dsfor)) + { + /** + * recover from hash + */ + jmap.setTo((SequenceI) seqRefIds.get(dsfor)); + } + else + { + frefedSequence.add(new Object[] + { dsfor, jmap }); + } + } + else + { + /** + * local sequence definition + */ + Sequence ms = mc.getSequence(); + jalview.datamodel.Sequence djs = null; + String sqid = ms.getDsseqid(); + if (sqid != null && sqid.length() > 0) + { + /* + * recover dataset sequence + */ + djs = (jalview.datamodel.Sequence) seqRefIds.get(sqid); + } + else + { + System.err + .println("Warning - making up dataset sequence id for DbRef sequence map reference"); + sqid = ((Object) ms).toString(); // make up a new hascode for + // undefined dataset sequence hash + // (unlikely to happen) + } + + if (djs == null) + { + /** + * make a new dataset sequence and add it to refIds hash + */ + djs = new jalview.datamodel.Sequence(ms.getName(), + ms.getSequence()); + djs.setStart(jmap.getMap().getToLowest()); + djs.setEnd(jmap.getMap().getToHighest()); + djs.setVamsasId(uniqueSetSuffix + sqid); + jmap.setTo(djs); + seqRefIds.put(sqid, djs); + + } + jalview.bin.Cache.log.debug("about to recurse on addDBRefs."); + addDBRefs(djs, ms); + + } + } + return (jmap); + + } + + public jalview.gui.AlignmentPanel copyAlignPanel(AlignmentPanel ap, + boolean keepSeqRefs) + { + initSeqRefs(); + jalview.schemabinding.version2.JalviewModel jm = SaveState(ap, null, + null); + + if (!keepSeqRefs) + { + clearSeqRefs(); + jm.getJalviewModelSequence().getViewport(0).setSequenceSetId(null); + } + else + { + uniqueSetSuffix = ""; + jm.getJalviewModelSequence().getViewport(0).setId(null); // we don't + // overwrite the + // view we just + // copied + } + if (this.frefedSequence == null) + { + frefedSequence = new Vector(); + } + + viewportsAdded = new Hashtable(); + + AlignFrame af = LoadFromObject(jm, null, false, null); + af.alignPanels.clear(); + af.closeMenuItem_actionPerformed(true); + + /* + * if(ap.av.getAlignment().getAlignmentAnnotation()!=null) { for(int i=0; + * i