2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
7 * Jalview is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation, either version 3
10 * of the License, or (at your option) any later version.
12 * Jalview is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty
14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19 * The Jalview Authors are detailed in the 'AUTHORS' file.
23 import jalview.api.ViewStyleI;
24 import jalview.api.structures.JalviewStructureDisplayI;
25 import jalview.bin.Cache;
26 import jalview.datamodel.AlignedCodonFrame;
27 import jalview.datamodel.Alignment;
28 import jalview.datamodel.AlignmentAnnotation;
29 import jalview.datamodel.AlignmentI;
30 import jalview.datamodel.PDBEntry;
31 import jalview.datamodel.RnaViewerModel;
32 import jalview.datamodel.SequenceGroup;
33 import jalview.datamodel.SequenceI;
34 import jalview.datamodel.StructureViewerModel;
35 import jalview.datamodel.StructureViewerModel.StructureData;
36 import jalview.ext.varna.RnaModel;
37 import jalview.gui.StructureViewer.ViewerType;
38 import jalview.schemabinding.version2.AlcodMap;
39 import jalview.schemabinding.version2.AlcodonFrame;
40 import jalview.schemabinding.version2.Annotation;
41 import jalview.schemabinding.version2.AnnotationColours;
42 import jalview.schemabinding.version2.AnnotationElement;
43 import jalview.schemabinding.version2.CalcIdParam;
44 import jalview.schemabinding.version2.DBRef;
45 import jalview.schemabinding.version2.Features;
46 import jalview.schemabinding.version2.Group;
47 import jalview.schemabinding.version2.HiddenColumns;
48 import jalview.schemabinding.version2.JGroup;
49 import jalview.schemabinding.version2.JSeq;
50 import jalview.schemabinding.version2.JalviewModel;
51 import jalview.schemabinding.version2.JalviewModelSequence;
52 import jalview.schemabinding.version2.MapListFrom;
53 import jalview.schemabinding.version2.MapListTo;
54 import jalview.schemabinding.version2.Mapping;
55 import jalview.schemabinding.version2.MappingChoice;
56 import jalview.schemabinding.version2.OtherData;
57 import jalview.schemabinding.version2.PdbentryItem;
58 import jalview.schemabinding.version2.Pdbids;
59 import jalview.schemabinding.version2.Property;
60 import jalview.schemabinding.version2.RnaViewer;
61 import jalview.schemabinding.version2.SecondaryStructure;
62 import jalview.schemabinding.version2.Sequence;
63 import jalview.schemabinding.version2.SequenceSet;
64 import jalview.schemabinding.version2.SequenceSetProperties;
65 import jalview.schemabinding.version2.Setting;
66 import jalview.schemabinding.version2.StructureState;
67 import jalview.schemabinding.version2.ThresholdLine;
68 import jalview.schemabinding.version2.Tree;
69 import jalview.schemabinding.version2.UserColours;
70 import jalview.schemabinding.version2.Viewport;
71 import jalview.schemes.AnnotationColourGradient;
72 import jalview.schemes.ColourSchemeI;
73 import jalview.schemes.ColourSchemeProperty;
74 import jalview.schemes.GraduatedColor;
75 import jalview.schemes.ResidueColourScheme;
76 import jalview.schemes.ResidueProperties;
77 import jalview.schemes.UserColourScheme;
78 import jalview.structure.StructureSelectionManager;
79 import jalview.structures.models.AAStructureBindingModel;
80 import jalview.util.MessageManager;
81 import jalview.util.Platform;
82 import jalview.util.StringUtils;
83 import jalview.util.jarInputStreamProvider;
84 import jalview.viewmodel.AlignmentViewport;
85 import jalview.viewmodel.seqfeatures.FeatureRendererSettings;
86 import jalview.viewmodel.seqfeatures.FeaturesDisplayed;
87 import jalview.ws.jws2.Jws2Discoverer;
88 import jalview.ws.jws2.dm.AAConSettings;
89 import jalview.ws.jws2.jabaws2.Jws2Instance;
90 import jalview.ws.params.ArgumentI;
91 import jalview.ws.params.AutoCalcSetting;
92 import jalview.ws.params.WsParamSetI;
94 import java.awt.Color;
95 import java.awt.Rectangle;
96 import java.io.BufferedReader;
97 import java.io.DataInputStream;
98 import java.io.DataOutputStream;
100 import java.io.FileInputStream;
101 import java.io.FileOutputStream;
102 import java.io.IOException;
103 import java.io.InputStreamReader;
104 import java.io.OutputStreamWriter;
105 import java.io.PrintWriter;
106 import java.lang.reflect.InvocationTargetException;
107 import java.net.MalformedURLException;
109 import java.util.ArrayList;
110 import java.util.Enumeration;
111 import java.util.HashMap;
112 import java.util.HashSet;
113 import java.util.Hashtable;
114 import java.util.IdentityHashMap;
115 import java.util.Iterator;
116 import java.util.LinkedHashMap;
117 import java.util.List;
118 import java.util.Map;
119 import java.util.Map.Entry;
120 import java.util.Set;
121 import java.util.Vector;
122 import java.util.jar.JarEntry;
123 import java.util.jar.JarInputStream;
124 import java.util.jar.JarOutputStream;
126 import javax.swing.JInternalFrame;
127 import javax.swing.JOptionPane;
128 import javax.swing.SwingUtilities;
130 import org.exolab.castor.xml.Marshaller;
131 import org.exolab.castor.xml.Unmarshaller;
134 * Write out the current jalview desktop state as a Jalview XML stream.
136 * Note: the vamsas objects referred to here are primitive versions of the
137 * VAMSAS project schema elements - they are not the same and most likely never
141 * @version $Revision: 1.134 $
143 public class Jalview2XML
145 private static final String VIEWER_PREFIX = "viewer_";
147 private static final String RNA_PREFIX = "rna_";
149 private static final String UTF_8 = "UTF-8";
151 // use this with nextCounter() to make unique names for entities
152 private int counter = 0;
155 * SequenceI reference -> XML ID string in jalview XML. Populated as XML reps
156 * of sequence objects are created.
158 IdentityHashMap<SequenceI, String> seqsToIds = null;
161 * jalview XML Sequence ID to jalview sequence object reference (both dataset
162 * and alignment sequences. Populated as XML reps of sequence objects are
165 Map<String, SequenceI> seqRefIds = null;
167 Vector<Object[]> frefedSequence = null;
169 boolean raiseGUI = true; // whether errors are raised in dialog boxes or not
172 * Map of reconstructed AlignFrame objects that appear to have come from
173 * SplitFrame objects (have a dna/protein complement view).
175 private Map<Viewport, AlignFrame> splitFrameCandidates = new HashMap<Viewport, AlignFrame>();
178 * Map from displayed rna structure models to their saved session state jar
181 private Map<RnaModel, String> rnaSessions = new HashMap<RnaModel, String>();
184 * create/return unique hash string for sq
187 * @return new or existing unique string for sq
189 String seqHash(SequenceI sq)
191 if (seqsToIds == null)
195 if (seqsToIds.containsKey(sq))
197 return seqsToIds.get(sq);
201 // create sequential key
202 String key = "sq" + (seqsToIds.size() + 1);
203 key = makeHashCode(sq, key); // check we don't have an external reference
205 seqsToIds.put(sq, key);
214 if (seqRefIds != null)
218 if (seqsToIds != null)
228 warn("clearSeqRefs called when _cleartables was not set. Doing nothing.");
229 // seqRefIds = new Hashtable();
230 // seqsToIds = new IdentityHashMap();
236 if (seqsToIds == null)
238 seqsToIds = new IdentityHashMap<SequenceI, String>();
240 if (seqRefIds == null)
242 seqRefIds = new HashMap<String, SequenceI>();
250 public Jalview2XML(boolean raiseGUI)
252 this.raiseGUI = raiseGUI;
255 public void resolveFrefedSequences()
257 if (frefedSequence.size() > 0)
259 int r = 0, rSize = frefedSequence.size();
262 Object[] ref = frefedSequence.elementAt(r);
265 String sref = (String) ref[0];
266 if (seqRefIds.containsKey(sref))
268 if (ref[1] instanceof jalview.datamodel.Mapping)
270 SequenceI seq = seqRefIds.get(sref);
271 while (seq.getDatasetSequence() != null)
273 seq = seq.getDatasetSequence();
275 ((jalview.datamodel.Mapping) ref[1]).setTo(seq);
279 if (ref[1] instanceof jalview.datamodel.AlignedCodonFrame)
281 SequenceI seq = seqRefIds.get(sref);
282 while (seq.getDatasetSequence() != null)
284 seq = seq.getDatasetSequence();
287 && ref[2] instanceof jalview.datamodel.Mapping)
289 jalview.datamodel.Mapping mp = (jalview.datamodel.Mapping) ref[2];
290 ((jalview.datamodel.AlignedCodonFrame) ref[1]).addMap(
291 seq, mp.getTo(), mp.getMap());
296 .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for AlcodonFrames involving "
297 + ref[2].getClass() + " type objects.");
303 .println("IMPLEMENTATION ERROR: Unimplemented forward sequence references for "
304 + ref[1].getClass() + " type objects.");
307 frefedSequence.remove(r);
313 .println("IMPLEMENTATION WARNING: Unresolved forward reference for hash string "
315 + " with objecttype "
316 + ref[1].getClass());
323 frefedSequence.remove(r);
331 * This maintains a map of viewports, the key being the seqSetId. Important to
332 * set historyItem and redoList for multiple views
334 Map<String, AlignViewport> viewportsAdded = new HashMap<String, AlignViewport>();
336 Map<String, AlignmentAnnotation> annotationIds = new HashMap<String, AlignmentAnnotation>();
338 String uniqueSetSuffix = "";
341 * List of pdbfiles added to Jar
343 List<String> pdbfiles = null;
345 // SAVES SEVERAL ALIGNMENT WINDOWS TO SAME JARFILE
346 public void saveState(File statefile)
348 FileOutputStream fos = null;
351 fos = new FileOutputStream(statefile);
352 JarOutputStream jout = new JarOutputStream(fos);
355 } catch (Exception e)
357 // TODO: inform user of the problem - they need to know if their data was
359 if (errorMessage == null)
361 errorMessage = "Couldn't write Jalview Archive to output file '"
362 + statefile + "' - See console error log for details";
366 errorMessage += "(output file was '" + statefile + "')";
376 } catch (IOException e)
386 * Writes a jalview project archive to the given Jar output stream.
390 public void saveState(JarOutputStream jout)
392 AlignFrame[] frames = Desktop.getAlignFrames();
399 Hashtable<String, AlignFrame> dsses = new Hashtable<String, AlignFrame>();
402 * ensure cached data is clear before starting
404 // todo tidy up seqRefIds, seqsToIds initialisation / reset
406 splitFrameCandidates.clear();
411 // NOTE UTF-8 MUST BE USED FOR WRITING UNICODE CHARS
412 // //////////////////////////////////////////////////
414 List<String> shortNames = new ArrayList<String>();
415 List<String> viewIds = new ArrayList<String>();
418 for (int i = frames.length - 1; i > -1; i--)
420 AlignFrame af = frames[i];
424 .containsKey(af.getViewport().getSequenceSetId()))
429 String shortName = makeFilename(af, shortNames);
431 int ap, apSize = af.alignPanels.size();
433 for (ap = 0; ap < apSize; ap++)
435 AlignmentPanel apanel = af.alignPanels.get(ap);
436 String fileName = apSize == 1 ? shortName : ap + shortName;
437 if (!fileName.endsWith(".xml"))
439 fileName = fileName + ".xml";
442 saveState(apanel, fileName, jout, viewIds);
444 String dssid = getDatasetIdRef(af.getViewport().getAlignment()
446 if (!dsses.containsKey(dssid))
448 dsses.put(dssid, af);
453 writeDatasetFor(dsses, "" + jout.hashCode() + " " + uniqueSetSuffix,
459 } catch (Exception foo)
464 } catch (Exception ex)
466 // TODO: inform user of the problem - they need to know if their data was
468 if (errorMessage == null)
470 errorMessage = "Couldn't write Jalview Archive - see error output for details";
472 ex.printStackTrace();
477 * Generates a distinct file name, based on the title of the AlignFrame, by
478 * appending _n for increasing n until an unused name is generated. The new
479 * name (without its extension) is added to the list.
483 * @return the generated name, with .xml extension
485 protected String makeFilename(AlignFrame af, List<String> namesUsed)
487 String shortName = af.getTitle();
489 if (shortName.indexOf(File.separatorChar) > -1)
491 shortName = shortName.substring(shortName
492 .lastIndexOf(File.separatorChar) + 1);
497 while (namesUsed.contains(shortName))
499 if (shortName.endsWith("_" + (count - 1)))
501 shortName = shortName.substring(0, shortName.lastIndexOf("_"));
504 shortName = shortName.concat("_" + count);
508 namesUsed.add(shortName);
510 if (!shortName.endsWith(".xml"))
512 shortName = shortName + ".xml";
517 // USE THIS METHOD TO SAVE A SINGLE ALIGNMENT WINDOW
518 public boolean saveAlignment(AlignFrame af, String jarFile,
524 int apSize = af.alignPanels.size();
525 FileOutputStream fos = new FileOutputStream(jarFile);
526 JarOutputStream jout = new JarOutputStream(fos);
527 Hashtable<String, AlignFrame> dsses = new Hashtable<String, AlignFrame>();
528 List<String> viewIds = new ArrayList<String>();
530 for (AlignmentPanel apanel : af.alignPanels)
532 String jfileName = apSize == 1 ? fileName : fileName + ap;
534 if (!jfileName.endsWith(".xml"))
536 jfileName = jfileName + ".xml";
538 saveState(apanel, jfileName, jout, viewIds);
539 String dssid = getDatasetIdRef(af.getViewport().getAlignment()
541 if (!dsses.containsKey(dssid))
543 dsses.put(dssid, af);
546 writeDatasetFor(dsses, fileName, jout);
550 } catch (Exception foo)
556 } catch (Exception ex)
558 errorMessage = "Couldn't Write alignment view to Jalview Archive - see error output for details";
559 ex.printStackTrace();
564 private void writeDatasetFor(Hashtable<String, AlignFrame> dsses,
565 String fileName, JarOutputStream jout)
568 for (String dssids : dsses.keySet())
570 AlignFrame _af = dsses.get(dssids);
571 String jfileName = fileName + " Dataset for " + _af.getTitle();
572 if (!jfileName.endsWith(".xml"))
574 jfileName = jfileName + ".xml";
576 saveState(_af.alignPanel, jfileName, true, jout, null);
581 * create a JalviewModel from an alignment view and marshall it to a
585 * panel to create jalview model for
587 * name of alignment panel written to output stream
594 public JalviewModel saveState(AlignmentPanel ap, String fileName,
595 JarOutputStream jout, List<String> viewIds)
597 return saveState(ap, fileName, false, jout, viewIds);
601 * create a JalviewModel from an alignment view and marshall it to a
605 * panel to create jalview model for
607 * name of alignment panel written to output stream
609 * when true, only write the dataset for the alignment, not the data
610 * associated with the view.
616 public JalviewModel saveState(AlignmentPanel ap, String fileName,
617 boolean storeDS, JarOutputStream jout, List<String> viewIds)
621 viewIds = new ArrayList<String>();
626 List<UserColourScheme> userColours = new ArrayList<UserColourScheme>();
628 AlignViewport av = ap.av;
630 JalviewModel object = new JalviewModel();
631 object.setVamsasModel(new jalview.schemabinding.version2.VamsasModel());
633 object.setCreationDate(new java.util.Date(System.currentTimeMillis()));
634 object.setVersion(jalview.bin.Cache.getDefault("VERSION",
635 "Development Build"));
637 jalview.datamodel.AlignmentI jal = av.getAlignment();
639 if (av.hasHiddenRows())
641 jal = jal.getHiddenSequences().getFullAlignment();
644 SequenceSet vamsasSet = new SequenceSet();
646 JalviewModelSequence jms = new JalviewModelSequence();
648 vamsasSet.setGapChar(jal.getGapCharacter() + "");
650 if (jal.getDataset() != null)
652 // dataset id is the dataset's hashcode
653 vamsasSet.setDatasetId(getDatasetIdRef(jal.getDataset()));
656 // switch jal and the dataset
657 jal = jal.getDataset();
660 if (jal.getProperties() != null)
662 Enumeration en = jal.getProperties().keys();
663 while (en.hasMoreElements())
665 String key = en.nextElement().toString();
666 SequenceSetProperties ssp = new SequenceSetProperties();
668 ssp.setValue(jal.getProperties().get(key).toString());
669 vamsasSet.addSequenceSetProperties(ssp);
674 Set<String> calcIdSet = new HashSet<String>();
677 for (int i = 0; i < jal.getHeight(); i++)
679 final SequenceI jds = jal.getSequenceAt(i);
680 final SequenceI jdatasq = jds.getDatasetSequence() == null ? jds
681 : jds.getDatasetSequence();
682 String id = seqHash(jds);
684 if (seqRefIds.get(id) != null)
686 // This happens for two reasons: 1. multiple views are being serialised.
687 // 2. the hashCode has collided with another sequence's code. This DOES
688 // HAPPEN! (PF00072.15.stk does this)
689 // JBPNote: Uncomment to debug writing out of files that do not read
690 // back in due to ArrayOutOfBoundExceptions.
691 // System.err.println("vamsasSeq backref: "+id+"");
692 // System.err.println(jds.getName()+"
693 // "+jds.getStart()+"-"+jds.getEnd()+" "+jds.getSequenceAsString());
694 // System.err.println("Hashcode: "+seqHash(jds));
695 // SequenceI rsq = (SequenceI) seqRefIds.get(id + "");
696 // System.err.println(rsq.getName()+"
697 // "+rsq.getStart()+"-"+rsq.getEnd()+" "+rsq.getSequenceAsString());
698 // System.err.println("Hashcode: "+seqHash(rsq));
702 vamsasSeq = createVamsasSequence(id, jds);
703 vamsasSet.addSequence(vamsasSeq);
704 seqRefIds.put(id, jds);
708 jseq.setStart(jds.getStart());
709 jseq.setEnd(jds.getEnd());
710 jseq.setColour(av.getSequenceColour(jds).getRGB());
712 jseq.setId(id); // jseq id should be a string not a number
715 // Store any sequences this sequence represents
716 if (av.hasHiddenRows())
718 jseq.setHidden(av.getAlignment().getHiddenSequences()
721 if (av.isHiddenRepSequence(jal.getSequenceAt(i)))
723 jalview.datamodel.SequenceI[] reps = av
724 .getRepresentedSequences(jal.getSequenceAt(i))
725 .getSequencesInOrder(jal);
727 for (int h = 0; h < reps.length; h++)
729 if (reps[h] != jal.getSequenceAt(i))
731 jseq.addHiddenSequences(jal.findIndex(reps[h]));
738 if (jds.getSequenceFeatures() != null)
740 jalview.datamodel.SequenceFeature[] sf = jds.getSequenceFeatures();
742 while (index < sf.length)
744 Features features = new Features();
746 features.setBegin(sf[index].getBegin());
747 features.setEnd(sf[index].getEnd());
748 features.setDescription(sf[index].getDescription());
749 features.setType(sf[index].getType());
750 features.setFeatureGroup(sf[index].getFeatureGroup());
751 features.setScore(sf[index].getScore());
752 if (sf[index].links != null)
754 for (int l = 0; l < sf[index].links.size(); l++)
756 OtherData keyValue = new OtherData();
757 keyValue.setKey("LINK_" + l);
758 keyValue.setValue(sf[index].links.elementAt(l).toString());
759 features.addOtherData(keyValue);
762 if (sf[index].otherDetails != null)
765 Iterator<String> keys = sf[index].otherDetails.keySet()
767 while (keys.hasNext())
770 OtherData keyValue = new OtherData();
771 keyValue.setKey(key);
772 keyValue.setValue(sf[index].otherDetails.get(key).toString());
773 features.addOtherData(keyValue);
777 jseq.addFeatures(features);
782 if (jdatasq.getAllPDBEntries() != null)
784 Enumeration en = jdatasq.getAllPDBEntries().elements();
785 while (en.hasMoreElements())
787 Pdbids pdb = new Pdbids();
788 jalview.datamodel.PDBEntry entry = (jalview.datamodel.PDBEntry) en
791 String pdbId = entry.getId();
793 pdb.setType(entry.getType());
796 * Store any structure views associated with this sequence. This
797 * section copes with duplicate entries in the project, so a dataset
798 * only view *should* be coped with sensibly.
800 // This must have been loaded, is it still visible?
801 JInternalFrame[] frames = Desktop.desktop.getAllFrames();
802 String matchedFile = null;
803 for (int f = frames.length - 1; f > -1; f--)
805 if (frames[f] instanceof StructureViewerBase)
807 StructureViewerBase viewFrame = (StructureViewerBase) frames[f];
808 matchedFile = saveStructureState(ap, jds, pdb, entry,
809 viewIds, matchedFile, viewFrame);
811 * Only store each structure viewer's state once in the project
812 * jar. First time through only (storeDS==false)
814 String viewId = viewFrame.getViewId();
815 if (!storeDS && !viewIds.contains(viewId))
820 String viewerState = viewFrame.getStateInfo();
821 writeJarEntry(jout, getViewerJarEntryName(viewId),
822 viewerState.getBytes());
823 } catch (IOException e)
825 System.err.println("Error saving viewer state: "
832 if (matchedFile != null || entry.getFile() != null)
834 if (entry.getFile() != null)
837 matchedFile = entry.getFile();
839 pdb.setFile(matchedFile); // entry.getFile());
840 if (pdbfiles == null)
842 pdbfiles = new ArrayList<String>();
845 if (!pdbfiles.contains(pdbId))
848 copyFileToJar(jout, matchedFile, pdbId);
852 if (entry.getProperty() != null && !entry.getProperty().isEmpty())
854 PdbentryItem item = new PdbentryItem();
855 Hashtable properties = entry.getProperty();
856 Enumeration en2 = properties.keys();
857 while (en2.hasMoreElements())
859 Property prop = new Property();
860 String key = en2.nextElement().toString();
862 prop.setValue(properties.get(key).toString());
863 item.addProperty(prop);
865 pdb.addPdbentryItem(item);
872 saveRnaViewers(jout, jseq, jds, viewIds, ap, storeDS);
877 if (!storeDS && av.hasHiddenRows())
879 jal = av.getAlignment();
882 if (jal.getCodonFrames() != null)
884 List<AlignedCodonFrame> jac = jal.getCodonFrames();
885 for (AlignedCodonFrame acf : jac)
887 AlcodonFrame alc = new AlcodonFrame();
888 vamsasSet.addAlcodonFrame(alc);
889 if (acf.getProtMappings() != null
890 && acf.getProtMappings().length > 0)
892 SequenceI[] dnas = acf.getdnaSeqs();
893 jalview.datamodel.Mapping[] pmaps = acf.getProtMappings();
894 for (int m = 0; m < pmaps.length; m++)
896 AlcodMap alcmap = new AlcodMap();
897 alcmap.setDnasq(seqHash(dnas[m]));
898 alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null,
900 alc.addAlcodMap(alcmap);
905 // AlcodonFrame alc = new AlcodonFrame();
906 // vamsasSet.addAlcodonFrame(alc);
907 // for (int p = 0; p < acf.aaWidth; p++)
909 // Alcodon cmap = new Alcodon();
910 // if (acf.codons[p] != null)
912 // // Null codons indicate a gapped column in the translated peptide
914 // cmap.setPos1(acf.codons[p][0]);
915 // cmap.setPos2(acf.codons[p][1]);
916 // cmap.setPos3(acf.codons[p][2]);
918 // alc.addAlcodon(cmap);
920 // if (acf.getProtMappings() != null
921 // && acf.getProtMappings().length > 0)
923 // SequenceI[] dnas = acf.getdnaSeqs();
924 // jalview.datamodel.Mapping[] pmaps = acf.getProtMappings();
925 // for (int m = 0; m < pmaps.length; m++)
927 // AlcodMap alcmap = new AlcodMap();
928 // alcmap.setDnasq(seqHash(dnas[m]));
929 // alcmap.setMapping(createVamsasMapping(pmaps[m], dnas[m], null,
931 // alc.addAlcodMap(alcmap);
938 // /////////////////////////////////
939 if (!storeDS && av.currentTree != null)
941 // FIND ANY ASSOCIATED TREES
942 // NOT IMPLEMENTED FOR HEADLESS STATE AT PRESENT
943 if (Desktop.desktop != null)
945 JInternalFrame[] frames = Desktop.desktop.getAllFrames();
947 for (int t = 0; t < frames.length; t++)
949 if (frames[t] instanceof TreePanel)
951 TreePanel tp = (TreePanel) frames[t];
953 if (tp.treeCanvas.av.getAlignment() == jal)
955 Tree tree = new Tree();
956 tree.setTitle(tp.getTitle());
957 tree.setCurrentTree((av.currentTree == tp.getTree()));
958 tree.setNewick(tp.getTree().toString());
959 tree.setThreshold(tp.treeCanvas.threshold);
961 tree.setFitToWindow(tp.fitToWindow.getState());
962 tree.setFontName(tp.getTreeFont().getName());
963 tree.setFontSize(tp.getTreeFont().getSize());
964 tree.setFontStyle(tp.getTreeFont().getStyle());
965 tree.setMarkUnlinked(tp.placeholdersMenu.getState());
967 tree.setShowBootstrap(tp.bootstrapMenu.getState());
968 tree.setShowDistances(tp.distanceMenu.getState());
970 tree.setHeight(tp.getHeight());
971 tree.setWidth(tp.getWidth());
972 tree.setXpos(tp.getX());
973 tree.setYpos(tp.getY());
974 tree.setId(makeHashCode(tp, null));
984 * store forward refs from an annotationRow to any groups
986 IdentityHashMap<SequenceGroup, String> groupRefs = new IdentityHashMap<SequenceGroup, String>();
989 for (SequenceI sq : jal.getSequences())
991 // Store annotation on dataset sequences only
992 AlignmentAnnotation[] aa = sq.getAnnotation();
993 if (aa != null && aa.length > 0)
995 storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS,
1002 if (jal.getAlignmentAnnotation() != null)
1004 // Store the annotation shown on the alignment.
1005 AlignmentAnnotation[] aa = jal.getAlignmentAnnotation();
1006 storeAlignmentAnnotation(aa, groupRefs, av, calcIdSet, storeDS,
1011 if (jal.getGroups() != null)
1013 JGroup[] groups = new JGroup[jal.getGroups().size()];
1015 for (jalview.datamodel.SequenceGroup sg : jal.getGroups())
1017 JGroup jGroup = new JGroup();
1018 groups[++i] = jGroup;
1020 jGroup.setStart(sg.getStartRes());
1021 jGroup.setEnd(sg.getEndRes());
1022 jGroup.setName(sg.getName());
1023 if (groupRefs.containsKey(sg))
1025 // group has references so set its ID field
1026 jGroup.setId(groupRefs.get(sg));
1030 if (sg.cs.conservationApplied())
1032 jGroup.setConsThreshold(sg.cs.getConservationInc());
1034 if (sg.cs instanceof jalview.schemes.UserColourScheme)
1036 jGroup.setColour(setUserColourScheme(sg.cs, userColours, jms));
1040 jGroup.setColour(ColourSchemeProperty.getColourName(sg.cs));
1043 else if (sg.cs instanceof jalview.schemes.AnnotationColourGradient)
1045 jGroup.setColour("AnnotationColourGradient");
1046 jGroup.setAnnotationColours(constructAnnotationColours(
1047 (jalview.schemes.AnnotationColourGradient) sg.cs,
1050 else if (sg.cs instanceof jalview.schemes.UserColourScheme)
1052 jGroup.setColour(setUserColourScheme(sg.cs, userColours, jms));
1056 jGroup.setColour(ColourSchemeProperty.getColourName(sg.cs));
1059 jGroup.setPidThreshold(sg.cs.getThreshold());
1062 jGroup.setOutlineColour(sg.getOutlineColour().getRGB());
1063 jGroup.setDisplayBoxes(sg.getDisplayBoxes());
1064 jGroup.setDisplayText(sg.getDisplayText());
1065 jGroup.setColourText(sg.getColourText());
1066 jGroup.setTextCol1(sg.textColour.getRGB());
1067 jGroup.setTextCol2(sg.textColour2.getRGB());
1068 jGroup.setTextColThreshold(sg.thresholdTextColour);
1069 jGroup.setShowUnconserved(sg.getShowNonconserved());
1070 jGroup.setIgnoreGapsinConsensus(sg.getIgnoreGapsConsensus());
1071 jGroup.setShowConsensusHistogram(sg.isShowConsensusHistogram());
1072 jGroup.setShowSequenceLogo(sg.isShowSequenceLogo());
1073 jGroup.setNormaliseSequenceLogo(sg.isNormaliseSequenceLogo());
1074 for (SequenceI seq : sg.getSequences())
1076 jGroup.addSeq(seqHash(seq));
1080 jms.setJGroup(groups);
1084 // /////////SAVE VIEWPORT
1085 Viewport view = new Viewport();
1086 view.setTitle(ap.alignFrame.getTitle());
1087 view.setSequenceSetId(makeHashCode(av.getSequenceSetId(),
1088 av.getSequenceSetId()));
1089 view.setId(av.getViewId());
1090 if (av.getCodingComplement() != null)
1092 view.setComplementId(av.getCodingComplement().getViewId());
1094 view.setViewName(av.viewName);
1095 view.setGatheredViews(av.isGatherViewsHere());
1097 Rectangle size = ap.av.getExplodedGeometry();
1098 Rectangle position = size;
1101 size = ap.alignFrame.getBounds();
1102 if (av.getCodingComplement() != null)
1104 position = ((SplitFrame) ap.alignFrame.getSplitViewContainer())
1112 view.setXpos(position.x);
1113 view.setYpos(position.y);
1115 view.setWidth(size.width);
1116 view.setHeight(size.height);
1118 view.setStartRes(av.startRes);
1119 view.setStartSeq(av.startSeq);
1121 if (av.getGlobalColourScheme() instanceof jalview.schemes.UserColourScheme)
1123 view.setBgColour(setUserColourScheme(av.getGlobalColourScheme(),
1126 else if (av.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient)
1128 AnnotationColours ac = constructAnnotationColours(
1129 (jalview.schemes.AnnotationColourGradient) av
1130 .getGlobalColourScheme(),
1133 view.setAnnotationColours(ac);
1134 view.setBgColour("AnnotationColourGradient");
1138 view.setBgColour(ColourSchemeProperty.getColourName(av
1139 .getGlobalColourScheme()));
1142 ColourSchemeI cs = av.getGlobalColourScheme();
1146 if (cs.conservationApplied())
1148 view.setConsThreshold(cs.getConservationInc());
1149 if (cs instanceof jalview.schemes.UserColourScheme)
1151 view.setBgColour(setUserColourScheme(cs, userColours, jms));
1155 if (cs instanceof ResidueColourScheme)
1157 view.setPidThreshold(cs.getThreshold());
1161 view.setConservationSelected(av.getConservationSelected());
1162 view.setPidSelected(av.getAbovePIDThreshold());
1163 view.setFontName(av.font.getName());
1164 view.setFontSize(av.font.getSize());
1165 view.setFontStyle(av.font.getStyle());
1166 view.setScaleProteinAsCdna(av.getViewStyle().isScaleProteinAsCdna());
1167 view.setRenderGaps(av.isRenderGaps());
1168 view.setShowAnnotation(av.isShowAnnotation());
1169 view.setShowBoxes(av.getShowBoxes());
1170 view.setShowColourText(av.getColourText());
1171 view.setShowFullId(av.getShowJVSuffix());
1172 view.setRightAlignIds(av.isRightAlignIds());
1173 view.setShowSequenceFeatures(av.isShowSequenceFeatures());
1174 view.setShowText(av.getShowText());
1175 view.setShowUnconserved(av.getShowUnconserved());
1176 view.setWrapAlignment(av.getWrapAlignment());
1177 view.setTextCol1(av.getTextColour().getRGB());
1178 view.setTextCol2(av.getTextColour2().getRGB());
1179 view.setTextColThreshold(av.getThresholdTextColour());
1180 view.setShowConsensusHistogram(av.isShowConsensusHistogram());
1181 view.setShowSequenceLogo(av.isShowSequenceLogo());
1182 view.setNormaliseSequenceLogo(av.isNormaliseSequenceLogo());
1183 view.setShowGroupConsensus(av.isShowGroupConsensus());
1184 view.setShowGroupConservation(av.isShowGroupConservation());
1185 view.setShowNPfeatureTooltip(av.isShowNPFeats());
1186 view.setShowDbRefTooltip(av.isShowDBRefs());
1187 view.setFollowHighlight(av.isFollowHighlight());
1188 view.setFollowSelection(av.followSelection);
1189 view.setIgnoreGapsinConsensus(av.isIgnoreGapsConsensus());
1190 if (av.getFeaturesDisplayed() != null)
1192 jalview.schemabinding.version2.FeatureSettings fs = new jalview.schemabinding.version2.FeatureSettings();
1194 String[] renderOrder = ap.getSeqPanel().seqCanvas
1195 .getFeatureRenderer().getRenderOrder()
1196 .toArray(new String[0]);
1198 Vector<String> settingsAdded = new Vector<String>();
1199 Object gstyle = null;
1200 GraduatedColor gcol = null;
1201 if (renderOrder != null)
1203 for (String featureType : renderOrder)
1205 gstyle = ap.getSeqPanel().seqCanvas.getFeatureRenderer()
1206 .getFeatureStyle(featureType);
1207 Setting setting = new Setting();
1208 setting.setType(featureType);
1209 if (gstyle instanceof GraduatedColor)
1211 gcol = (GraduatedColor) gstyle;
1212 setting.setColour(gcol.getMaxColor().getRGB());
1213 setting.setMincolour(gcol.getMinColor().getRGB());
1214 setting.setMin(gcol.getMin());
1215 setting.setMax(gcol.getMax());
1216 setting.setColourByLabel(gcol.isColourByLabel());
1217 setting.setAutoScale(gcol.isAutoScale());
1218 setting.setThreshold(gcol.getThresh());
1219 setting.setThreshstate(gcol.getThreshType());
1223 setting.setColour(((Color) gstyle).getRGB());
1226 setting.setDisplay(av.getFeaturesDisplayed().isVisible(
1228 float rorder = ap.getSeqPanel().seqCanvas.getFeatureRenderer()
1229 .getOrder(featureType);
1232 setting.setOrder(rorder);
1234 fs.addSetting(setting);
1235 settingsAdded.addElement(featureType);
1239 // is groups actually supposed to be a map here ?
1240 Iterator<String> en = ap.getSeqPanel().seqCanvas
1241 .getFeatureRenderer()
1242 .getFeatureGroups().iterator();
1243 Vector<String> groupsAdded = new Vector<String>();
1244 while (en.hasNext())
1246 String grp = en.next();
1247 if (groupsAdded.contains(grp))
1251 Group g = new Group();
1253 g.setDisplay(((Boolean) ap.getSeqPanel().seqCanvas
1254 .getFeatureRenderer().checkGroupVisibility(grp, false))
1257 groupsAdded.addElement(grp);
1259 jms.setFeatureSettings(fs);
1263 if (av.hasHiddenColumns())
1265 if (av.getColumnSelection() == null
1266 || av.getColumnSelection().getHiddenColumns() == null)
1268 warn("REPORT BUG: avoided null columnselection bug (DMAM reported). Please contact Jim about this.");
1272 for (int c = 0; c < av.getColumnSelection().getHiddenColumns()
1275 int[] region = av.getColumnSelection().getHiddenColumns()
1277 HiddenColumns hc = new HiddenColumns();
1278 hc.setStart(region[0]);
1279 hc.setEnd(region[1]);
1280 view.addHiddenColumns(hc);
1284 if (calcIdSet.size() > 0)
1286 for (String calcId : calcIdSet)
1288 if (calcId.trim().length() > 0)
1290 CalcIdParam cidp = createCalcIdParam(calcId, av);
1291 // Some calcIds have no parameters.
1294 view.addCalcIdParam(cidp);
1300 jms.addViewport(view);
1302 object.setJalviewModelSequence(jms);
1303 object.getVamsasModel().addSequenceSet(vamsasSet);
1305 if (jout != null && fileName != null)
1307 // We may not want to write the object to disk,
1308 // eg we can copy the alignViewport to a new view object
1309 // using save and then load
1312 System.out.println("Writing jar entry " + fileName);
1313 JarEntry entry = new JarEntry(fileName);
1314 jout.putNextEntry(entry);
1315 PrintWriter pout = new PrintWriter(new OutputStreamWriter(jout,
1317 Marshaller marshaller = new Marshaller(pout);
1318 marshaller.marshal(object);
1321 } catch (Exception ex)
1323 // TODO: raise error in GUI if marshalling failed.
1324 ex.printStackTrace();
1331 * Save any Varna viewers linked to this sequence. Writes an rnaViewer element
1332 * for each viewer, with
1334 * <li>viewer geometry (position, size, split pane divider location)</li>
1335 * <li>index of the selected structure in the viewer (currently shows gapped
1337 * <li>the id of the annotation holding RNA secondary structure</li>
1338 * <li>(currently only one SS is shown per viewer, may be more in future)</li>
1340 * Varna viewer state is also written out (in native Varna XML) to separate
1341 * project jar entries. A separate entry is written for each RNA structure
1342 * displayed, with the naming convention
1344 * <li>rna_viewId_sequenceId_annotationId_[gapped|trimmed]</li>
1352 * @param storeDataset
1354 protected void saveRnaViewers(JarOutputStream jout, JSeq jseq,
1355 final SequenceI jds, List<String> viewIds, AlignmentPanel ap,
1356 boolean storeDataset)
1358 if (Desktop.desktop == null)
1362 JInternalFrame[] frames = Desktop.desktop.getAllFrames();
1363 for (int f = frames.length - 1; f > -1; f--)
1365 if (frames[f] instanceof AppVarna)
1367 AppVarna varna = (AppVarna) frames[f];
1369 * link the sequence to every viewer that is showing it and is linked to
1370 * its alignment panel
1372 if (varna.isListeningFor(jds) && ap == varna.getAlignmentPanel())
1374 String viewId = varna.getViewId();
1375 RnaViewer rna = new RnaViewer();
1376 rna.setViewId(viewId);
1377 rna.setTitle(varna.getTitle());
1378 rna.setXpos(varna.getX());
1379 rna.setYpos(varna.getY());
1380 rna.setWidth(varna.getWidth());
1381 rna.setHeight(varna.getHeight());
1382 rna.setDividerLocation(varna.getDividerLocation());
1383 rna.setSelectedRna(varna.getSelectedIndex());
1384 jseq.addRnaViewer(rna);
1387 * Store each Varna panel's state once in the project per sequence.
1388 * First time through only (storeDataset==false)
1390 // boolean storeSessions = false;
1391 // String sequenceViewId = viewId + seqsToIds.get(jds);
1392 // if (!storeDataset && !viewIds.contains(sequenceViewId))
1394 // viewIds.add(sequenceViewId);
1395 // storeSessions = true;
1397 for (RnaModel model : varna.getModels())
1399 if (model.seq == jds)
1402 * VARNA saves each view (sequence or alignment secondary
1403 * structure, gapped or trimmed) as a separate XML file
1405 String jarEntryName = rnaSessions.get(model);
1406 if (jarEntryName == null)
1409 String varnaStateFile = varna.getStateInfo(model.rna);
1410 jarEntryName = RNA_PREFIX + viewId + "_" + nextCounter();
1411 copyFileToJar(jout, varnaStateFile, jarEntryName);
1412 rnaSessions.put(model, jarEntryName);
1414 SecondaryStructure ss = new SecondaryStructure();
1415 String annotationId = varna.getAnnotation(jds).annotationId;
1416 ss.setAnnotationId(annotationId);
1417 ss.setViewerState(jarEntryName);
1418 ss.setGapped(model.gapped);
1419 ss.setTitle(model.title);
1420 rna.addSecondaryStructure(ss);
1429 * Copy the contents of a file to a new entry added to the output jar
1433 * @param jarEntryName
1435 protected void copyFileToJar(JarOutputStream jout, String infilePath,
1436 String jarEntryName)
1438 DataInputStream dis = null;
1441 File file = new File(infilePath);
1442 if (file.exists() && jout != null)
1444 dis = new DataInputStream(new FileInputStream(file));
1445 byte[] data = new byte[(int) file.length()];
1446 dis.readFully(data);
1447 writeJarEntry(jout, jarEntryName, data);
1449 } catch (Exception ex)
1451 ex.printStackTrace();
1459 } catch (IOException e)
1468 * Write the data to a new entry of given name in the output jar file
1471 * @param jarEntryName
1473 * @throws IOException
1475 protected void writeJarEntry(JarOutputStream jout, String jarEntryName,
1476 byte[] data) throws IOException
1480 System.out.println("Writing jar entry " + jarEntryName);
1481 jout.putNextEntry(new JarEntry(jarEntryName));
1482 DataOutputStream dout = new DataOutputStream(jout);
1483 dout.write(data, 0, data.length);
1490 * Save the state of a structure viewer
1495 * the archive XML element under which to save the state
1498 * @param matchedFile
1502 protected String saveStructureState(AlignmentPanel ap, SequenceI jds,
1503 Pdbids pdb, PDBEntry entry, List<String> viewIds,
1504 String matchedFile, StructureViewerBase viewFrame)
1506 final AAStructureBindingModel bindingModel = viewFrame.getBinding();
1509 * Look for any bindings for this viewer to the PDB file of interest
1510 * (including part matches excluding chain id)
1512 for (int peid = 0; peid < bindingModel.getPdbCount(); peid++)
1514 final PDBEntry pdbentry = bindingModel.getPdbEntry(peid);
1515 final String pdbId = pdbentry.getId();
1516 if (!pdbId.equals(entry.getId())
1517 && !(entry.getId().length() > 4 && entry.getId()
1518 .toLowerCase().startsWith(pdbId.toLowerCase())))
1521 * not interested in a binding to a different PDB entry here
1525 if (matchedFile == null)
1527 matchedFile = pdbentry.getFile();
1529 else if (!matchedFile.equals(pdbentry.getFile()))
1532 .warn("Probably lost some PDB-Sequence mappings for this structure file (which apparently has same PDB Entry code): "
1533 + pdbentry.getFile());
1537 // can get at it if the ID
1538 // match is ambiguous (e.g.
1541 for (int smap = 0; smap < viewFrame.getBinding().getSequence()[peid].length; smap++)
1543 // if (jal.findIndex(jmol.jmb.sequence[peid][smap]) > -1)
1544 if (jds == viewFrame.getBinding().getSequence()[peid][smap])
1546 StructureState state = new StructureState();
1547 state.setVisible(true);
1548 state.setXpos(viewFrame.getX());
1549 state.setYpos(viewFrame.getY());
1550 state.setWidth(viewFrame.getWidth());
1551 state.setHeight(viewFrame.getHeight());
1552 final String viewId = viewFrame.getViewId();
1553 state.setViewId(viewId);
1554 state.setAlignwithAlignPanel(viewFrame.isUsedforaligment(ap));
1555 state.setColourwithAlignPanel(viewFrame.isUsedforcolourby(ap));
1556 state.setColourByJmol(viewFrame.isColouredByViewer());
1557 state.setType(viewFrame.getViewerType().toString());
1558 pdb.addStructureState(state);
1565 private AnnotationColours constructAnnotationColours(
1566 AnnotationColourGradient acg, List<UserColourScheme> userColours,
1567 JalviewModelSequence jms)
1569 AnnotationColours ac = new AnnotationColours();
1570 ac.setAboveThreshold(acg.getAboveThreshold());
1571 ac.setThreshold(acg.getAnnotationThreshold());
1572 ac.setAnnotation(acg.getAnnotation());
1573 if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
1575 ac.setColourScheme(setUserColourScheme(acg.getBaseColour(),
1580 ac.setColourScheme(ColourSchemeProperty.getColourName(acg
1584 ac.setMaxColour(acg.getMaxColour().getRGB());
1585 ac.setMinColour(acg.getMinColour().getRGB());
1586 ac.setPerSequence(acg.isSeqAssociated());
1587 ac.setPredefinedColours(acg.isPredefinedColours());
1591 private void storeAlignmentAnnotation(AlignmentAnnotation[] aa,
1592 IdentityHashMap<SequenceGroup, String> groupRefs,
1593 AlignmentViewport av, Set<String> calcIdSet, boolean storeDS,
1594 SequenceSet vamsasSet)
1597 for (int i = 0; i < aa.length; i++)
1599 Annotation an = new Annotation();
1601 AlignmentAnnotation annotation = aa[i];
1602 if (annotation.annotationId != null)
1604 annotationIds.put(annotation.annotationId, annotation);
1607 an.setId(annotation.annotationId);
1609 an.setVisible(annotation.visible);
1611 an.setDescription(annotation.description);
1613 if (annotation.sequenceRef != null)
1615 // 2.9 JAL-1781 xref on sequence id rather than name
1616 an.setSequenceRef(seqsToIds.get(annotation.sequenceRef));
1618 if (annotation.groupRef != null)
1620 String groupIdr = groupRefs.get(annotation.groupRef);
1621 if (groupIdr == null)
1623 // make a locally unique String
1625 annotation.groupRef,
1626 groupIdr = ("" + System.currentTimeMillis()
1627 + annotation.groupRef.getName() + groupRefs
1630 an.setGroupRef(groupIdr.toString());
1633 // store all visualization attributes for annotation
1634 an.setGraphHeight(annotation.graphHeight);
1635 an.setCentreColLabels(annotation.centreColLabels);
1636 an.setScaleColLabels(annotation.scaleColLabel);
1637 an.setShowAllColLabels(annotation.showAllColLabels);
1638 an.setBelowAlignment(annotation.belowAlignment);
1640 if (annotation.graph > 0)
1643 an.setGraphType(annotation.graph);
1644 an.setGraphGroup(annotation.graphGroup);
1645 if (annotation.getThreshold() != null)
1647 ThresholdLine line = new ThresholdLine();
1648 line.setLabel(annotation.getThreshold().label);
1649 line.setValue(annotation.getThreshold().value);
1650 line.setColour(annotation.getThreshold().colour.getRGB());
1651 an.setThresholdLine(line);
1659 an.setLabel(annotation.label);
1661 if (annotation == av.getAlignmentQualityAnnot()
1662 || annotation == av.getAlignmentConservationAnnotation()
1663 || annotation == av.getAlignmentConsensusAnnotation()
1664 || annotation.autoCalculated)
1666 // new way of indicating autocalculated annotation -
1667 an.setAutoCalculated(annotation.autoCalculated);
1669 if (annotation.hasScore())
1671 an.setScore(annotation.getScore());
1674 if (annotation.getCalcId() != null)
1676 calcIdSet.add(annotation.getCalcId());
1677 an.setCalcId(annotation.getCalcId());
1679 if (annotation.hasProperties())
1681 for (String pr : annotation.getProperties())
1683 Property prop = new Property();
1685 prop.setValue(annotation.getProperty(pr));
1686 an.addProperty(prop);
1690 AnnotationElement ae;
1691 if (annotation.annotations != null)
1693 an.setScoreOnly(false);
1694 for (int a = 0; a < annotation.annotations.length; a++)
1696 if ((annotation == null) || (annotation.annotations[a] == null))
1701 ae = new AnnotationElement();
1702 if (annotation.annotations[a].description != null)
1704 ae.setDescription(annotation.annotations[a].description);
1706 if (annotation.annotations[a].displayCharacter != null)
1708 ae.setDisplayCharacter(annotation.annotations[a].displayCharacter);
1711 if (!Float.isNaN(annotation.annotations[a].value))
1713 ae.setValue(annotation.annotations[a].value);
1717 if (annotation.annotations[a].secondaryStructure > ' ')
1719 ae.setSecondaryStructure(annotation.annotations[a].secondaryStructure
1723 if (annotation.annotations[a].colour != null
1724 && annotation.annotations[a].colour != java.awt.Color.black)
1726 ae.setColour(annotation.annotations[a].colour.getRGB());
1729 an.addAnnotationElement(ae);
1730 if (annotation.autoCalculated)
1732 // only write one non-null entry into the annotation row -
1733 // sufficient to get the visualization attributes necessary to
1741 an.setScoreOnly(true);
1743 if (!storeDS || (storeDS && !annotation.autoCalculated))
1745 // skip autocalculated annotation - these are only provided for
1747 vamsasSet.addAnnotation(an);
1753 private CalcIdParam createCalcIdParam(String calcId, AlignViewport av)
1755 AutoCalcSetting settings = av.getCalcIdSettingsFor(calcId);
1756 if (settings != null)
1758 CalcIdParam vCalcIdParam = new CalcIdParam();
1759 vCalcIdParam.setCalcId(calcId);
1760 vCalcIdParam.addServiceURL(settings.getServiceURI());
1761 // generic URI allowing a third party to resolve another instance of the
1762 // service used for this calculation
1763 for (String urls : settings.getServiceURLs())
1765 vCalcIdParam.addServiceURL(urls);
1767 vCalcIdParam.setVersion("1.0");
1768 if (settings.getPreset() != null)
1770 WsParamSetI setting = settings.getPreset();
1771 vCalcIdParam.setName(setting.getName());
1772 vCalcIdParam.setDescription(setting.getDescription());
1776 vCalcIdParam.setName("");
1777 vCalcIdParam.setDescription("Last used parameters");
1779 // need to be able to recover 1) settings 2) user-defined presets or
1780 // recreate settings from preset 3) predefined settings provided by
1781 // service - or settings that can be transferred (or discarded)
1782 vCalcIdParam.setParameters(settings.getWsParamFile().replace("\n",
1784 vCalcIdParam.setAutoUpdate(settings.isAutoUpdate());
1785 // todo - decide if updateImmediately is needed for any projects.
1787 return vCalcIdParam;
1792 private boolean recoverCalcIdParam(CalcIdParam calcIdParam,
1795 if (calcIdParam.getVersion().equals("1.0"))
1797 Jws2Instance service = Jws2Discoverer.getDiscoverer()
1798 .getPreferredServiceFor(calcIdParam.getServiceURL());
1799 if (service != null)
1801 WsParamSetI parmSet = null;
1804 parmSet = service.getParamStore().parseServiceParameterFile(
1805 calcIdParam.getName(), calcIdParam.getDescription(),
1806 calcIdParam.getServiceURL(),
1807 calcIdParam.getParameters().replace("|\\n|", "\n"));
1808 } catch (IOException x)
1810 warn("Couldn't parse parameter data for "
1811 + calcIdParam.getCalcId(), x);
1814 List<ArgumentI> argList = null;
1815 if (calcIdParam.getName().length() > 0)
1817 parmSet = service.getParamStore()
1818 .getPreset(calcIdParam.getName());
1819 if (parmSet != null)
1821 // TODO : check we have a good match with settings in AACon -
1822 // otherwise we'll need to create a new preset
1827 argList = parmSet.getArguments();
1830 AAConSettings settings = new AAConSettings(
1831 calcIdParam.isAutoUpdate(), service, parmSet, argList);
1832 av.setCalcIdSettingsFor(calcIdParam.getCalcId(), settings,
1833 calcIdParam.isNeedsUpdate());
1838 warn("Cannot resolve a service for the parameters used in this project. Try configuring a JABAWS server.");
1842 throw new Error(MessageManager.formatMessage(
1843 "error.unsupported_version_calcIdparam",
1844 new Object[] { calcIdParam.toString() }));
1848 * External mapping between jalview objects and objects yielding a valid and
1849 * unique object ID string. This is null for normal Jalview project IO, but
1850 * non-null when a jalview project is being read or written as part of a
1853 IdentityHashMap jv2vobj = null;
1856 * Construct a unique ID for jvobj using either existing bindings or if none
1857 * exist, the result of the hashcode call for the object.
1860 * jalview data object
1861 * @return unique ID for referring to jvobj
1863 private String makeHashCode(Object jvobj, String altCode)
1865 if (jv2vobj != null)
1867 Object id = jv2vobj.get(jvobj);
1870 return id.toString();
1872 // check string ID mappings
1873 if (jvids2vobj != null && jvobj instanceof String)
1875 id = jvids2vobj.get(jvobj);
1879 return id.toString();
1881 // give up and warn that something has gone wrong
1882 warn("Cannot find ID for object in external mapping : " + jvobj);
1888 * return local jalview object mapped to ID, if it exists
1892 * @return null or object bound to idcode
1894 private Object retrieveExistingObj(String idcode)
1896 if (idcode != null && vobj2jv != null)
1898 return vobj2jv.get(idcode);
1904 * binding from ID strings from external mapping table to jalview data model
1907 private Hashtable vobj2jv;
1909 private Sequence createVamsasSequence(String id, SequenceI jds)
1911 return createVamsasSequence(true, id, jds, null);
1914 private Sequence createVamsasSequence(boolean recurse, String id,
1915 SequenceI jds, SequenceI parentseq)
1917 Sequence vamsasSeq = new Sequence();
1918 vamsasSeq.setId(id);
1919 vamsasSeq.setName(jds.getName());
1920 vamsasSeq.setSequence(jds.getSequenceAsString());
1921 vamsasSeq.setDescription(jds.getDescription());
1922 jalview.datamodel.DBRefEntry[] dbrefs = null;
1923 if (jds.getDatasetSequence() != null)
1925 vamsasSeq.setDsseqid(seqHash(jds.getDatasetSequence()));
1926 if (jds.getDatasetSequence().getDBRefs() != null)
1928 dbrefs = jds.getDatasetSequence().getDBRefs();
1933 vamsasSeq.setDsseqid(id); // so we can tell which sequences really are
1934 // dataset sequences only
1935 dbrefs = jds.getDBRefs();
1939 for (int d = 0; d < dbrefs.length; d++)
1941 DBRef dbref = new DBRef();
1942 dbref.setSource(dbrefs[d].getSource());
1943 dbref.setVersion(dbrefs[d].getVersion());
1944 dbref.setAccessionId(dbrefs[d].getAccessionId());
1945 if (dbrefs[d].hasMap())
1947 Mapping mp = createVamsasMapping(dbrefs[d].getMap(), parentseq,
1949 dbref.setMapping(mp);
1951 vamsasSeq.addDBRef(dbref);
1957 private Mapping createVamsasMapping(jalview.datamodel.Mapping jmp,
1958 SequenceI parentseq, SequenceI jds, boolean recurse)
1961 if (jmp.getMap() != null)
1965 jalview.util.MapList mlst = jmp.getMap();
1966 List<int[]> r = mlst.getFromRanges();
1967 for (int[] range : r)
1969 MapListFrom mfrom = new MapListFrom();
1970 mfrom.setStart(range[0]);
1971 mfrom.setEnd(range[1]);
1972 mp.addMapListFrom(mfrom);
1974 r = mlst.getToRanges();
1975 for (int[] range : r)
1977 MapListTo mto = new MapListTo();
1978 mto.setStart(range[0]);
1979 mto.setEnd(range[1]);
1980 mp.addMapListTo(mto);
1982 mp.setMapFromUnit(mlst.getFromRatio());
1983 mp.setMapToUnit(mlst.getToRatio());
1984 if (jmp.getTo() != null)
1986 MappingChoice mpc = new MappingChoice();
1988 && (parentseq != jmp.getTo() || parentseq
1989 .getDatasetSequence() != jmp.getTo()))
1991 mpc.setSequence(createVamsasSequence(false, seqHash(jmp.getTo()),
1997 SequenceI ps = null;
1998 if (parentseq != jmp.getTo()
1999 && parentseq.getDatasetSequence() != jmp.getTo())
2001 // chaining dbref rather than a handshaking one
2002 jmpid = seqHash(ps = jmp.getTo());
2006 jmpid = seqHash(ps = parentseq);
2008 mpc.setDseqFor(jmpid);
2009 if (!seqRefIds.containsKey(mpc.getDseqFor()))
2011 jalview.bin.Cache.log.debug("creatign new DseqFor ID");
2012 seqRefIds.put(mpc.getDseqFor(), ps);
2016 jalview.bin.Cache.log.debug("reusing DseqFor ID");
2019 mp.setMappingChoice(mpc);
2025 String setUserColourScheme(jalview.schemes.ColourSchemeI cs,
2026 List<UserColourScheme> userColours, JalviewModelSequence jms)
2029 jalview.schemes.UserColourScheme ucs = (jalview.schemes.UserColourScheme) cs;
2030 boolean newucs = false;
2031 if (!userColours.contains(ucs))
2033 userColours.add(ucs);
2036 id = "ucs" + userColours.indexOf(ucs);
2039 // actually create the scheme's entry in the XML model
2040 java.awt.Color[] colours = ucs.getColours();
2041 jalview.schemabinding.version2.UserColours uc = new jalview.schemabinding.version2.UserColours();
2042 jalview.schemabinding.version2.UserColourScheme jbucs = new jalview.schemabinding.version2.UserColourScheme();
2044 for (int i = 0; i < colours.length; i++)
2046 jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
2047 col.setName(ResidueProperties.aa[i]);
2048 col.setRGB(jalview.util.Format.getHexString(colours[i]));
2049 jbucs.addColour(col);
2051 if (ucs.getLowerCaseColours() != null)
2053 colours = ucs.getLowerCaseColours();
2054 for (int i = 0; i < colours.length; i++)
2056 jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
2057 col.setName(ResidueProperties.aa[i].toLowerCase());
2058 col.setRGB(jalview.util.Format.getHexString(colours[i]));
2059 jbucs.addColour(col);
2064 uc.setUserColourScheme(jbucs);
2065 jms.addUserColours(uc);
2071 jalview.schemes.UserColourScheme getUserColourScheme(
2072 JalviewModelSequence jms, String id)
2074 UserColours[] uc = jms.getUserColours();
2075 UserColours colours = null;
2077 for (int i = 0; i < uc.length; i++)
2079 if (uc[i].getId().equals(id))
2087 java.awt.Color[] newColours = new java.awt.Color[24];
2089 for (int i = 0; i < 24; i++)
2091 newColours[i] = new java.awt.Color(Integer.parseInt(colours
2092 .getUserColourScheme().getColour(i).getRGB(), 16));
2095 jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme(
2098 if (colours.getUserColourScheme().getColourCount() > 24)
2100 newColours = new java.awt.Color[23];
2101 for (int i = 0; i < 23; i++)
2103 newColours[i] = new java.awt.Color(Integer.parseInt(colours
2104 .getUserColourScheme().getColour(i + 24).getRGB(), 16));
2106 ucs.setLowerCaseColours(newColours);
2113 * contains last error message (if any) encountered by XML loader.
2115 String errorMessage = null;
2118 * flag to control whether the Jalview2XML_V1 parser should be deferred to if
2119 * exceptions are raised during project XML parsing
2121 public boolean attemptversion1parse = true;
2124 * Load a jalview project archive from a jar file
2127 * - HTTP URL or filename
2129 public AlignFrame loadJalviewAlign(final String file)
2132 jalview.gui.AlignFrame af = null;
2136 // create list to store references for any new Jmol viewers created
2137 newStructureViewers = new Vector<JalviewStructureDisplayI>();
2138 // UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
2139 // Workaround is to make sure caller implements the JarInputStreamProvider
2141 // so we can re-open the jar input stream for each entry.
2143 jarInputStreamProvider jprovider = createjarInputStreamProvider(file);
2144 af = loadJalviewAlign(jprovider);
2146 } catch (MalformedURLException e)
2148 errorMessage = "Invalid URL format for '" + file + "'";
2154 SwingUtilities.invokeAndWait(new Runnable()
2159 setLoadingFinishedForNewStructureViewers();
2162 } catch (Exception x)
2164 System.err.println("Error loading alignment: " + x.getMessage());
2170 private jarInputStreamProvider createjarInputStreamProvider(
2171 final String file) throws MalformedURLException
2174 errorMessage = null;
2175 uniqueSetSuffix = null;
2177 viewportsAdded.clear();
2178 frefedSequence = null;
2180 if (file.startsWith("http://"))
2182 url = new URL(file);
2184 final URL _url = url;
2185 return new jarInputStreamProvider()
2189 public JarInputStream getJarInputStream() throws IOException
2193 return new JarInputStream(_url.openStream());
2197 return new JarInputStream(new FileInputStream(file));
2202 public String getFilename()
2210 * Recover jalview session from a jalview project archive. Caller may
2211 * initialise uniqueSetSuffix, seqRefIds, viewportsAdded and frefedSequence
2212 * themselves. Any null fields will be initialised with default values,
2213 * non-null fields are left alone.
2218 public AlignFrame loadJalviewAlign(final jarInputStreamProvider jprovider)
2220 errorMessage = null;
2221 if (uniqueSetSuffix == null)
2223 uniqueSetSuffix = System.currentTimeMillis() % 100000 + "";
2225 if (seqRefIds == null)
2227 seqRefIds = new HashMap<String, SequenceI>();
2229 if (frefedSequence == null)
2231 frefedSequence = new Vector<Object[]>();
2234 AlignFrame af = null, _af = null;
2235 Map<String, AlignFrame> gatherToThisFrame = new HashMap<String, AlignFrame>();
2236 final String file = jprovider.getFilename();
2239 JarInputStream jin = null;
2240 JarEntry jarentry = null;
2245 jin = jprovider.getJarInputStream();
2246 for (int i = 0; i < entryCount; i++)
2248 jarentry = jin.getNextJarEntry();
2251 if (jarentry != null && jarentry.getName().endsWith(".xml"))
2253 InputStreamReader in = new InputStreamReader(jin, UTF_8);
2254 JalviewModel object = new JalviewModel();
2256 Unmarshaller unmar = new Unmarshaller(object);
2257 unmar.setValidation(false);
2258 object = (JalviewModel) unmar.unmarshal(in);
2259 if (true) // !skipViewport(object))
2261 _af = loadFromObject(object, file, true, jprovider);
2262 if (object.getJalviewModelSequence().getViewportCount() > 0)
2265 if (af.viewport.isGatherViewsHere())
2267 gatherToThisFrame.put(af.viewport.getSequenceSetId(), af);
2273 else if (jarentry != null)
2275 // Some other file here.
2278 } while (jarentry != null);
2279 resolveFrefedSequences();
2280 } catch (IOException ex)
2282 ex.printStackTrace();
2283 errorMessage = "Couldn't locate Jalview XML file : " + file;
2284 System.err.println("Exception whilst loading jalview XML file : "
2286 } catch (Exception ex)
2288 System.err.println("Parsing as Jalview Version 2 file failed.");
2289 ex.printStackTrace(System.err);
2290 if (attemptversion1parse)
2292 // Is Version 1 Jar file?
2295 af = new Jalview2XML_V1(raiseGUI).LoadJalviewAlign(jprovider);
2296 } catch (Exception ex2)
2298 System.err.println("Exception whilst loading as jalviewXMLV1:");
2299 ex2.printStackTrace();
2303 if (Desktop.instance != null)
2305 Desktop.instance.stopLoading();
2309 System.out.println("Successfully loaded archive file");
2312 ex.printStackTrace();
2314 System.err.println("Exception whilst loading jalview XML file : "
2316 } catch (OutOfMemoryError e)
2318 // Don't use the OOM Window here
2319 errorMessage = "Out of memory loading jalview XML file";
2320 System.err.println("Out of memory whilst loading jalview XML file");
2321 e.printStackTrace();
2324 if (Desktop.instance != null)
2326 Desktop.instance.stopLoading();
2330 * Regather multiple views (with the same sequence set id) to the frame (if
2331 * any) that is flagged as the one to gather to, i.e. convert them to tabbed
2332 * views instead of separate frames. Note this doesn't restore a state where
2333 * some expanded views in turn have tabbed views - the last "first tab" read
2334 * in will play the role of gatherer for all.
2336 for (AlignFrame fr : gatherToThisFrame.values())
2338 Desktop.instance.gatherViews(fr);
2341 restoreSplitFrames();
2343 if (errorMessage != null)
2351 * Try to reconstruct and display SplitFrame windows, where each contains
2352 * complementary dna and protein alignments. Done by pairing up AlignFrame
2353 * objects (created earlier) which have complementary viewport ids associated.
2355 protected void restoreSplitFrames()
2357 List<SplitFrame> gatherTo = new ArrayList<SplitFrame>();
2358 List<AlignFrame> addedToSplitFrames = new ArrayList<AlignFrame>();
2359 Map<String, AlignFrame> dna = new HashMap<String, AlignFrame>();
2362 * Identify the DNA alignments
2364 for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
2367 AlignFrame af = candidate.getValue();
2368 if (af.getViewport().getAlignment().isNucleotide())
2370 dna.put(candidate.getKey().getId(), af);
2375 * Try to match up the protein complements
2377 for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
2380 AlignFrame af = candidate.getValue();
2381 if (!af.getViewport().getAlignment().isNucleotide())
2383 String complementId = candidate.getKey().getComplementId();
2384 // only non-null complements should be in the Map
2385 if (complementId != null && dna.containsKey(complementId))
2387 final AlignFrame dnaFrame = dna.get(complementId);
2388 SplitFrame sf = createSplitFrame(dnaFrame, af);
2389 addedToSplitFrames.add(dnaFrame);
2390 addedToSplitFrames.add(af);
2391 if (af.viewport.isGatherViewsHere())
2400 * Open any that we failed to pair up (which shouldn't happen!) as
2401 * standalone AlignFrame's.
2403 for (Entry<Viewport, AlignFrame> candidate : splitFrameCandidates
2406 AlignFrame af = candidate.getValue();
2407 if (!addedToSplitFrames.contains(af))
2409 Viewport view = candidate.getKey();
2410 Desktop.addInternalFrame(af, view.getTitle(), view.getWidth(),
2412 System.err.println("Failed to restore view " + view.getTitle()
2413 + " to split frame");
2418 * Gather back into tabbed views as flagged.
2420 for (SplitFrame sf : gatherTo)
2422 Desktop.instance.gatherViews(sf);
2425 splitFrameCandidates.clear();
2429 * Construct and display one SplitFrame holding DNA and protein alignments.
2432 * @param proteinFrame
2435 protected SplitFrame createSplitFrame(AlignFrame dnaFrame,
2436 AlignFrame proteinFrame)
2438 SplitFrame splitFrame = new SplitFrame(dnaFrame, proteinFrame);
2439 String title = MessageManager.getString("label.linked_view_title");
2440 int width = (int) dnaFrame.getBounds().getWidth();
2441 int height = (int) (dnaFrame.getBounds().getHeight()
2442 + proteinFrame.getBounds().getHeight() + 50);
2445 * SplitFrame location is saved to both enclosed frames
2447 splitFrame.setLocation(dnaFrame.getX(), dnaFrame.getY());
2448 Desktop.addInternalFrame(splitFrame, title, width, height);
2451 * And compute cDNA consensus (couldn't do earlier with consensus as
2452 * mappings were not yet present)
2454 proteinFrame.viewport.alignmentChanged(proteinFrame.alignPanel);
2460 * check errorMessage for a valid error message and raise an error box in the
2461 * GUI or write the current errorMessage to stderr and then clear the error
2464 protected void reportErrors()
2466 reportErrors(false);
2469 protected void reportErrors(final boolean saving)
2471 if (errorMessage != null)
2473 final String finalErrorMessage = errorMessage;
2476 javax.swing.SwingUtilities.invokeLater(new Runnable()
2481 JOptionPane.showInternalMessageDialog(Desktop.desktop,
2482 finalErrorMessage, "Error "
2483 + (saving ? "saving" : "loading")
2484 + " Jalview file", JOptionPane.WARNING_MESSAGE);
2490 System.err.println("Problem loading Jalview file: " + errorMessage);
2493 errorMessage = null;
2496 Map<String, String> alreadyLoadedPDB = new HashMap<String, String>();
2499 * when set, local views will be updated from view stored in JalviewXML
2500 * Currently (28th Sep 2008) things will go horribly wrong in vamsas document
2501 * sync if this is set to true.
2503 private final boolean updateLocalViews = false;
2506 * Returns the path to a temporary file holding the PDB file for the given PDB
2507 * id. The first time of asking, searches for a file of that name in the
2508 * Jalview project jar, and copies it to a new temporary file. Any repeat
2509 * requests just return the path to the file previously created.
2515 String loadPDBFile(jarInputStreamProvider jprovider, String pdbId)
2517 if (alreadyLoadedPDB.containsKey(pdbId))
2519 return alreadyLoadedPDB.get(pdbId).toString();
2522 String tempFile = copyJarEntry(jprovider, pdbId, "jalview_pdb");
2523 if (tempFile != null)
2525 alreadyLoadedPDB.put(pdbId, tempFile);
2531 * Copies the jar entry of given name to a new temporary file and returns the
2532 * path to the file, or null if the entry is not found.
2535 * @param jarEntryName
2537 * a prefix for the temporary file name, must be at least three
2541 protected String copyJarEntry(jarInputStreamProvider jprovider,
2542 String jarEntryName, String prefix)
2544 BufferedReader in = null;
2545 PrintWriter out = null;
2549 JarInputStream jin = jprovider.getJarInputStream();
2551 * if (jprovider.startsWith("http://")) { jin = new JarInputStream(new
2552 * URL(jprovider).openStream()); } else { jin = new JarInputStream(new
2553 * FileInputStream(jprovider)); }
2556 JarEntry entry = null;
2559 entry = jin.getNextJarEntry();
2560 } while (entry != null && !entry.getName().equals(jarEntryName));
2563 in = new BufferedReader(new InputStreamReader(jin, UTF_8));
2564 File outFile = File.createTempFile(prefix, ".tmp");
2565 outFile.deleteOnExit();
2566 out = new PrintWriter(new FileOutputStream(outFile));
2569 while ((data = in.readLine()) != null)
2574 String t = outFile.getAbsolutePath();
2579 warn("Couldn't find entry in Jalview Jar for " + jarEntryName);
2581 } catch (Exception ex)
2583 ex.printStackTrace();
2591 } catch (IOException e)
2605 private class JvAnnotRow
2607 public JvAnnotRow(int i, AlignmentAnnotation jaa)
2614 * persisted version of annotation row from which to take vis properties
2616 public jalview.datamodel.AlignmentAnnotation template;
2619 * original position of the annotation row in the alignment
2625 * Load alignment frame from jalview XML DOM object
2630 * filename source string
2631 * @param loadTreesAndStructures
2632 * when false only create Viewport
2634 * data source provider
2635 * @return alignment frame created from view stored in DOM
2637 AlignFrame loadFromObject(JalviewModel object, String file,
2638 boolean loadTreesAndStructures, jarInputStreamProvider jprovider)
2640 SequenceSet vamsasSet = object.getVamsasModel().getSequenceSet(0);
2641 Sequence[] vamsasSeq = vamsasSet.getSequence();
2643 JalviewModelSequence jms = object.getJalviewModelSequence();
2645 Viewport view = (jms.getViewportCount() > 0) ? jms.getViewport(0)
2648 // ////////////////////////////////
2651 List<SequenceI> hiddenSeqs = null;
2652 jalview.datamodel.Sequence jseq;
2654 List<SequenceI> tmpseqs = new ArrayList<SequenceI>();
2656 boolean multipleView = false;
2658 JSeq[] jseqs = object.getJalviewModelSequence().getJSeq();
2659 int vi = 0; // counter in vamsasSeq array
2660 for (int i = 0; i < jseqs.length; i++)
2662 String seqId = jseqs[i].getId();
2664 if (seqRefIds.get(seqId) != null)
2666 tmpseqs.add(seqRefIds.get(seqId));
2667 multipleView = true;
2671 jseq = new jalview.datamodel.Sequence(vamsasSeq[vi].getName(),
2672 vamsasSeq[vi].getSequence());
2673 jseq.setDescription(vamsasSeq[vi].getDescription());
2674 jseq.setStart(jseqs[i].getStart());
2675 jseq.setEnd(jseqs[i].getEnd());
2676 jseq.setVamsasId(uniqueSetSuffix + seqId);
2677 seqRefIds.put(vamsasSeq[vi].getId(), jseq);
2682 if (jseqs[i].getHidden())
2684 if (hiddenSeqs == null)
2686 hiddenSeqs = new ArrayList<SequenceI>();
2689 hiddenSeqs.add(seqRefIds.get(seqId));
2695 // Create the alignment object from the sequence set
2696 // ///////////////////////////////
2697 SequenceI[] orderedSeqs = tmpseqs
2698 .toArray(new SequenceI[tmpseqs.size()]);
2700 Alignment al = new Alignment(orderedSeqs);
2702 // / Add the alignment properties
2703 for (int i = 0; i < vamsasSet.getSequenceSetPropertiesCount(); i++)
2705 SequenceSetProperties ssp = vamsasSet.getSequenceSetProperties(i);
2706 al.setProperty(ssp.getKey(), ssp.getValue());
2710 // SequenceFeatures are added to the DatasetSequence,
2711 // so we must create or recover the dataset before loading features
2712 // ///////////////////////////////
2713 if (vamsasSet.getDatasetId() == null || vamsasSet.getDatasetId() == "")
2715 // older jalview projects do not have a dataset id.
2716 al.setDataset(null);
2720 // recover dataset - passing on flag indicating if this a 'viewless'
2721 // sequence set (a.k.a. a stored dataset for the project)
2722 recoverDatasetFor(vamsasSet, al, object.getJalviewModelSequence()
2723 .getViewportCount() == 0);
2725 // ///////////////////////////////
2727 Hashtable pdbloaded = new Hashtable(); // TODO nothing writes to this??
2730 // load sequence features, database references and any associated PDB
2731 // structures for the alignment
2732 for (int i = 0; i < vamsasSeq.length; i++)
2734 if (jseqs[i].getFeaturesCount() > 0)
2736 Features[] features = jseqs[i].getFeatures();
2737 for (int f = 0; f < features.length; f++)
2739 jalview.datamodel.SequenceFeature sf = new jalview.datamodel.SequenceFeature(
2740 features[f].getType(), features[f].getDescription(),
2741 features[f].getStatus(), features[f].getBegin(),
2742 features[f].getEnd(), features[f].getFeatureGroup());
2744 sf.setScore(features[f].getScore());
2745 for (int od = 0; od < features[f].getOtherDataCount(); od++)
2747 OtherData keyValue = features[f].getOtherData(od);
2748 if (keyValue.getKey().startsWith("LINK"))
2750 sf.addLink(keyValue.getValue());
2754 sf.setValue(keyValue.getKey(), keyValue.getValue());
2759 al.getSequenceAt(i).getDatasetSequence().addSequenceFeature(sf);
2762 if (vamsasSeq[i].getDBRefCount() > 0)
2764 addDBRefs(al.getSequenceAt(i).getDatasetSequence(), vamsasSeq[i]);
2766 if (jseqs[i].getPdbidsCount() > 0)
2768 Pdbids[] ids = jseqs[i].getPdbids();
2769 for (int p = 0; p < ids.length; p++)
2771 jalview.datamodel.PDBEntry entry = new jalview.datamodel.PDBEntry();
2772 entry.setId(ids[p].getId());
2773 if (ids[p].getType() != null)
2775 if (ids[p].getType().equalsIgnoreCase("PDB"))
2777 entry.setType(PDBEntry.Type.PDB);
2781 entry.setType(PDBEntry.Type.FILE);
2784 if (ids[p].getFile() != null)
2786 if (!pdbloaded.containsKey(ids[p].getFile()))
2788 entry.setFile(loadPDBFile(jprovider, ids[p].getId()));
2792 entry.setFile(pdbloaded.get(ids[p].getId()).toString());
2795 StructureSelectionManager.getStructureSelectionManager(
2796 Desktop.instance).registerPDBEntry(entry);
2797 al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
2801 } // end !multipleview
2803 // ///////////////////////////////
2804 // LOAD SEQUENCE MAPPINGS
2806 if (vamsasSet.getAlcodonFrameCount() > 0)
2808 // TODO Potentially this should only be done once for all views of an
2810 AlcodonFrame[] alc = vamsasSet.getAlcodonFrame();
2811 for (int i = 0; i < alc.length; i++)
2813 AlignedCodonFrame cf = new AlignedCodonFrame();
2814 if (alc[i].getAlcodMapCount() > 0)
2816 AlcodMap[] maps = alc[i].getAlcodMap();
2817 for (int m = 0; m < maps.length; m++)
2819 SequenceI dnaseq = seqRefIds.get(maps[m].getDnasq());
2821 jalview.datamodel.Mapping mapping = null;
2822 // attach to dna sequence reference.
2823 if (maps[m].getMapping() != null)
2825 mapping = addMapping(maps[m].getMapping());
2827 if (dnaseq != null && mapping.getTo() != null)
2829 cf.addMap(dnaseq, mapping.getTo(), mapping.getMap());
2834 frefedSequence.add(new Object[] { maps[m].getDnasq(), cf,
2839 al.addCodonFrame(cf);
2843 // ////////////////////////////////
2845 List<JvAnnotRow> autoAlan = new ArrayList<JvAnnotRow>();
2848 * store any annotations which forward reference a group's ID
2850 Map<String, List<AlignmentAnnotation>> groupAnnotRefs = new Hashtable<String, List<AlignmentAnnotation>>();
2852 if (vamsasSet.getAnnotationCount() > 0)
2854 Annotation[] an = vamsasSet.getAnnotation();
2856 for (int i = 0; i < an.length; i++)
2858 Annotation annotation = an[i];
2861 * test if annotation is automatically calculated for this view only
2863 boolean autoForView = false;
2864 if (annotation.getLabel().equals("Quality")
2865 || annotation.getLabel().equals("Conservation")
2866 || annotation.getLabel().equals("Consensus"))
2868 // Kludge for pre 2.5 projects which lacked the autocalculated flag
2870 if (!annotation.hasAutoCalculated())
2872 annotation.setAutoCalculated(true);
2876 || (annotation.hasAutoCalculated() && annotation
2877 .isAutoCalculated()))
2879 // remove ID - we don't recover annotation from other views for
2880 // view-specific annotation
2881 annotation.setId(null);
2884 // set visiblity for other annotation in this view
2885 String annotationId = annotation.getId();
2886 if (annotationId != null && annotationIds.containsKey(annotationId))
2888 AlignmentAnnotation jda = annotationIds.get(annotationId);
2889 // in principle Visible should always be true for annotation displayed
2890 // in multiple views
2891 if (annotation.hasVisible())
2893 jda.visible = annotation.getVisible();
2896 al.addAnnotation(jda);
2900 // Construct new annotation from model.
2901 AnnotationElement[] ae = annotation.getAnnotationElement();
2902 jalview.datamodel.Annotation[] anot = null;
2903 java.awt.Color firstColour = null;
2905 if (!annotation.getScoreOnly())
2907 anot = new jalview.datamodel.Annotation[al.getWidth()];
2908 for (int aa = 0; aa < ae.length && aa < anot.length; aa++)
2910 anpos = ae[aa].getPosition();
2912 if (anpos >= anot.length)
2917 anot[anpos] = new jalview.datamodel.Annotation(
2919 ae[aa].getDisplayCharacter(), ae[aa].getDescription(),
2920 (ae[aa].getSecondaryStructure() == null || ae[aa]
2921 .getSecondaryStructure().length() == 0) ? ' '
2922 : ae[aa].getSecondaryStructure().charAt(0),
2926 // JBPNote: Consider verifying dataflow for IO of secondary
2927 // structure annotation read from Stockholm files
2928 // this was added to try to ensure that
2929 // if (anot[ae[aa].getPosition()].secondaryStructure>' ')
2931 // anot[ae[aa].getPosition()].displayCharacter = "";
2933 anot[anpos].colour = new java.awt.Color(ae[aa].getColour());
2934 if (firstColour == null)
2936 firstColour = anot[anpos].colour;
2940 jalview.datamodel.AlignmentAnnotation jaa = null;
2942 if (annotation.getGraph())
2944 float llim = 0, hlim = 0;
2945 // if (autoForView || an[i].isAutoCalculated()) {
2948 jaa = new jalview.datamodel.AlignmentAnnotation(
2949 annotation.getLabel(), annotation.getDescription(), anot,
2950 llim, hlim, annotation.getGraphType());
2952 jaa.graphGroup = annotation.getGraphGroup();
2953 jaa._linecolour = firstColour;
2954 if (annotation.getThresholdLine() != null)
2956 jaa.setThreshold(new jalview.datamodel.GraphLine(annotation
2957 .getThresholdLine().getValue(), annotation
2958 .getThresholdLine().getLabel(), new java.awt.Color(
2959 annotation.getThresholdLine().getColour())));
2962 if (autoForView || annotation.isAutoCalculated())
2964 // Hardwire the symbol display line to ensure that labels for
2965 // histograms are displayed
2971 jaa = new jalview.datamodel.AlignmentAnnotation(an[i].getLabel(),
2972 an[i].getDescription(), anot);
2973 jaa._linecolour = firstColour;
2975 // register new annotation
2976 if (an[i].getId() != null)
2978 annotationIds.put(an[i].getId(), jaa);
2979 jaa.annotationId = an[i].getId();
2981 // recover sequence association
2982 String sequenceRef = an[i].getSequenceRef();
2983 if (sequenceRef != null)
2985 // from 2.9 sequenceRef is to sequence id (JAL-1781)
2986 SequenceI sequence = seqRefIds.get(sequenceRef);
2987 if (sequence == null)
2989 // in pre-2.9 projects sequence ref is to sequence name
2990 sequence = al.findName(sequenceRef);
2992 if (sequence != null)
2994 jaa.createSequenceMapping(sequence, 1, true);
2995 sequence.addAlignmentAnnotation(jaa);
2998 // and make a note of any group association
2999 if (an[i].getGroupRef() != null && an[i].getGroupRef().length() > 0)
3001 List<jalview.datamodel.AlignmentAnnotation> aal = groupAnnotRefs
3002 .get(an[i].getGroupRef());
3005 aal = new ArrayList<jalview.datamodel.AlignmentAnnotation>();
3006 groupAnnotRefs.put(an[i].getGroupRef(), aal);
3011 if (an[i].hasScore())
3013 jaa.setScore(an[i].getScore());
3015 if (an[i].hasVisible())
3017 jaa.visible = an[i].getVisible();
3020 if (an[i].hasCentreColLabels())
3022 jaa.centreColLabels = an[i].getCentreColLabels();
3025 if (an[i].hasScaleColLabels())
3027 jaa.scaleColLabel = an[i].getScaleColLabels();
3029 if (an[i].hasAutoCalculated() && an[i].isAutoCalculated())
3031 // newer files have an 'autoCalculated' flag and store calculation
3032 // state in viewport properties
3033 jaa.autoCalculated = true; // means annotation will be marked for
3034 // update at end of load.
3036 if (an[i].hasGraphHeight())
3038 jaa.graphHeight = an[i].getGraphHeight();
3040 if (an[i].hasBelowAlignment())
3042 jaa.belowAlignment = an[i].isBelowAlignment();
3044 jaa.setCalcId(an[i].getCalcId());
3045 if (an[i].getPropertyCount() > 0)
3047 for (jalview.schemabinding.version2.Property prop : an[i]
3050 jaa.setProperty(prop.getName(), prop.getValue());
3053 if (jaa.autoCalculated)
3055 autoAlan.add(new JvAnnotRow(i, jaa));
3058 // if (!autoForView)
3060 // add autocalculated group annotation and any user created annotation
3062 al.addAnnotation(jaa);
3066 // ///////////////////////
3068 // Create alignment markup and styles for this view
3069 if (jms.getJGroupCount() > 0)
3071 JGroup[] groups = jms.getJGroup();
3072 boolean addAnnotSchemeGroup = false;
3073 for (int i = 0; i < groups.length; i++)
3075 JGroup jGroup = groups[i];
3076 ColourSchemeI cs = null;
3077 if (jGroup.getColour() != null)
3079 if (jGroup.getColour().startsWith("ucs"))
3081 cs = getUserColourScheme(jms, jGroup.getColour());
3083 else if (jGroup.getColour().equals("AnnotationColourGradient")
3084 && jGroup.getAnnotationColours() != null)
3086 addAnnotSchemeGroup = true;
3091 cs = ColourSchemeProperty.getColour(al, jGroup.getColour());
3096 cs.setThreshold(jGroup.getPidThreshold(), true);
3100 Vector<SequenceI> seqs = new Vector<SequenceI>();
3102 for (int s = 0; s < jGroup.getSeqCount(); s++)
3104 String seqId = jGroup.getSeq(s) + "";
3105 SequenceI ts = seqRefIds.get(seqId);
3109 seqs.addElement(ts);
3113 if (seqs.size() < 1)
3118 SequenceGroup sg = new SequenceGroup(seqs, jGroup.getName(), cs,
3119 jGroup.getDisplayBoxes(), jGroup.getDisplayText(),
3120 jGroup.getColourText(), jGroup.getStart(), jGroup.getEnd());
3122 sg.setOutlineColour(new java.awt.Color(jGroup.getOutlineColour()));
3124 sg.textColour = new java.awt.Color(jGroup.getTextCol1());
3125 sg.textColour2 = new java.awt.Color(jGroup.getTextCol2());
3126 sg.setShowNonconserved(jGroup.hasShowUnconserved() ? jGroup
3127 .isShowUnconserved() : false);
3128 sg.thresholdTextColour = jGroup.getTextColThreshold();
3129 if (jGroup.hasShowConsensusHistogram())
3131 sg.setShowConsensusHistogram(jGroup.isShowConsensusHistogram());
3134 if (jGroup.hasShowSequenceLogo())
3136 sg.setshowSequenceLogo(jGroup.isShowSequenceLogo());
3138 if (jGroup.hasNormaliseSequenceLogo())
3140 sg.setNormaliseSequenceLogo(jGroup.isNormaliseSequenceLogo());
3142 if (jGroup.hasIgnoreGapsinConsensus())
3144 sg.setIgnoreGapsConsensus(jGroup.getIgnoreGapsinConsensus());
3146 if (jGroup.getConsThreshold() != 0)
3148 jalview.analysis.Conservation c = new jalview.analysis.Conservation(
3149 "All", ResidueProperties.propHash, 3,
3150 sg.getSequences(null), 0, sg.getWidth() - 1);
3152 c.verdict(false, 25);
3153 sg.cs.setConservation(c);
3156 if (jGroup.getId() != null && groupAnnotRefs.size() > 0)
3158 // re-instate unique group/annotation row reference
3159 List<AlignmentAnnotation> jaal = groupAnnotRefs.get(jGroup
3163 for (AlignmentAnnotation jaa : jaal)
3166 if (jaa.autoCalculated)
3168 // match up and try to set group autocalc alignment row for this
3170 if (jaa.label.startsWith("Consensus for "))
3172 sg.setConsensus(jaa);
3174 // match up and try to set group autocalc alignment row for this
3176 if (jaa.label.startsWith("Conservation for "))
3178 sg.setConservationRow(jaa);
3185 if (addAnnotSchemeGroup)
3187 // reconstruct the annotation colourscheme
3188 sg.cs = constructAnnotationColour(jGroup.getAnnotationColours(),
3189 null, al, jms, false);
3195 // only dataset in this model, so just return.
3198 // ///////////////////////////////
3201 // If we just load in the same jar file again, the sequenceSetId
3202 // will be the same, and we end up with multiple references
3203 // to the same sequenceSet. We must modify this id on load
3204 // so that each load of the file gives a unique id
3205 String uniqueSeqSetId = view.getSequenceSetId() + uniqueSetSuffix;
3206 String viewId = (view.getId() == null ? null : view.getId()
3208 AlignFrame af = null;
3209 AlignViewport av = null;
3210 // now check to see if we really need to create a new viewport.
3211 if (multipleView && viewportsAdded.size() == 0)
3213 // We recovered an alignment for which a viewport already exists.
3214 // TODO: fix up any settings necessary for overlaying stored state onto
3215 // state recovered from another document. (may not be necessary).
3216 // we may need a binding from a viewport in memory to one recovered from
3218 // and then recover its containing af to allow the settings to be applied.
3219 // TODO: fix for vamsas demo
3221 .println("About to recover a viewport for existing alignment: Sequence set ID is "
3223 Object seqsetobj = retrieveExistingObj(uniqueSeqSetId);
3224 if (seqsetobj != null)
3226 if (seqsetobj instanceof String)
3228 uniqueSeqSetId = (String) seqsetobj;
3230 .println("Recovered extant sequence set ID mapping for ID : New Sequence set ID is "
3236 .println("Warning : Collision between sequence set ID string and existing jalview object mapping.");
3242 * indicate that annotation colours are applied across all groups (pre
3243 * Jalview 2.8.1 behaviour)
3245 boolean doGroupAnnColour = Jalview2XML.isVersionStringLaterThan(
3246 "2.8.1", object.getVersion());
3248 AlignmentPanel ap = null;
3249 boolean isnewview = true;
3252 // Check to see if this alignment already has a view id == viewId
3253 jalview.gui.AlignmentPanel views[] = Desktop
3254 .getAlignmentPanels(uniqueSeqSetId);
3255 if (views != null && views.length > 0)
3257 for (int v = 0; v < views.length; v++)
3259 if (views[v].av.getViewId().equalsIgnoreCase(viewId))
3261 // recover the existing alignpanel, alignframe, viewport
3262 af = views[v].alignFrame;
3265 // TODO: could even skip resetting view settings if we don't want to
3266 // change the local settings from other jalview processes
3275 af = loadViewport(file, jseqs, hiddenSeqs, al, jms, view,
3276 uniqueSeqSetId, viewId, autoAlan);
3282 * Load any trees, PDB structures and viewers
3284 * Not done if flag is false (when this method is used for New View)
3286 if (loadTreesAndStructures)
3288 loadTrees(jms, view, af, av, ap);
3289 loadPDBStructures(jprovider, jseqs, af, ap);
3290 loadRnaViewers(jprovider, jseqs, ap);
3292 // and finally return.
3297 * Instantiate and link any saved RNA (Varna) viewers. The state of the Varna
3298 * panel is restored from separate jar entries, two (gapped and trimmed) per
3299 * sequence and secondary structure.
3301 * Currently each viewer shows just one sequence and structure (gapped and
3302 * trimmed), however this method is designed to support multiple sequences or
3303 * structures in viewers if wanted in future.
3309 private void loadRnaViewers(jarInputStreamProvider jprovider,
3310 JSeq[] jseqs, AlignmentPanel ap)
3313 * scan the sequences for references to viewers; create each one the first
3314 * time it is referenced, add Rna models to existing viewers
3316 for (JSeq jseq : jseqs)
3318 for (int i = 0; i < jseq.getRnaViewerCount(); i++)
3320 RnaViewer viewer = jseq.getRnaViewer(i);
3321 AppVarna appVarna = findOrCreateVarnaViewer(viewer,
3322 uniqueSetSuffix, ap);
3324 for (int j = 0; j < viewer.getSecondaryStructureCount(); j++)
3326 SecondaryStructure ss = viewer.getSecondaryStructure(j);
3327 SequenceI seq = seqRefIds.get(jseq.getId());
3328 AlignmentAnnotation ann = this.annotationIds.get(ss
3329 .getAnnotationId());
3332 * add the structure to the Varna display (with session state copied
3333 * from the jar to a temporary file)
3335 boolean gapped = ss.isGapped();
3336 String rnaTitle = ss.getTitle();
3337 String sessionState = ss.getViewerState();
3338 String tempStateFile = copyJarEntry(jprovider, sessionState,
3340 RnaModel rna = new RnaModel(rnaTitle, ann, seq, null, gapped);
3341 appVarna.addModelSession(rna, rnaTitle, tempStateFile);
3343 appVarna.setInitialSelection(viewer.getSelectedRna());
3349 * Locate and return an already instantiated matching AppVarna, or create one
3353 * @param viewIdSuffix
3357 protected AppVarna findOrCreateVarnaViewer(RnaViewer viewer,
3358 String viewIdSuffix, AlignmentPanel ap)
3361 * on each load a suffix is appended to the saved viewId, to avoid conflicts
3362 * if load is repeated
3364 String postLoadId = viewer.getViewId() + viewIdSuffix;
3365 for (JInternalFrame frame : getAllFrames())
3367 if (frame instanceof AppVarna)
3369 AppVarna varna = (AppVarna) frame;
3370 if (postLoadId.equals(varna.getViewId()))
3372 // this viewer is already instantiated
3373 // could in future here add ap as another 'parent' of the
3374 // AppVarna window; currently just 1-to-many
3381 * viewer not found - make it
3383 RnaViewerModel model = new RnaViewerModel(postLoadId,
3384 viewer.getTitle(), viewer.getXpos(), viewer.getYpos(),
3385 viewer.getWidth(), viewer.getHeight(),
3386 viewer.getDividerLocation());
3387 AppVarna varna = new AppVarna(model, ap);
3393 * Load any saved trees
3401 protected void loadTrees(JalviewModelSequence jms, Viewport view,
3402 AlignFrame af, AlignViewport av, AlignmentPanel ap)
3404 // TODO result of automated refactoring - are all these parameters needed?
3407 for (int t = 0; t < jms.getTreeCount(); t++)
3410 Tree tree = jms.getTree(t);
3412 TreePanel tp = (TreePanel) retrieveExistingObj(tree.getId());
3415 tp = af.ShowNewickTree(
3416 new jalview.io.NewickFile(tree.getNewick()),
3417 tree.getTitle(), tree.getWidth(), tree.getHeight(),
3418 tree.getXpos(), tree.getYpos());
3419 if (tree.getId() != null)
3421 // perhaps bind the tree id to something ?
3426 // update local tree attributes ?
3427 // TODO: should check if tp has been manipulated by user - if so its
3428 // settings shouldn't be modified
3429 tp.setTitle(tree.getTitle());
3430 tp.setBounds(new Rectangle(tree.getXpos(), tree.getYpos(), tree
3431 .getWidth(), tree.getHeight()));
3432 tp.av = av; // af.viewport; // TODO: verify 'associate with all
3435 tp.treeCanvas.av = av; // af.viewport;
3436 tp.treeCanvas.ap = ap; // af.alignPanel;
3441 warn("There was a problem recovering stored Newick tree: \n"
3442 + tree.getNewick());
3446 tp.fitToWindow.setState(tree.getFitToWindow());
3447 tp.fitToWindow_actionPerformed(null);
3449 if (tree.getFontName() != null)
3451 tp.setTreeFont(new java.awt.Font(tree.getFontName(), tree
3452 .getFontStyle(), tree.getFontSize()));
3456 tp.setTreeFont(new java.awt.Font(view.getFontName(), view
3457 .getFontStyle(), tree.getFontSize()));
3460 tp.showPlaceholders(tree.getMarkUnlinked());
3461 tp.showBootstrap(tree.getShowBootstrap());
3462 tp.showDistances(tree.getShowDistances());
3464 tp.treeCanvas.threshold = tree.getThreshold();
3466 if (tree.getCurrentTree())
3468 af.viewport.setCurrentTree(tp.getTree());
3472 } catch (Exception ex)
3474 ex.printStackTrace();
3479 * Load and link any saved structure viewers.
3486 protected void loadPDBStructures(jarInputStreamProvider jprovider,
3487 JSeq[] jseqs, AlignFrame af, AlignmentPanel ap)
3490 * Run through all PDB ids on the alignment, and collect mappings between
3491 * distinct view ids and all sequences referring to that view.
3493 Map<String, StructureViewerModel> structureViewers = new LinkedHashMap<String, StructureViewerModel>();
3495 for (int i = 0; i < jseqs.length; i++)
3497 if (jseqs[i].getPdbidsCount() > 0)
3499 Pdbids[] ids = jseqs[i].getPdbids();
3500 for (int p = 0; p < ids.length; p++)
3502 final int structureStateCount = ids[p].getStructureStateCount();
3503 for (int s = 0; s < structureStateCount; s++)
3505 // check to see if we haven't already created this structure view
3506 final StructureState structureState = ids[p]
3507 .getStructureState(s);
3508 String sviewid = (structureState.getViewId() == null) ? null
3509 : structureState.getViewId() + uniqueSetSuffix;
3510 jalview.datamodel.PDBEntry jpdb = new jalview.datamodel.PDBEntry();
3511 // Originally : ids[p].getFile()
3512 // : TODO: verify external PDB file recovery still works in normal
3513 // jalview project load
3514 jpdb.setFile(loadPDBFile(jprovider, ids[p].getId()));
3515 jpdb.setId(ids[p].getId());
3517 int x = structureState.getXpos();
3518 int y = structureState.getYpos();
3519 int width = structureState.getWidth();
3520 int height = structureState.getHeight();
3522 // Probably don't need to do this anymore...
3523 // Desktop.desktop.getComponentAt(x, y);
3524 // TODO: NOW: check that this recovers the PDB file correctly.
3525 String pdbFile = loadPDBFile(jprovider, ids[p].getId());
3526 jalview.datamodel.SequenceI seq = seqRefIds.get(jseqs[i]
3528 if (sviewid == null)
3530 sviewid = "_jalview_pre2_4_" + x + "," + y + "," + width
3533 if (!structureViewers.containsKey(sviewid))
3535 structureViewers.put(sviewid,
3536 new StructureViewerModel(x, y, width, height, false,
3537 false, true, structureState.getViewId(),
3538 structureState.getType()));
3539 // Legacy pre-2.7 conversion JAL-823 :
3540 // do not assume any view has to be linked for colour by
3544 // assemble String[] { pdb files }, String[] { id for each
3545 // file }, orig_fileloc, SequenceI[][] {{ seqs_file 1 }, {
3546 // seqs_file 2}, boolean[] {
3547 // linkAlignPanel,superposeWithAlignpanel}} from hash
3548 StructureViewerModel jmoldat = structureViewers.get(sviewid);
3549 jmoldat.setAlignWithPanel(jmoldat.isAlignWithPanel()
3550 | (structureState.hasAlignwithAlignPanel() ? structureState
3551 .getAlignwithAlignPanel() : false));
3554 * Default colour by linked panel to false if not specified (e.g.
3555 * for pre-2.7 projects)
3557 boolean colourWithAlignPanel = jmoldat.isColourWithAlignPanel();
3558 colourWithAlignPanel |= (structureState
3559 .hasColourwithAlignPanel() ? structureState
3560 .getColourwithAlignPanel() : false);
3561 jmoldat.setColourWithAlignPanel(colourWithAlignPanel);
3564 * Default colour by viewer to true if not specified (e.g. for
3567 boolean colourByViewer = jmoldat.isColourByViewer();
3568 colourByViewer &= structureState.hasColourByJmol() ? structureState
3569 .getColourByJmol() : true;
3570 jmoldat.setColourByViewer(colourByViewer);
3572 if (jmoldat.getStateData().length() < structureState
3573 .getContent().length())
3576 jmoldat.setStateData(structureState.getContent());
3579 if (ids[p].getFile() != null)
3581 File mapkey = new File(ids[p].getFile());
3582 StructureData seqstrmaps = jmoldat.getFileData().get(mapkey);
3583 if (seqstrmaps == null)
3585 jmoldat.getFileData().put(
3587 seqstrmaps = jmoldat.new StructureData(pdbFile,
3590 if (!seqstrmaps.getSeqList().contains(seq))
3592 seqstrmaps.getSeqList().add(seq);
3598 errorMessage = ("The Jmol views in this project were imported\nfrom an older version of Jalview.\nPlease review the sequence colour associations\nin the Colour by section of the Jmol View menu.\n\nIn the case of problems, see note at\nhttp://issues.jalview.org/browse/JAL-747");
3605 // Instantiate the associated structure views
3606 for (Entry<String, StructureViewerModel> entry : structureViewers
3611 createOrLinkStructureViewer(entry, af, ap, jprovider);
3612 } catch (Exception e)
3614 System.err.println("Error loading structure viewer: "
3616 // failed - try the next one
3628 protected void createOrLinkStructureViewer(
3629 Entry<String, StructureViewerModel> viewerData, AlignFrame af,
3630 AlignmentPanel ap, jarInputStreamProvider jprovider)
3632 final StructureViewerModel stateData = viewerData.getValue();
3635 * Search for any viewer windows already open from other alignment views
3636 * that exactly match the stored structure state
3638 StructureViewerBase comp = findMatchingViewer(viewerData);
3642 linkStructureViewer(ap, comp, stateData);
3647 * From 2.9: stateData.type contains JMOL or CHIMERA, data is in jar entry
3648 * "viewer_"+stateData.viewId
3650 if (ViewerType.CHIMERA.toString().equals(stateData.getType()))
3652 createChimeraViewer(viewerData, af, jprovider);
3657 * else Jmol (if pre-2.9, stateData contains JMOL state string)
3659 createJmolViewer(viewerData, af, jprovider);
3664 * Create a new Chimera viewer.
3670 protected void createChimeraViewer(
3671 Entry<String, StructureViewerModel> viewerData, AlignFrame af,
3672 jarInputStreamProvider jprovider)
3674 StructureViewerModel data = viewerData.getValue();
3675 String chimeraSessionFile = data.getStateData();
3678 * Copy Chimera session from jar entry "viewer_"+viewId to a temporary file
3680 * NB this is the 'saved' viewId as in the project file XML, _not_ the
3681 * 'uniquified' sviewid used to reconstruct the viewer here
3683 String viewerJarEntryName = getViewerJarEntryName(data.getViewId());
3684 chimeraSessionFile = copyJarEntry(jprovider, viewerJarEntryName,
3687 Set<Entry<File, StructureData>> fileData = data.getFileData()
3689 List<PDBEntry> pdbs = new ArrayList<PDBEntry>();
3690 List<SequenceI[]> allseqs = new ArrayList<SequenceI[]>();
3691 for (Entry<File, StructureData> pdb : fileData)
3693 String filePath = pdb.getValue().getFilePath();
3694 String pdbId = pdb.getValue().getPdbId();
3695 // pdbs.add(new PDBEntry(filePath, pdbId));
3696 pdbs.add(new PDBEntry(pdbId, null, PDBEntry.Type.PDB, filePath));
3697 final List<SequenceI> seqList = pdb.getValue().getSeqList();
3698 SequenceI[] seqs = seqList.toArray(new SequenceI[seqList.size()]);
3702 boolean colourByChimera = data.isColourByViewer();
3703 boolean colourBySequence = data.isColourWithAlignPanel();
3705 // TODO use StructureViewer as a factory here, see JAL-1761
3706 final PDBEntry[] pdbArray = pdbs.toArray(new PDBEntry[pdbs.size()]);
3707 final SequenceI[][] seqsArray = allseqs.toArray(new SequenceI[allseqs
3709 String newViewId = viewerData.getKey();
3711 ChimeraViewFrame cvf = new ChimeraViewFrame(chimeraSessionFile,
3712 af.alignPanel, pdbArray, seqsArray, colourByChimera,
3713 colourBySequence, newViewId);
3714 cvf.setSize(data.getWidth(), data.getHeight());
3715 cvf.setLocation(data.getX(), data.getY());
3719 * Create a new Jmol window. First parse the Jmol state to translate filenames
3720 * loaded into the view, and record the order in which files are shown in the
3721 * Jmol view, so we can add the sequence mappings in same order.
3727 protected void createJmolViewer(
3728 final Entry<String, StructureViewerModel> viewerData,
3729 AlignFrame af, jarInputStreamProvider jprovider)
3731 final StructureViewerModel svattrib = viewerData.getValue();
3732 String state = svattrib.getStateData();
3735 * Pre-2.9: state element value is the Jmol state string
3737 * 2.9+: @type is "JMOL", state data is in a Jar file member named "viewer_"
3740 if (ViewerType.JMOL.toString().equals(svattrib.getType()))
3742 state = readJarEntry(jprovider,
3743 getViewerJarEntryName(svattrib.getViewId()));
3746 List<String> pdbfilenames = new ArrayList<String>();
3747 List<SequenceI[]> seqmaps = new ArrayList<SequenceI[]>();
3748 List<String> pdbids = new ArrayList<String>();
3749 StringBuilder newFileLoc = new StringBuilder(64);
3750 int cp = 0, ncp, ecp;
3751 Map<File, StructureData> oldFiles = svattrib.getFileData();
3752 while ((ncp = state.indexOf("load ", cp)) > -1)
3756 // look for next filename in load statement
3757 newFileLoc.append(state.substring(cp,
3758 ncp = (state.indexOf("\"", ncp + 1) + 1)));
3759 String oldfilenam = state.substring(ncp,
3760 ecp = state.indexOf("\"", ncp));
3761 // recover the new mapping data for this old filename
3762 // have to normalize filename - since Jmol and jalview do
3764 // translation differently.
3765 StructureData filedat = oldFiles.get(new File(oldfilenam));
3766 newFileLoc.append(Platform.escapeString(filedat.getFilePath()));
3767 pdbfilenames.add(filedat.getFilePath());
3768 pdbids.add(filedat.getPdbId());
3769 seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
3770 newFileLoc.append("\"");
3771 cp = ecp + 1; // advance beyond last \" and set cursor so we can
3772 // look for next file statement.
3773 } while ((ncp = state.indexOf("/*file*/", cp)) > -1);
3777 // just append rest of state
3778 newFileLoc.append(state.substring(cp));
3782 System.err.print("Ignoring incomplete Jmol state for PDB ids: ");
3783 newFileLoc = new StringBuilder(state);
3784 newFileLoc.append("; load append ");
3785 for (File id : oldFiles.keySet())
3787 // add this and any other pdb files that should be present in
3789 StructureData filedat = oldFiles.get(id);
3790 newFileLoc.append(filedat.getFilePath());
3791 pdbfilenames.add(filedat.getFilePath());
3792 pdbids.add(filedat.getPdbId());
3793 seqmaps.add(filedat.getSeqList().toArray(new SequenceI[0]));
3794 newFileLoc.append(" \"");
3795 newFileLoc.append(filedat.getFilePath());
3796 newFileLoc.append("\"");
3799 newFileLoc.append(";");
3802 if (newFileLoc.length() == 0)
3806 int histbug = newFileLoc.indexOf("history = ");
3810 * change "history = [true|false];" to "history = [1|0];"
3813 int diff = histbug == -1 ? -1 : newFileLoc.indexOf(";", histbug);
3814 String val = (diff == -1) ? null : newFileLoc
3815 .substring(histbug, diff);
3816 if (val != null && val.length() >= 4)
3818 if (val.contains("e")) // eh? what can it be?
3820 if (val.trim().equals("true"))
3828 newFileLoc.replace(histbug, diff, val);
3833 final String[] pdbf = pdbfilenames.toArray(new String[pdbfilenames
3835 final String[] id = pdbids.toArray(new String[pdbids.size()]);
3836 final SequenceI[][] sq = seqmaps
3837 .toArray(new SequenceI[seqmaps.size()][]);
3838 final String fileloc = newFileLoc.toString();
3839 final String sviewid = viewerData.getKey();
3840 final AlignFrame alf = af;
3841 final Rectangle rect = new Rectangle(svattrib.getX(), svattrib.getY(),
3842 svattrib.getWidth(), svattrib.getHeight());
3845 javax.swing.SwingUtilities.invokeAndWait(new Runnable()
3850 JalviewStructureDisplayI sview = null;
3853 sview = new StructureViewer(alf.alignPanel
3854 .getStructureSelectionManager()).createView(
3855 StructureViewer.ViewerType.JMOL, pdbf, id, sq,
3856 alf.alignPanel, svattrib, fileloc, rect, sviewid);
3857 addNewStructureViewer(sview);
3858 } catch (OutOfMemoryError ex)
3860 new OOMWarning("restoring structure view for PDB id " + id,
3861 (OutOfMemoryError) ex.getCause());
3862 if (sview != null && sview.isVisible())
3864 sview.closeViewer(false);
3865 sview.setVisible(false);
3871 } catch (InvocationTargetException ex)
3873 warn("Unexpected error when opening Jmol view.", ex);
3875 } catch (InterruptedException e)
3877 // e.printStackTrace();
3883 * Generates a name for the entry in the project jar file to hold state
3884 * information for a structure viewer
3889 protected String getViewerJarEntryName(String viewId)
3891 return VIEWER_PREFIX + viewId;
3895 * Returns any open frame that matches given structure viewer data. The match
3896 * is based on the unique viewId, or (for older project versions) the frame's
3902 protected StructureViewerBase findMatchingViewer(
3903 Entry<String, StructureViewerModel> viewerData)
3905 final String sviewid = viewerData.getKey();
3906 final StructureViewerModel svattrib = viewerData.getValue();
3907 StructureViewerBase comp = null;
3908 JInternalFrame[] frames = getAllFrames();
3909 for (JInternalFrame frame : frames)
3911 if (frame instanceof StructureViewerBase)
3914 * Post jalview 2.4 schema includes structure view id
3917 && ((StructureViewerBase) frame).getViewId()
3920 comp = (StructureViewerBase) frame;
3921 break; // break added in 2.9
3924 * Otherwise test for matching position and size of viewer frame
3926 else if (frame.getX() == svattrib.getX()
3927 && frame.getY() == svattrib.getY()
3928 && frame.getHeight() == svattrib.getHeight()
3929 && frame.getWidth() == svattrib.getWidth())
3931 comp = (StructureViewerBase) frame;
3932 // no break in faint hope of an exact match on viewId
3940 * Link an AlignmentPanel to an existing structure viewer.
3945 * @param useinViewerSuperpos
3946 * @param usetoColourbyseq
3947 * @param viewerColouring
3949 protected void linkStructureViewer(AlignmentPanel ap,
3950 StructureViewerBase viewer, StructureViewerModel stateData)
3952 // NOTE: if the jalview project is part of a shared session then
3953 // view synchronization should/could be done here.
3955 final boolean useinViewerSuperpos = stateData.isAlignWithPanel();
3956 final boolean usetoColourbyseq = stateData.isColourWithAlignPanel();
3957 final boolean viewerColouring = stateData.isColourByViewer();
3958 Map<File, StructureData> oldFiles = stateData.getFileData();
3961 * Add mapping for sequences in this view to an already open viewer
3963 final AAStructureBindingModel binding = viewer.getBinding();
3964 for (File id : oldFiles.keySet())
3966 // add this and any other pdb files that should be present in the
3968 StructureData filedat = oldFiles.get(id);
3969 String pdbFile = filedat.getFilePath();
3970 SequenceI[] seq = filedat.getSeqList().toArray(new SequenceI[0]);
3971 binding.getSsm().setMapping(seq, null, pdbFile,
3972 jalview.io.AppletFormatAdapter.FILE);
3973 binding.addSequenceForStructFile(pdbFile, seq);
3975 // and add the AlignmentPanel's reference to the view panel
3976 viewer.addAlignmentPanel(ap);
3977 if (useinViewerSuperpos)
3979 viewer.useAlignmentPanelForSuperposition(ap);
3983 viewer.excludeAlignmentPanelForSuperposition(ap);
3985 if (usetoColourbyseq)
3987 viewer.useAlignmentPanelForColourbyseq(ap, !viewerColouring);
3991 viewer.excludeAlignmentPanelForColourbyseq(ap);
3996 * Get all frames within the Desktop.
4000 protected JInternalFrame[] getAllFrames()
4002 JInternalFrame[] frames = null;
4003 // TODO is this necessary - is it safe - risk of hanging?
4008 frames = Desktop.desktop.getAllFrames();
4009 } catch (ArrayIndexOutOfBoundsException e)
4011 // occasional No such child exceptions are thrown here...
4015 } catch (InterruptedException f)
4019 } while (frames == null);
4024 * Answers true if 'version' is equal to or later than 'supported', where each
4025 * is formatted as major/minor versions like "2.8.3" or "2.3.4b1" for bugfix
4026 * changes. Development and test values for 'version' are leniently treated
4030 * - minimum version we are comparing against
4032 * - version of data being processsed
4035 public static boolean isVersionStringLaterThan(String supported,
4038 if (supported == null || version == null
4039 || version.equalsIgnoreCase("DEVELOPMENT BUILD")
4040 || version.equalsIgnoreCase("Test")
4041 || version.equalsIgnoreCase("AUTOMATED BUILD"))
4043 System.err.println("Assuming project file with "
4044 + (version == null ? "null" : version)
4045 + " is compatible with Jalview version " + supported);
4050 return StringUtils.compareVersions(version, supported, "b") >= 0;
4054 Vector<JalviewStructureDisplayI> newStructureViewers = null;
4056 protected void addNewStructureViewer(JalviewStructureDisplayI sview)
4058 if (newStructureViewers != null)
4060 sview.getBinding().setFinishedLoadingFromArchive(false);
4061 newStructureViewers.add(sview);
4065 protected void setLoadingFinishedForNewStructureViewers()
4067 if (newStructureViewers != null)
4069 for (JalviewStructureDisplayI sview : newStructureViewers)
4071 sview.getBinding().setFinishedLoadingFromArchive(true);
4073 newStructureViewers.clear();
4074 newStructureViewers = null;
4078 AlignFrame loadViewport(String file, JSeq[] JSEQ,
4079 List<SequenceI> hiddenSeqs, Alignment al,
4080 JalviewModelSequence jms, Viewport view, String uniqueSeqSetId,
4081 String viewId, List<JvAnnotRow> autoAlan)
4083 AlignFrame af = null;
4084 af = new AlignFrame(al, view.getWidth(), view.getHeight(),
4085 uniqueSeqSetId, viewId);
4087 af.setFileName(file, "Jalview");
4089 for (int i = 0; i < JSEQ.length; i++)
4091 af.viewport.setSequenceColour(af.viewport.getAlignment()
4092 .getSequenceAt(i), new java.awt.Color(JSEQ[i].getColour()));
4095 af.viewport.setGatherViewsHere(view.getGatheredViews());
4097 if (view.getSequenceSetId() != null)
4099 AlignmentViewport av = viewportsAdded.get(uniqueSeqSetId);
4101 af.viewport.setSequenceSetId(uniqueSeqSetId);
4104 // propagate shared settings to this new view
4105 af.viewport.setHistoryList(av.getHistoryList());
4106 af.viewport.setRedoList(av.getRedoList());
4110 viewportsAdded.put(uniqueSeqSetId, af.viewport);
4112 // TODO: check if this method can be called repeatedly without
4113 // side-effects if alignpanel already registered.
4114 PaintRefresher.Register(af.alignPanel, uniqueSeqSetId);
4116 // apply Hidden regions to view.
4117 if (hiddenSeqs != null)
4119 for (int s = 0; s < JSEQ.length; s++)
4121 jalview.datamodel.SequenceGroup hidden = new jalview.datamodel.SequenceGroup();
4123 for (int r = 0; r < JSEQ[s].getHiddenSequencesCount(); r++)
4126 al.getSequenceAt(JSEQ[s].getHiddenSequences(r)), false);
4128 af.viewport.hideRepSequences(al.getSequenceAt(s), hidden);
4131 // jalview.datamodel.SequenceI[] hseqs = new
4132 // jalview.datamodel.SequenceI[hiddenSeqs
4135 // for (int s = 0; s < hiddenSeqs.size(); s++)
4137 // hseqs[s] = (jalview.datamodel.SequenceI) hiddenSeqs.elementAt(s);
4140 SequenceI[] hseqs = hiddenSeqs.toArray(new SequenceI[hiddenSeqs
4142 af.viewport.hideSequence(hseqs);
4145 // recover view properties and display parameters
4146 if (view.getViewName() != null)
4148 af.viewport.viewName = view.getViewName();
4149 af.setInitialTabVisible();
4151 af.setBounds(view.getXpos(), view.getYpos(), view.getWidth(),
4154 af.viewport.setShowAnnotation(view.getShowAnnotation());
4155 af.viewport.setAbovePIDThreshold(view.getPidSelected());
4157 af.viewport.setColourText(view.getShowColourText());
4159 af.viewport.setConservationSelected(view.getConservationSelected());
4160 af.viewport.setShowJVSuffix(view.getShowFullId());
4161 af.viewport.setRightAlignIds(view.getRightAlignIds());
4162 af.viewport.setFont(
4163 new java.awt.Font(view.getFontName(), view.getFontStyle(), view
4164 .getFontSize()), true);
4165 ViewStyleI vs = af.viewport.getViewStyle();
4166 vs.setScaleProteinAsCdna(view.isScaleProteinAsCdna());
4167 af.viewport.setViewStyle(vs);
4168 // TODO: allow custom charWidth/Heights to be restored by updating them
4169 // after setting font - which means set above to false
4170 af.viewport.setRenderGaps(view.getRenderGaps());
4171 af.viewport.setWrapAlignment(view.getWrapAlignment());
4172 af.viewport.setShowAnnotation(view.getShowAnnotation());
4174 af.viewport.setShowBoxes(view.getShowBoxes());
4176 af.viewport.setShowText(view.getShowText());
4178 af.viewport.setTextColour(new java.awt.Color(view.getTextCol1()));
4179 af.viewport.setTextColour2(new java.awt.Color(view.getTextCol2()));
4180 af.viewport.setThresholdTextColour(view.getTextColThreshold());
4181 af.viewport.setShowUnconserved(view.hasShowUnconserved() ? view
4182 .isShowUnconserved() : false);
4183 af.viewport.setStartRes(view.getStartRes());
4184 af.viewport.setStartSeq(view.getStartSeq());
4185 af.alignPanel.updateLayout();
4186 ColourSchemeI cs = null;
4187 // apply colourschemes
4188 if (view.getBgColour() != null)
4190 if (view.getBgColour().startsWith("ucs"))
4192 cs = getUserColourScheme(jms, view.getBgColour());
4194 else if (view.getBgColour().startsWith("Annotation"))
4196 AnnotationColours viewAnnColour = view.getAnnotationColours();
4197 cs = constructAnnotationColour(viewAnnColour, af, al, jms, true);
4204 cs = ColourSchemeProperty.getColour(al, view.getBgColour());
4209 cs.setThreshold(view.getPidThreshold(), true);
4210 cs.setConsensus(af.viewport.getSequenceConsensusHash());
4214 af.viewport.setGlobalColourScheme(cs);
4215 af.viewport.setColourAppliesToAllGroups(false);
4217 if (view.getConservationSelected() && cs != null)
4219 cs.setConservationInc(view.getConsThreshold());
4222 af.changeColour(cs);
4224 af.viewport.setColourAppliesToAllGroups(true);
4226 af.viewport.setShowSequenceFeatures(view.getShowSequenceFeatures());
4228 if (view.hasCentreColumnLabels())
4230 af.viewport.setCentreColumnLabels(view.getCentreColumnLabels());
4232 if (view.hasIgnoreGapsinConsensus())
4234 af.viewport.setIgnoreGapsConsensus(view.getIgnoreGapsinConsensus(),
4237 if (view.hasFollowHighlight())
4239 af.viewport.setFollowHighlight(view.getFollowHighlight());
4241 if (view.hasFollowSelection())
4243 af.viewport.followSelection = view.getFollowSelection();
4245 if (view.hasShowConsensusHistogram())
4247 af.viewport.setShowConsensusHistogram(view
4248 .getShowConsensusHistogram());
4252 af.viewport.setShowConsensusHistogram(true);
4254 if (view.hasShowSequenceLogo())
4256 af.viewport.setShowSequenceLogo(view.getShowSequenceLogo());
4260 af.viewport.setShowSequenceLogo(false);
4262 if (view.hasNormaliseSequenceLogo())
4264 af.viewport.setNormaliseSequenceLogo(view.getNormaliseSequenceLogo());
4266 if (view.hasShowDbRefTooltip())
4268 af.viewport.setShowDBRefs(view.getShowDbRefTooltip());
4270 if (view.hasShowNPfeatureTooltip())
4272 af.viewport.setShowNPFeats(view.hasShowNPfeatureTooltip());
4274 if (view.hasShowGroupConsensus())
4276 af.viewport.setShowGroupConsensus(view.getShowGroupConsensus());
4280 af.viewport.setShowGroupConsensus(false);
4282 if (view.hasShowGroupConservation())
4284 af.viewport.setShowGroupConservation(view.getShowGroupConservation());
4288 af.viewport.setShowGroupConservation(false);
4291 // recover featre settings
4292 if (jms.getFeatureSettings() != null)
4294 FeaturesDisplayed fdi;
4295 af.viewport.setFeaturesDisplayed(fdi = new FeaturesDisplayed());
4296 String[] renderOrder = new String[jms.getFeatureSettings()
4297 .getSettingCount()];
4298 Hashtable featureGroups = new Hashtable();
4299 Hashtable featureColours = new Hashtable();
4300 Hashtable featureOrder = new Hashtable();
4302 for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++)
4304 Setting setting = jms.getFeatureSettings().getSetting(fs);
4305 if (setting.hasMincolour())
4307 GraduatedColor gc = setting.hasMin() ? new GraduatedColor(
4308 new java.awt.Color(setting.getMincolour()),
4309 new java.awt.Color(setting.getColour()),
4310 setting.getMin(), setting.getMax()) : new GraduatedColor(
4311 new java.awt.Color(setting.getMincolour()),
4312 new java.awt.Color(setting.getColour()), 0, 1);
4313 if (setting.hasThreshold())
4315 gc.setThresh(setting.getThreshold());
4316 gc.setThreshType(setting.getThreshstate());
4318 gc.setAutoScaled(true); // default
4319 if (setting.hasAutoScale())
4321 gc.setAutoScaled(setting.getAutoScale());
4323 if (setting.hasColourByLabel())
4325 gc.setColourByLabel(setting.getColourByLabel());
4327 // and put in the feature colour table.
4328 featureColours.put(setting.getType(), gc);
4332 featureColours.put(setting.getType(),
4333 new java.awt.Color(setting.getColour()));
4335 renderOrder[fs] = setting.getType();
4336 if (setting.hasOrder())
4338 featureOrder.put(setting.getType(), setting.getOrder());
4342 featureOrder.put(setting.getType(), new Float(fs
4343 / jms.getFeatureSettings().getSettingCount()));
4345 if (setting.getDisplay())
4347 fdi.setVisible(setting.getType());
4350 Hashtable fgtable = new Hashtable();
4351 for (int gs = 0; gs < jms.getFeatureSettings().getGroupCount(); gs++)
4353 Group grp = jms.getFeatureSettings().getGroup(gs);
4354 fgtable.put(grp.getName(), new Boolean(grp.getDisplay()));
4356 // FeatureRendererSettings frs = new FeatureRendererSettings(renderOrder,
4357 // fgtable, featureColours, jms.getFeatureSettings().hasTransparency() ?
4358 // jms.getFeatureSettings().getTransparency() : 0.0, featureOrder);
4359 FeatureRendererSettings frs = new FeatureRendererSettings(
4360 renderOrder, fgtable, featureColours, 1.0f, featureOrder);
4361 af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer()
4362 .transferSettings(frs);
4366 if (view.getHiddenColumnsCount() > 0)
4368 for (int c = 0; c < view.getHiddenColumnsCount(); c++)
4370 af.viewport.hideColumns(view.getHiddenColumns(c).getStart(), view
4371 .getHiddenColumns(c).getEnd() // +1
4375 if (view.getCalcIdParam() != null)
4377 for (CalcIdParam calcIdParam : view.getCalcIdParam())
4379 if (calcIdParam != null)
4381 if (recoverCalcIdParam(calcIdParam, af.viewport))
4386 warn("Couldn't recover parameters for "
4387 + calcIdParam.getCalcId());
4392 af.setMenusFromViewport(af.viewport);
4394 // TODO: we don't need to do this if the viewport is aready visible.
4396 * Add the AlignFrame to the desktop (it may be 'gathered' later), unless it
4397 * has a 'cdna/protein complement' view, in which case save it in order to
4398 * populate a SplitFrame once all views have been read in.
4400 String complementaryViewId = view.getComplementId();
4401 if (complementaryViewId == null)
4403 Desktop.addInternalFrame(af, view.getTitle(), view.getWidth(),
4405 // recompute any autoannotation
4406 af.alignPanel.updateAnnotation(false, true);
4407 reorderAutoannotation(af, al, autoAlan);
4408 af.alignPanel.alignmentChanged();
4412 splitFrameCandidates.put(view, af);
4417 private ColourSchemeI constructAnnotationColour(
4418 AnnotationColours viewAnnColour, AlignFrame af, Alignment al,
4419 JalviewModelSequence jms, boolean checkGroupAnnColour)
4421 boolean propagateAnnColour = false;
4422 ColourSchemeI cs = null;
4423 AlignmentI annAlignment = af != null ? af.viewport.getAlignment() : al;
4424 if (checkGroupAnnColour && al.getGroups() != null
4425 && al.getGroups().size() > 0)
4427 // pre 2.8.1 behaviour
4428 // check to see if we should transfer annotation colours
4429 propagateAnnColour = true;
4430 for (jalview.datamodel.SequenceGroup sg : al.getGroups())
4432 if (sg.cs instanceof AnnotationColourGradient)
4434 propagateAnnColour = false;
4438 // int find annotation
4439 if (annAlignment.getAlignmentAnnotation() != null)
4441 for (int i = 0; i < annAlignment.getAlignmentAnnotation().length; i++)
4443 if (annAlignment.getAlignmentAnnotation()[i].label
4444 .equals(viewAnnColour.getAnnotation()))
4446 if (annAlignment.getAlignmentAnnotation()[i].getThreshold() == null)
4448 annAlignment.getAlignmentAnnotation()[i]
4449 .setThreshold(new jalview.datamodel.GraphLine(
4450 viewAnnColour.getThreshold(), "Threshold",
4451 java.awt.Color.black)
4456 if (viewAnnColour.getColourScheme().equals("None"))
4458 cs = new AnnotationColourGradient(
4459 annAlignment.getAlignmentAnnotation()[i],
4460 new java.awt.Color(viewAnnColour.getMinColour()),
4461 new java.awt.Color(viewAnnColour.getMaxColour()),
4462 viewAnnColour.getAboveThreshold());
4464 else if (viewAnnColour.getColourScheme().startsWith("ucs"))
4466 cs = new AnnotationColourGradient(
4467 annAlignment.getAlignmentAnnotation()[i],
4468 getUserColourScheme(jms,
4469 viewAnnColour.getColourScheme()),
4470 viewAnnColour.getAboveThreshold());
4474 cs = new AnnotationColourGradient(
4475 annAlignment.getAlignmentAnnotation()[i],
4476 ColourSchemeProperty.getColour(al,
4477 viewAnnColour.getColourScheme()),
4478 viewAnnColour.getAboveThreshold());
4480 if (viewAnnColour.hasPerSequence())
4482 ((AnnotationColourGradient) cs).setSeqAssociated(viewAnnColour
4485 if (viewAnnColour.hasPredefinedColours())
4487 ((AnnotationColourGradient) cs)
4488 .setPredefinedColours(viewAnnColour
4489 .isPredefinedColours());
4491 if (propagateAnnColour && al.getGroups() != null)
4493 // Also use these settings for all the groups
4494 for (int g = 0; g < al.getGroups().size(); g++)
4496 jalview.datamodel.SequenceGroup sg = al.getGroups().get(g);
4504 * if (viewAnnColour.getColourScheme().equals("None" )) { sg.cs =
4505 * new AnnotationColourGradient(
4506 * annAlignment.getAlignmentAnnotation()[i], new
4507 * java.awt.Color(viewAnnColour. getMinColour()), new
4508 * java.awt.Color(viewAnnColour. getMaxColour()),
4509 * viewAnnColour.getAboveThreshold()); } else
4512 sg.cs = new AnnotationColourGradient(
4513 annAlignment.getAlignmentAnnotation()[i], sg.cs,
4514 viewAnnColour.getAboveThreshold());
4515 if (cs instanceof AnnotationColourGradient)
4517 if (viewAnnColour.hasPerSequence())
4519 ((AnnotationColourGradient) cs)
4520 .setSeqAssociated(viewAnnColour.isPerSequence());
4522 if (viewAnnColour.hasPredefinedColours())
4524 ((AnnotationColourGradient) cs)
4525 .setPredefinedColours(viewAnnColour
4526 .isPredefinedColours());
4542 private void reorderAutoannotation(AlignFrame af, Alignment al,
4543 List<JvAnnotRow> autoAlan)
4545 // copy over visualization settings for autocalculated annotation in the
4547 if (al.getAlignmentAnnotation() != null)
4550 * Kludge for magic autoannotation names (see JAL-811)
4552 String[] magicNames = new String[] { "Consensus", "Quality",
4554 JvAnnotRow nullAnnot = new JvAnnotRow(-1, null);
4555 Hashtable<String, JvAnnotRow> visan = new Hashtable<String, JvAnnotRow>();
4556 for (String nm : magicNames)
4558 visan.put(nm, nullAnnot);
4560 for (JvAnnotRow auan : autoAlan)
4562 visan.put(auan.template.label
4563 + (auan.template.getCalcId() == null ? "" : "\t"
4564 + auan.template.getCalcId()), auan);
4566 int hSize = al.getAlignmentAnnotation().length;
4567 List<JvAnnotRow> reorder = new ArrayList<JvAnnotRow>();
4568 // work through any autoCalculated annotation already on the view
4569 // removing it if it should be placed in a different location on the
4570 // annotation panel.
4571 List<String> remains = new ArrayList<String>(visan.keySet());
4572 for (int h = 0; h < hSize; h++)
4574 jalview.datamodel.AlignmentAnnotation jalan = al
4575 .getAlignmentAnnotation()[h];
4576 if (jalan.autoCalculated)
4579 JvAnnotRow valan = visan.get(k = jalan.label);
4580 if (jalan.getCalcId() != null)
4582 valan = visan.get(k = jalan.label + "\t" + jalan.getCalcId());
4587 // delete the auto calculated row from the alignment
4588 al.deleteAnnotation(jalan, false);
4592 if (valan != nullAnnot)
4594 if (jalan != valan.template)
4596 // newly created autoannotation row instance
4597 // so keep a reference to the visible annotation row
4598 // and copy over all relevant attributes
4599 if (valan.template.graphHeight >= 0)
4602 jalan.graphHeight = valan.template.graphHeight;
4604 jalan.visible = valan.template.visible;
4606 reorder.add(new JvAnnotRow(valan.order, jalan));
4611 // Add any (possibly stale) autocalculated rows that were not appended to
4612 // the view during construction
4613 for (String other : remains)
4615 JvAnnotRow othera = visan.get(other);
4616 if (othera != nullAnnot && othera.template.getCalcId() != null
4617 && othera.template.getCalcId().length() > 0)
4619 reorder.add(othera);
4622 // now put the automatic annotation in its correct place
4623 int s = 0, srt[] = new int[reorder.size()];
4624 JvAnnotRow[] rws = new JvAnnotRow[reorder.size()];
4625 for (JvAnnotRow jvar : reorder)
4628 srt[s++] = jvar.order;
4631 jalview.util.QuickSort.sort(srt, rws);
4632 // and re-insert the annotation at its correct position
4633 for (JvAnnotRow jvar : rws)
4635 al.addAnnotation(jvar.template, jvar.order);
4637 af.alignPanel.adjustAnnotationHeight();
4641 Hashtable skipList = null;
4644 * TODO remove this method
4647 * @return AlignFrame bound to sequenceSetId from view, if one exists. private
4648 * AlignFrame getSkippedFrame(Viewport view) { if (skipList==null) {
4649 * throw new Error("Implementation Error. No skipList defined for this
4650 * Jalview2XML instance."); } return (AlignFrame)
4651 * skipList.get(view.getSequenceSetId()); }
4655 * Check if the Jalview view contained in object should be skipped or not.
4658 * @return true if view's sequenceSetId is a key in skipList
4660 private boolean skipViewport(JalviewModel object)
4662 if (skipList == null)
4667 if (skipList.containsKey(id = object.getJalviewModelSequence()
4668 .getViewport()[0].getSequenceSetId()))
4670 if (Cache.log != null && Cache.log.isDebugEnabled())
4672 Cache.log.debug("Skipping seuqence set id " + id);
4679 public void addToSkipList(AlignFrame af)
4681 if (skipList == null)
4683 skipList = new Hashtable();
4685 skipList.put(af.getViewport().getSequenceSetId(), af);
4688 public void clearSkipList()
4690 if (skipList != null)
4697 private void recoverDatasetFor(SequenceSet vamsasSet, Alignment al,
4698 boolean ignoreUnrefed)
4700 jalview.datamodel.Alignment ds = getDatasetFor(vamsasSet.getDatasetId());
4701 Vector dseqs = null;
4704 // create a list of new dataset sequences
4705 dseqs = new Vector();
4707 for (int i = 0, iSize = vamsasSet.getSequenceCount(); i < iSize; i++)
4709 Sequence vamsasSeq = vamsasSet.getSequence(i);
4710 ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs, ignoreUnrefed);
4712 // create a new dataset
4715 SequenceI[] dsseqs = new SequenceI[dseqs.size()];
4716 dseqs.copyInto(dsseqs);
4717 ds = new jalview.datamodel.Alignment(dsseqs);
4718 debug("Created new dataset " + vamsasSet.getDatasetId()
4719 + " for alignment " + System.identityHashCode(al));
4720 addDatasetRef(vamsasSet.getDatasetId(), ds);
4722 // set the dataset for the newly imported alignment.
4723 if (al.getDataset() == null && !ignoreUnrefed)
4732 * sequence definition to create/merge dataset sequence for
4736 * vector to add new dataset sequence to
4738 private void ensureJalviewDatasetSequence(Sequence vamsasSeq,
4739 AlignmentI ds, Vector dseqs, boolean ignoreUnrefed)
4741 // JBP TODO: Check this is called for AlCodonFrames to support recovery of
4743 SequenceI sq = seqRefIds.get(vamsasSeq.getId());
4744 SequenceI dsq = null;
4745 if (sq != null && sq.getDatasetSequence() != null)
4747 dsq = sq.getDatasetSequence();
4749 if (sq == null && ignoreUnrefed)
4753 String sqid = vamsasSeq.getDsseqid();
4756 // need to create or add a new dataset sequence reference to this sequence
4759 dsq = seqRefIds.get(sqid);
4764 // make a new dataset sequence
4765 dsq = sq.createDatasetSequence();
4768 // make up a new dataset reference for this sequence
4769 sqid = seqHash(dsq);
4771 dsq.setVamsasId(uniqueSetSuffix + sqid);
4772 seqRefIds.put(sqid, dsq);
4777 dseqs.addElement(dsq);
4782 ds.addSequence(dsq);
4788 { // make this dataset sequence sq's dataset sequence
4789 sq.setDatasetSequence(dsq);
4790 // and update the current dataset alignment
4795 if (!dseqs.contains(dsq))
4802 if (ds.findIndex(dsq) < 0)
4804 ds.addSequence(dsq);
4811 // TODO: refactor this as a merge dataset sequence function
4812 // now check that sq (the dataset sequence) sequence really is the union of
4813 // all references to it
4814 // boolean pre = sq.getStart() < dsq.getStart();
4815 // boolean post = sq.getEnd() > dsq.getEnd();
4819 // StringBuffer sb = new StringBuffer();
4820 String newres = jalview.analysis.AlignSeq.extractGaps(
4821 jalview.util.Comparison.GapChars, sq.getSequenceAsString());
4822 if (!newres.equalsIgnoreCase(dsq.getSequenceAsString())
4823 && newres.length() > dsq.getLength())
4825 // Update with the longer sequence.
4829 * if (pre) { sb.insert(0, newres .substring(0, dsq.getStart() -
4830 * sq.getStart())); dsq.setStart(sq.getStart()); } if (post) {
4831 * sb.append(newres.substring(newres.length() - sq.getEnd() -
4832 * dsq.getEnd())); dsq.setEnd(sq.getEnd()); }
4834 dsq.setSequence(newres);
4836 // TODO: merges will never happen if we 'know' we have the real dataset
4837 // sequence - this should be detected when id==dssid
4839 .println("DEBUG Notice: Merged dataset sequence (if you see this often, post at http://issues.jalview.org/browse/JAL-1474)"); // ("
4840 // + (pre ? "prepended" : "") + " "
4841 // + (post ? "appended" : ""));
4847 * TODO use AlignmentI here and in related methods - needs
4848 * AlignmentI.getDataset() changed to return AlignmentI instead of Alignment
4850 Hashtable<String, Alignment> datasetIds = null;
4852 IdentityHashMap<Alignment, String> dataset2Ids = null;
4854 private Alignment getDatasetFor(String datasetId)
4856 if (datasetIds == null)
4858 datasetIds = new Hashtable<String, Alignment>();
4861 if (datasetIds.containsKey(datasetId))
4863 return datasetIds.get(datasetId);
4868 private void addDatasetRef(String datasetId, Alignment dataset)
4870 if (datasetIds == null)
4872 datasetIds = new Hashtable<String, Alignment>();
4874 datasetIds.put(datasetId, dataset);
4878 * make a new dataset ID for this jalview dataset alignment
4883 private String getDatasetIdRef(Alignment dataset)
4885 if (dataset.getDataset() != null)
4887 warn("Serious issue! Dataset Object passed to getDatasetIdRef is not a Jalview DATASET alignment...");
4889 String datasetId = makeHashCode(dataset, null);
4890 if (datasetId == null)
4892 // make a new datasetId and record it
4893 if (dataset2Ids == null)
4895 dataset2Ids = new IdentityHashMap<Alignment, String>();
4899 datasetId = dataset2Ids.get(dataset);
4901 if (datasetId == null)
4903 datasetId = "ds" + dataset2Ids.size() + 1;
4904 dataset2Ids.put(dataset, datasetId);
4910 private void addDBRefs(SequenceI datasetSequence, Sequence sequence)
4912 for (int d = 0; d < sequence.getDBRefCount(); d++)
4914 DBRef dr = sequence.getDBRef(d);
4915 jalview.datamodel.DBRefEntry entry = new jalview.datamodel.DBRefEntry(
4916 sequence.getDBRef(d).getSource(), sequence.getDBRef(d)
4917 .getVersion(), sequence.getDBRef(d).getAccessionId());
4918 if (dr.getMapping() != null)
4920 entry.setMap(addMapping(dr.getMapping()));
4922 datasetSequence.addDBRef(entry);
4926 private jalview.datamodel.Mapping addMapping(Mapping m)
4928 SequenceI dsto = null;
4929 // Mapping m = dr.getMapping();
4930 int fr[] = new int[m.getMapListFromCount() * 2];
4931 Enumeration f = m.enumerateMapListFrom();
4932 for (int _i = 0; f.hasMoreElements(); _i += 2)
4934 MapListFrom mf = (MapListFrom) f.nextElement();
4935 fr[_i] = mf.getStart();
4936 fr[_i + 1] = mf.getEnd();
4938 int fto[] = new int[m.getMapListToCount() * 2];
4939 f = m.enumerateMapListTo();
4940 for (int _i = 0; f.hasMoreElements(); _i += 2)
4942 MapListTo mf = (MapListTo) f.nextElement();
4943 fto[_i] = mf.getStart();
4944 fto[_i + 1] = mf.getEnd();
4946 jalview.datamodel.Mapping jmap = new jalview.datamodel.Mapping(dsto,
4947 fr, fto, (int) m.getMapFromUnit(), (int) m.getMapToUnit());
4948 if (m.getMappingChoice() != null)
4950 MappingChoice mc = m.getMappingChoice();
4951 if (mc.getDseqFor() != null)
4953 String dsfor = "" + mc.getDseqFor();
4954 if (seqRefIds.containsKey(dsfor))
4959 jmap.setTo(seqRefIds.get(dsfor));
4963 frefedSequence.add(new Object[] { dsfor, jmap });
4969 * local sequence definition
4971 Sequence ms = mc.getSequence();
4972 SequenceI djs = null;
4973 String sqid = ms.getDsseqid();
4974 if (sqid != null && sqid.length() > 0)
4977 * recover dataset sequence
4979 djs = seqRefIds.get(sqid);
4984 .println("Warning - making up dataset sequence id for DbRef sequence map reference");
4985 sqid = ((Object) ms).toString(); // make up a new hascode for
4986 // undefined dataset sequence hash
4987 // (unlikely to happen)
4993 * make a new dataset sequence and add it to refIds hash
4995 djs = new jalview.datamodel.Sequence(ms.getName(),
4997 djs.setStart(jmap.getMap().getToLowest());
4998 djs.setEnd(jmap.getMap().getToHighest());
4999 djs.setVamsasId(uniqueSetSuffix + sqid);
5001 seqRefIds.put(sqid, djs);
5004 jalview.bin.Cache.log.debug("about to recurse on addDBRefs.");
5013 public jalview.gui.AlignmentPanel copyAlignPanel(AlignmentPanel ap,
5014 boolean keepSeqRefs)
5017 JalviewModel jm = saveState(ap, null, null, null);
5022 jm.getJalviewModelSequence().getViewport(0).setSequenceSetId(null);
5026 uniqueSetSuffix = "";
5027 jm.getJalviewModelSequence().getViewport(0).setId(null); // we don't
5032 if (this.frefedSequence == null)
5034 frefedSequence = new Vector();
5037 viewportsAdded.clear();
5039 AlignFrame af = loadFromObject(jm, null, false, null);
5040 af.alignPanels.clear();
5041 af.closeMenuItem_actionPerformed(true);
5044 * if(ap.av.getAlignment().getAlignmentAnnotation()!=null) { for(int i=0;
5045 * i<ap.av.getAlignment().getAlignmentAnnotation().length; i++) {
5046 * if(!ap.av.getAlignment().getAlignmentAnnotation()[i].autoCalculated) {
5047 * af.alignPanel.av.getAlignment().getAlignmentAnnotation()[i] =
5048 * ap.av.getAlignment().getAlignmentAnnotation()[i]; } } }
5051 return af.alignPanel;
5055 * flag indicating if hashtables should be cleared on finalization TODO this
5056 * flag may not be necessary
5058 private final boolean _cleartables = true;
5060 private Hashtable jvids2vobj;
5065 * @see java.lang.Object#finalize()
5068 protected void finalize() throws Throwable
5070 // really make sure we have no buried refs left.
5075 this.seqRefIds = null;
5076 this.seqsToIds = null;
5080 private void warn(String msg)
5085 private void warn(String msg, Exception e)
5087 if (Cache.log != null)
5091 Cache.log.warn(msg, e);
5095 Cache.log.warn(msg);
5100 System.err.println("Warning: " + msg);
5103 e.printStackTrace();
5108 private void debug(String string)
5110 debug(string, null);
5113 private void debug(String msg, Exception e)
5115 if (Cache.log != null)
5119 Cache.log.debug(msg, e);
5123 Cache.log.debug(msg);
5128 System.err.println("Warning: " + msg);
5131 e.printStackTrace();
5137 * set the object to ID mapping tables used to write/recover objects and XML
5138 * ID strings for the jalview project. If external tables are provided then
5139 * finalize and clearSeqRefs will not clear the tables when the Jalview2XML
5140 * object goes out of scope. - also populates the datasetIds hashtable with
5141 * alignment objects containing dataset sequences
5144 * Map from ID strings to jalview datamodel
5146 * Map from jalview datamodel to ID strings
5150 public void setObjectMappingTables(Hashtable vobj2jv,
5151 IdentityHashMap jv2vobj)
5153 this.jv2vobj = jv2vobj;
5154 this.vobj2jv = vobj2jv;
5155 Iterator ds = jv2vobj.keySet().iterator();
5157 while (ds.hasNext())
5159 Object jvobj = ds.next();
5160 id = jv2vobj.get(jvobj).toString();
5161 if (jvobj instanceof jalview.datamodel.Alignment)
5163 if (((jalview.datamodel.Alignment) jvobj).getDataset() == null)
5165 addDatasetRef(id, (jalview.datamodel.Alignment) jvobj);
5168 else if (jvobj instanceof jalview.datamodel.Sequence)
5170 // register sequence object so the XML parser can recover it.
5171 if (seqRefIds == null)
5173 seqRefIds = new HashMap<String, SequenceI>();
5175 if (seqsToIds == null)
5177 seqsToIds = new IdentityHashMap<SequenceI, String>();
5179 seqRefIds.put(jv2vobj.get(jvobj).toString(), (SequenceI) jvobj);
5180 seqsToIds.put((SequenceI) jvobj, id);
5182 else if (jvobj instanceof jalview.datamodel.AlignmentAnnotation)
5185 AlignmentAnnotation jvann = (AlignmentAnnotation) jvobj;
5186 annotationIds.put(anid = jv2vobj.get(jvobj).toString(), jvann);
5187 if (jvann.annotationId == null)
5189 jvann.annotationId = anid;
5191 if (!jvann.annotationId.equals(anid))
5193 // TODO verify that this is the correct behaviour
5194 this.warn("Overriding Annotation ID for " + anid
5195 + " from different id : " + jvann.annotationId);
5196 jvann.annotationId = anid;
5199 else if (jvobj instanceof String)
5201 if (jvids2vobj == null)
5203 jvids2vobj = new Hashtable();
5204 jvids2vobj.put(jvobj, jv2vobj.get(jvobj).toString());
5209 Cache.log.debug("Ignoring " + jvobj.getClass() + " (ID = " + id);
5215 * set the uniqueSetSuffix used to prefix/suffix object IDs for jalview
5216 * objects created from the project archive. If string is null (default for
5217 * construction) then suffix will be set automatically.
5221 public void setUniqueSetSuffix(String string)
5223 uniqueSetSuffix = string;
5228 * uses skipList2 as the skipList for skipping views on sequence sets
5229 * associated with keys in the skipList
5233 public void setSkipList(Hashtable skipList2)
5235 skipList = skipList2;
5239 * Reads the jar entry of given name and returns its contents, or null if the
5240 * entry is not found.
5243 * @param jarEntryName
5246 protected String readJarEntry(jarInputStreamProvider jprovider,
5247 String jarEntryName)
5249 String result = null;
5250 BufferedReader in = null;
5255 * Reopen the jar input stream and traverse its entries to find a matching
5258 JarInputStream jin = jprovider.getJarInputStream();
5259 JarEntry entry = null;
5262 entry = jin.getNextJarEntry();
5263 } while (entry != null && !entry.getName().equals(jarEntryName));
5267 StringBuilder out = new StringBuilder(256);
5268 in = new BufferedReader(new InputStreamReader(jin, UTF_8));
5271 while ((data = in.readLine()) != null)
5275 result = out.toString();
5279 warn("Couldn't find entry in Jalview Jar for " + jarEntryName);
5281 } catch (Exception ex)
5283 ex.printStackTrace();
5291 } catch (IOException e)
5302 * Returns an incrementing counter (0, 1, 2...)
5306 private synchronized int nextCounter()