/*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.0b1)
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
* Copyright (C) 2014 The Jalview Authors
*
* This file is part of Jalview.
*
* Jalview is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
*
* Jalview is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
- * You should have received a copy of the GNU General Public License along with Jalview. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
* The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.gui;
-import java.awt.Rectangle;
-import java.io.*;
-import java.lang.reflect.InvocationTargetException;
-import java.net.*;
-import java.util.*;
-import java.util.Map.Entry;
-import java.util.jar.*;
-
-import javax.swing.*;
-
-import org.exolab.castor.xml.*;
-
+import jalview.api.structures.JalviewStructureDisplayI;
import jalview.bin.Cache;
import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceI;
-import jalview.schemabinding.version2.*;
-import jalview.schemes.*;
+import jalview.schemabinding.version2.AlcodMap;
+import jalview.schemabinding.version2.Alcodon;
+import jalview.schemabinding.version2.AlcodonFrame;
+import jalview.schemabinding.version2.Annotation;
+import jalview.schemabinding.version2.AnnotationColours;
+import jalview.schemabinding.version2.AnnotationElement;
+import jalview.schemabinding.version2.CalcIdParam;
+import jalview.schemabinding.version2.DBRef;
+import jalview.schemabinding.version2.Features;
+import jalview.schemabinding.version2.Group;
+import jalview.schemabinding.version2.HiddenColumns;
+import jalview.schemabinding.version2.JGroup;
+import jalview.schemabinding.version2.JSeq;
+import jalview.schemabinding.version2.JalviewModel;
+import jalview.schemabinding.version2.JalviewModelSequence;
+import jalview.schemabinding.version2.MapListFrom;
+import jalview.schemabinding.version2.MapListTo;
+import jalview.schemabinding.version2.Mapping;
+import jalview.schemabinding.version2.MappingChoice;
+import jalview.schemabinding.version2.OtherData;
+import jalview.schemabinding.version2.PdbentryItem;
+import jalview.schemabinding.version2.Pdbids;
+import jalview.schemabinding.version2.Property;
+import jalview.schemabinding.version2.Sequence;
+import jalview.schemabinding.version2.SequenceSet;
+import jalview.schemabinding.version2.SequenceSetProperties;
+import jalview.schemabinding.version2.Setting;
+import jalview.schemabinding.version2.StructureState;
+import jalview.schemabinding.version2.ThresholdLine;
+import jalview.schemabinding.version2.Tree;
+import jalview.schemabinding.version2.UserColours;
+import jalview.schemabinding.version2.Viewport;
+import jalview.schemes.AnnotationColourGradient;
+import jalview.schemes.ColourSchemeI;
+import jalview.schemes.ColourSchemeProperty;
+import jalview.schemes.GraduatedColor;
+import jalview.schemes.ResidueColourScheme;
+import jalview.schemes.ResidueProperties;
+import jalview.structure.StructureSelectionManager;
+import jalview.util.MessageManager;
import jalview.util.Platform;
import jalview.util.jarInputStreamProvider;
import jalview.viewmodel.AlignmentViewport;
import jalview.ws.params.AutoCalcSetting;
import jalview.ws.params.WsParamSetI;
+import java.awt.Rectangle;
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.Vector;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+import java.util.jar.JarOutputStream;
+
+import javax.swing.JInternalFrame;
+import javax.swing.JOptionPane;
+import javax.swing.SwingUtilities;
+
+import org.exolab.castor.xml.Unmarshaller;
+
/**
* Write out the current jalview desktop state as a Jalview XML stream.
*
.startsWith(
jmol.jmb.pdbentry[peid].getId()
.toLowerCase())))
+ {
continue;
+ }
if (matchedFile == null)
{
matchedFile = jmol.jmb.pdbentry[peid].getFile();
}
else if (sg.cs instanceof jalview.schemes.AnnotationColourGradient)
{
- groups[i]
- .setColour(ColourSchemeProperty
- .getColourName(((jalview.schemes.AnnotationColourGradient) sg.cs)
- .getBaseColour()));
+ groups[i].setColour("AnnotationColourGradient");
+ groups[i].setAnnotationColours(constructAnnotationColours(
+ (jalview.schemes.AnnotationColourGradient) sg.cs,
+ userColours, jms));
}
else if (sg.cs instanceof jalview.schemes.UserColourScheme)
{
}
else if (av.getGlobalColourScheme() instanceof jalview.schemes.AnnotationColourGradient)
{
- jalview.schemes.AnnotationColourGradient acg = (jalview.schemes.AnnotationColourGradient) av
- .getGlobalColourScheme();
-
- AnnotationColours ac = new AnnotationColours();
- ac.setAboveThreshold(acg.getAboveThreshold());
- ac.setThreshold(acg.getAnnotationThreshold());
- ac.setAnnotation(acg.getAnnotation());
- if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
- {
- ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(),
- userColours, jms));
- }
- else
- {
- ac.setColourScheme(ColourSchemeProperty.getColourName(acg
- .getBaseColour()));
- }
+ AnnotationColours ac = constructAnnotationColours(
+ (jalview.schemes.AnnotationColourGradient) av
+ .getGlobalColourScheme(),
+ userColours, jms);
- ac.setMaxColour(acg.getMaxColour().getRGB());
- ac.setMinColour(acg.getMinColour().getRGB());
- ac.setPerSequence(acg.isSeqAssociated());
- ac.setPredefinedColours(acg.isPredefinedColours());
view.setAnnotationColours(ac);
view.setBgColour("AnnotationColourGradient");
}
view.setShowBoxes(av.getShowBoxes());
view.setShowColourText(av.getColourText());
view.setShowFullId(av.getShowJVSuffix());
- view.setRightAlignIds(av.rightAlignIds);
+ view.setRightAlignIds(av.isRightAlignIds());
view.setShowSequenceFeatures(av.showSequenceFeatures);
view.setShowText(av.getShowText());
view.setShowUnconserved(av.getShowUnconserved());
view.setFollowHighlight(av.followHighlight);
view.setFollowSelection(av.followSelection);
view.setIgnoreGapsinConsensus(av.getIgnoreGapsConsensus());
- if (av.featuresDisplayed != null)
+ if (av.getFeaturesDisplayed() != null)
{
jalview.schemabinding.version2.FeatureSettings fs = new jalview.schemabinding.version2.FeatureSettings();
- String[] renderOrder = ap.seqPanel.seqCanvas.getFeatureRenderer().renderOrder;
+ String[] renderOrder = ap.getSeqPanel().seqCanvas.getFeatureRenderer().renderOrder;
Vector settingsAdded = new Vector();
Object gstyle = null;
{
for (int ro = 0; ro < renderOrder.length; ro++)
{
- gstyle = ap.seqPanel.seqCanvas.getFeatureRenderer()
+ gstyle = ap.getSeqPanel().seqCanvas.getFeatureRenderer()
.getFeatureStyle(renderOrder[ro]);
Setting setting = new Setting();
setting.setType(renderOrder[ro]);
}
else
{
- setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer()
+ setting.setColour(ap.getSeqPanel().seqCanvas.getFeatureRenderer()
.getColour(renderOrder[ro]).getRGB());
}
- setting.setDisplay(av.featuresDisplayed
+ setting.setDisplay(av.getFeaturesDisplayed()
.containsKey(renderOrder[ro]));
- float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer()
+ float rorder = ap.getSeqPanel().seqCanvas.getFeatureRenderer()
.getOrder(renderOrder[ro]);
if (rorder > -1)
{
}
// Make sure we save none displayed feature settings
- Iterator en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureColours
+ Iterator en = ap.getSeqPanel().seqCanvas.getFeatureRenderer().featureColours
.keySet().iterator();
while (en.hasNext())
{
Setting setting = new Setting();
setting.setType(key);
- setting.setColour(ap.seqPanel.seqCanvas.getFeatureRenderer()
+ setting.setColour(ap.getSeqPanel().seqCanvas.getFeatureRenderer()
.getColour(key).getRGB());
setting.setDisplay(false);
- float rorder = ap.seqPanel.seqCanvas.getFeatureRenderer()
+ float rorder = ap.getSeqPanel().seqCanvas.getFeatureRenderer()
.getOrder(key);
if (rorder > -1)
{
fs.addSetting(setting);
settingsAdded.addElement(key);
}
- en = ap.seqPanel.seqCanvas.getFeatureRenderer().featureGroups
+ en = ap.getSeqPanel().seqCanvas.getFeatureRenderer().featureGroups
.keySet().iterator();
Vector groupsAdded = new Vector();
while (en.hasNext())
}
Group g = new Group();
g.setName(grp);
- g.setDisplay(((Boolean) ap.seqPanel.seqCanvas
+ g.setDisplay(((Boolean) ap.getSeqPanel().seqCanvas
.getFeatureRenderer().featureGroups.get(grp))
.booleanValue());
fs.addGroup(g);
return object;
}
- private void storeAlignmentAnnotation(AlignmentAnnotation[] aa, IdentityHashMap groupRefs, AlignmentViewport av, Set<String> calcIdSet, boolean storeDS, SequenceSet vamsasSet)
+ private AnnotationColours constructAnnotationColours(
+ AnnotationColourGradient acg, Vector userColours,
+ JalviewModelSequence jms)
+ {
+ AnnotationColours ac = new AnnotationColours();
+ ac.setAboveThreshold(acg.getAboveThreshold());
+ ac.setThreshold(acg.getAnnotationThreshold());
+ ac.setAnnotation(acg.getAnnotation());
+ if (acg.getBaseColour() instanceof jalview.schemes.UserColourScheme)
+ {
+ ac.setColourScheme(SetUserColourScheme(acg.getBaseColour(),
+ userColours, jms));
+ }
+ else
+ {
+ ac.setColourScheme(ColourSchemeProperty.getColourName(acg
+ .getBaseColour()));
+ }
+
+ ac.setMaxColour(acg.getMaxColour().getRGB());
+ ac.setMinColour(acg.getMinColour().getRGB());
+ ac.setPerSequence(acg.isSeqAssociated());
+ ac.setPredefinedColours(acg.isPredefinedColours());
+ return ac;
+ }
+
+ private void storeAlignmentAnnotation(AlignmentAnnotation[] aa,
+ IdentityHashMap groupRefs, AlignmentViewport av,
+ Set<String> calcIdSet, boolean storeDS, SequenceSet vamsasSet)
{
for (int i = 0; i < aa.length; i++)
calcIdSet.add(aa[i].getCalcId());
an.setCalcId(aa[i].getCalcId());
}
-
+ if (aa[i].hasProperties())
+ {
+ for (String pr : aa[i].getProperties())
+ {
+ Property prop = new Property();
+ prop.setName(pr);
+ prop.setValue(aa[i].getProperty(pr));
+ an.addProperty(prop);
+ }
+ }
AnnotationElement ae;
if (aa[i].annotations != null)
{
ae = new AnnotationElement();
if (aa[i].annotations[a].description != null)
+ {
ae.setDescription(aa[i].annotations[a].description);
+ }
if (aa[i].annotations[a].displayCharacter != null)
+ {
ae.setDisplayCharacter(aa[i].annotations[a].displayCharacter);
+ }
if (!Float.isNaN(aa[i].annotations[a].value))
+ {
ae.setValue(aa[i].annotations[a].value);
+ }
ae.setPosition(a);
- if (aa[i].annotations[a].secondaryStructure != ' '
- && aa[i].annotations[a].secondaryStructure != '\0')
+ if (aa[i].annotations[a].secondaryStructure > ' ')
+ {
ae.setSecondaryStructure(aa[i].annotations[a].secondaryStructure
+ "");
+ }
if (aa[i].annotations[a].colour != null
&& aa[i].annotations[a].colour != java.awt.Color.black)
return false;
}
}
- throw new Error("Unsupported Version for calcIdparam "
- + calcIdParam.toString());
+ throw new Error(MessageManager.formatMessage("error.unsupported_version_calcIdparam", new String[]{calcIdParam.toString()}));
}
/**
try
{
// create list to store references for any new Jmol viewers created
- newStructureViewers = new Vector<AppJmol>();
+ newStructureViewers = new Vector<JalviewStructureDisplayI>();
// UNMARSHALLER SEEMS TO CLOSE JARINPUTSTREAM, MOST ANNOYING
// Workaround is to make sure caller implements the JarInputStreamProvider
// interface
if (object.getJalviewModelSequence().getViewportCount() > 0)
{
af = _af;
- if (object.getJalviewModelSequence().getViewportCount() > 1
- && af.viewport.gatherViewsHere)
+ if (af.viewport.gatherViewsHere)
{
gatherToThisFrame.put(af.viewport.getSequenceSetId(), af);
}
errorMessage = null;
}
- Hashtable alreadyLoadedPDB;
+ Hashtable<String, String> alreadyLoadedPDB;
/**
* when set, local views will be updated from view stored in JalviewXML
String loadPDBFile(jarInputStreamProvider jprovider, String pdbId)
{
if (alreadyLoadedPDB == null)
+ {
alreadyLoadedPDB = new Hashtable();
+ }
if (alreadyLoadedPDB.containsKey(pdbId))
+ {
return alreadyLoadedPDB.get(pdbId).toString();
+ }
try
{
}
else
{
- recoverDatasetFor(vamsasSet, al);
+ // recover dataset - passing on flag indicating if this a 'viewless'
+ // sequence set (a.k.a. a stored dataset for the project)
+ recoverDatasetFor(vamsasSet, al, object.getJalviewModelSequence()
+ .getViewportCount() == 0);
}
// ///////////////////////////////
entry.setFile(pdbloaded.get(ids[p].getId()).toString());
}
}
-
+ StructureSelectionManager.getStructureSelectionManager(
+ Desktop.instance)
+ .registerPDBEntry(entry);
al.getSequenceAt(i).getDatasetSequence().addPDBId(entry);
}
}
// in principle Visible should always be true for annotation displayed
// in multiple views
if (an[i].hasVisible())
+ {
jda.visible = an[i].getVisible();
+ }
al.addAnnotation(jda);
anpos = ae[aa].getPosition();
if (anpos >= anot.length)
+ {
continue;
+ }
anot[anpos] = new jalview.datamodel.Annotation(
jaa.setScore(an[i].getScore());
}
if (an[i].hasVisible())
+ {
jaa.visible = an[i].getVisible();
+ }
if (an[i].hasCentreColLabels())
+ {
jaa.centreColLabels = an[i].getCentreColLabels();
+ }
if (an[i].hasScaleColLabels())
{
jaa.belowAlignment = an[i].isBelowAlignment();
}
jaa.setCalcId(an[i].getCalcId());
-
+ if (an[i].getPropertyCount() > 0)
+ {
+ for (jalview.schemabinding.version2.Property prop : an[i]
+ .getProperty())
+ {
+ jaa.setProperty(prop.getName(), prop.getValue());
+ }
+ }
if (jaa.autoCalculated)
{
autoAlan.add(new JvAnnotRow(i, jaa));
if (jms.getJGroupCount() > 0)
{
JGroup[] groups = jms.getJGroup();
-
+ boolean addAnnotSchemeGroup = false;
for (int i = 0; i < groups.length; i++)
{
ColourSchemeI cs = null;
{
cs = GetUserColourScheme(jms, groups[i].getColour());
}
+ else if (groups[i].getColour().equals("AnnotationColourGradient")
+ && groups[i].getAnnotationColours() != null)
+ {
+ addAnnotSchemeGroup = true;
+ cs = null;
+ }
else
{
cs = ColourSchemeProperty.getColour(al, groups[i].getColour());
}
}
al.addGroup(sg);
-
+ if (addAnnotSchemeGroup)
+ {
+ // reconstruct the annotation colourscheme
+ sg.cs = constructAnnotationColour(
+ groups[i].getAnnotationColours(), null, al, jms, false);
+ }
}
}
if (view == null)
}
}
+ /**
+ * indicate that annotation colours are applied across all groups (pre
+ * Jalview 2.8.1 behaviour)
+ */
+ boolean doGroupAnnColour = isVersionStringLaterThan("2.8.1",
+ object.getVersion());
+
AlignmentPanel ap = null;
boolean isnewview = true;
if (viewId != null)
@Override
public void run()
{
- AppJmol sview = null;
+ JalviewStructureDisplayI sview = null;
try
{
- sview = new AppJmol(pdbf, id, sq, alf.alignPanel,
+ // JAL-1333 note - we probably can't migrate Jmol views to UCSF Chimera!
+ sview = new StructureViewer(alf.alignPanel.getStructureSelectionManager()).createView(StructureViewer.Viewer.JMOL, pdbf, id, sq, alf.alignPanel,
useinJmolsuperpos, usetoColourbyseq,
jmolColouring, fileloc, rect, vid);
addNewStructureViewer(sview);
// and finally return.
return af;
}
- Vector<AppJmol> newStructureViewers=null;
- protected void addNewStructureViewer(AppJmol sview)
+
+ /**
+ *
+ * @param supported
+ * - minimum version we are comparing against
+ * @param version
+ * - version of data being processsed.
+ * @return true if version is development/null or evaluates to the same or
+ * later X.Y.Z (where X,Y,Z are like [0-9]+b?[0-9]*)
+ */
+ private boolean isVersionStringLaterThan(String supported, String version)
+ {
+ if (version == null || version.equalsIgnoreCase("DEVELOPMENT BUILD")
+ || version.equalsIgnoreCase("Test")
+ || version.equalsIgnoreCase("AUTOMATED BUILD"))
+ {
+ System.err.println("Assuming project file with "
+ + (version == null ? "null" : version)
+ + " is compatible with Jalview version " + supported);
+ return true;
+ }
+ else
+ {
+ StringTokenizer currentV = new StringTokenizer(supported, "."), fileV = new StringTokenizer(
+ version, ".");
+ while (currentV.hasMoreTokens() && fileV.hasMoreTokens())
+ {
+ // convert b to decimal to catch bugfix releases within a series
+ String curT = currentV.nextToken().toLowerCase().replace('b', '.');
+ String fileT = fileV.nextToken().toLowerCase().replace('b', '.');
+ try
+ {
+ if (Float.valueOf(curT) > Float.valueOf(fileT))
+ {
+ // current version is newer than the version that wrote the file
+ return false;
+ }
+ } catch (NumberFormatException nfe)
+ {
+ System.err
+ .println("** WARNING: Version comparison failed for tokens ("
+ + curT
+ + ") and ("
+ + fileT
+ + ")\n** Current: '"
+ + supported + "' and Version: '" + version + "'");
+ }
+ }
+ if (currentV.hasMoreElements())
+ {
+ // fileV has no minor version but identical series to current
+ return false;
+ }
+ }
+ return true;
+ }
+
+ Vector<JalviewStructureDisplayI> newStructureViewers = null;
+
+ protected void addNewStructureViewer(JalviewStructureDisplayI sview)
{
if (newStructureViewers != null)
{
- sview.jmb.setFinishedLoadingFromArchive(false);
+ sview.getBinding().setFinishedLoadingFromArchive(false);
newStructureViewers.add(sview);
}
}
{
if (newStructureViewers != null)
{
- for (AppJmol sview : newStructureViewers)
+ for (JalviewStructureDisplayI sview : newStructureViewers)
{
- sview.jmb.setFinishedLoadingFromArchive(true);
+ sview.getBinding().setFinishedLoadingFromArchive(true);
}
newStructureViewers.clear();
newStructureViewers = null;
af.viewport.setConservationSelected(view.getConservationSelected());
af.viewport.setShowJVSuffix(view.getShowFullId());
- af.viewport.rightAlignIds = view.getRightAlignIds();
+ af.viewport.setRightAlignIds(view.getRightAlignIds());
af.viewport.setFont(new java.awt.Font(view.getFontName(), view
.getFontStyle(), view.getFontSize()));
af.alignPanel.fontChanged();
}
else if (view.getBgColour().startsWith("Annotation"))
{
- // int find annotation
- if (af.viewport.getAlignment().getAlignmentAnnotation() != null)
- {
- for (int i = 0; i < af.viewport.getAlignment()
- .getAlignmentAnnotation().length; i++)
- {
- if (af.viewport.getAlignment().getAlignmentAnnotation()[i].label
- .equals(view.getAnnotationColours().getAnnotation()))
- {
- if (af.viewport.getAlignment().getAlignmentAnnotation()[i]
- .getThreshold() == null)
- {
- af.viewport.getAlignment().getAlignmentAnnotation()[i]
- .setThreshold(new jalview.datamodel.GraphLine(view
- .getAnnotationColours().getThreshold(),
- "Threshold", java.awt.Color.black)
-
- );
- }
-
- if (view.getAnnotationColours().getColourScheme()
- .equals("None"))
- {
- cs = new AnnotationColourGradient(af.viewport
- .getAlignment().getAlignmentAnnotation()[i],
- new java.awt.Color(view.getAnnotationColours()
- .getMinColour()), new java.awt.Color(view
- .getAnnotationColours().getMaxColour()),
- view.getAnnotationColours().getAboveThreshold());
- }
- else if (view.getAnnotationColours().getColourScheme()
- .startsWith("ucs"))
- {
- cs = new AnnotationColourGradient(af.viewport
- .getAlignment().getAlignmentAnnotation()[i],
- GetUserColourScheme(jms, view
- .getAnnotationColours().getColourScheme()),
- view.getAnnotationColours().getAboveThreshold());
- }
- else
- {
- cs = new AnnotationColourGradient(af.viewport
- .getAlignment().getAlignmentAnnotation()[i],
- ColourSchemeProperty.getColour(al, view
- .getAnnotationColours().getColourScheme()),
- view.getAnnotationColours().getAboveThreshold());
- }
- if (view.getAnnotationColours().hasPerSequence())
- {
- ((AnnotationColourGradient)cs).setSeqAssociated(view.getAnnotationColours().isPerSequence());
- }
- if (view.getAnnotationColours().hasPredefinedColours())
- {
- ((AnnotationColourGradient)cs).setPredefinedColours(view.getAnnotationColours().isPredefinedColours());
- }
- // Also use these settings for all the groups
- if (al.getGroups() != null)
- {
- for (int g = 0; g < al.getGroups().size(); g++)
- {
- jalview.datamodel.SequenceGroup sg = al.getGroups()
- .get(g);
-
- if (sg.cs == null)
- {
- continue;
- }
-
- /*
- * if
- * (view.getAnnotationColours().getColourScheme().equals("None"
- * )) { sg.cs = new AnnotationColourGradient(
- * af.viewport.getAlignment().getAlignmentAnnotation()[i], new
- * java.awt.Color(view.getAnnotationColours().
- * getMinColour()), new
- * java.awt.Color(view.getAnnotationColours().
- * getMaxColour()),
- * view.getAnnotationColours().getAboveThreshold()); } else
- */
- {
- sg.cs = new AnnotationColourGradient(af.viewport
- .getAlignment().getAlignmentAnnotation()[i],
- sg.cs, view.getAnnotationColours()
- .getAboveThreshold());
- if (cs instanceof AnnotationColourGradient)
- {
- if (view.getAnnotationColours().hasPerSequence())
- {
- ((AnnotationColourGradient)cs).setSeqAssociated(view.getAnnotationColours().isPerSequence());
- }
- if (view.getAnnotationColours().hasPredefinedColours())
- {
- ((AnnotationColourGradient)cs).setPredefinedColours(view.getAnnotationColours().isPredefinedColours());
- }
- }
- }
+ AnnotationColours viewAnnColour = view.getAnnotationColours();
+ cs = constructAnnotationColour(viewAnnColour, af, al, jms, true);
- }
- }
-
- break;
- }
+ // annpos
- }
- }
}
else
{
// recover featre settings
if (jms.getFeatureSettings() != null)
{
- af.viewport.featuresDisplayed = new Hashtable();
+ af.viewport.setFeaturesDisplayed(new Hashtable());
String[] renderOrder = new String[jms.getFeatureSettings()
.getSettingCount()];
for (int fs = 0; fs < jms.getFeatureSettings().getSettingCount(); fs++)
gc.setColourByLabel(setting.getColourByLabel());
}
// and put in the feature colour table.
- af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(
+ af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer().setColour(
setting.getType(), gc);
}
else
{
- af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setColour(
+ af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer().setColour(
setting.getType(),
new java.awt.Color(setting.getColour()));
}
renderOrder[fs] = setting.getType();
if (setting.hasOrder())
- af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(
+ {
+ af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer().setOrder(
setting.getType(), setting.getOrder());
+ }
else
- af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().setOrder(
+ {
+ af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer().setOrder(
setting.getType(),
fs / jms.getFeatureSettings().getSettingCount());
+ }
if (setting.getDisplay())
{
- af.viewport.featuresDisplayed.put(setting.getType(), new Integer(
+ af.viewport.getFeaturesDisplayed().put(setting.getType(), new Integer(
setting.getColour()));
}
}
- af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().renderOrder = renderOrder;
+ af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer().renderOrder = renderOrder;
Hashtable fgtable;
- af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().featureGroups = fgtable = new Hashtable();
+ af.alignPanel.getSeqPanel().seqCanvas.getFeatureRenderer().featureGroups = fgtable = new Hashtable();
for (int gs = 0; gs < jms.getFeatureSettings().getGroupCount(); gs++)
{
Group grp = jms.getFeatureSettings().getGroup(gs);
return af;
}
+ private ColourSchemeI constructAnnotationColour(
+ AnnotationColours viewAnnColour, AlignFrame af, Alignment al,
+ JalviewModelSequence jms, boolean checkGroupAnnColour)
+ {
+ boolean propagateAnnColour = false;
+ ColourSchemeI cs = null;
+ AlignmentI annAlignment = af != null ? af.viewport.getAlignment() : al;
+ if (checkGroupAnnColour && al.getGroups() != null
+ && al.getGroups().size() > 0)
+ {
+ // pre 2.8.1 behaviour
+ // check to see if we should transfer annotation colours
+ propagateAnnColour = true;
+ for (jalview.datamodel.SequenceGroup sg : al.getGroups())
+ {
+ if (sg.cs instanceof AnnotationColourGradient)
+ {
+ propagateAnnColour = false;
+ }
+ }
+ }
+ // int find annotation
+ if (annAlignment.getAlignmentAnnotation() != null)
+ {
+ for (int i = 0; i < annAlignment.getAlignmentAnnotation().length; i++)
+ {
+ if (annAlignment.getAlignmentAnnotation()[i].label
+ .equals(viewAnnColour.getAnnotation()))
+ {
+ if (annAlignment.getAlignmentAnnotation()[i].getThreshold() == null)
+ {
+ annAlignment.getAlignmentAnnotation()[i]
+ .setThreshold(new jalview.datamodel.GraphLine(
+ viewAnnColour.getThreshold(), "Threshold",
+ java.awt.Color.black)
+
+ );
+ }
+
+ if (viewAnnColour.getColourScheme().equals("None"))
+ {
+ cs = new AnnotationColourGradient(
+ annAlignment.getAlignmentAnnotation()[i],
+ new java.awt.Color(viewAnnColour.getMinColour()),
+ new java.awt.Color(viewAnnColour.getMaxColour()),
+ viewAnnColour.getAboveThreshold());
+ }
+ else if (viewAnnColour.getColourScheme().startsWith("ucs"))
+ {
+ cs = new AnnotationColourGradient(
+ annAlignment.getAlignmentAnnotation()[i],
+ GetUserColourScheme(jms,
+ viewAnnColour.getColourScheme()),
+ viewAnnColour.getAboveThreshold());
+ }
+ else
+ {
+ cs = new AnnotationColourGradient(
+ annAlignment.getAlignmentAnnotation()[i],
+ ColourSchemeProperty.getColour(al,
+ viewAnnColour.getColourScheme()),
+ viewAnnColour.getAboveThreshold());
+ }
+ if (viewAnnColour.hasPerSequence())
+ {
+ ((AnnotationColourGradient) cs).setSeqAssociated(viewAnnColour
+ .isPerSequence());
+ }
+ if (viewAnnColour.hasPredefinedColours())
+ {
+ ((AnnotationColourGradient) cs)
+ .setPredefinedColours(viewAnnColour
+ .isPredefinedColours());
+ }
+ if (propagateAnnColour && al.getGroups() != null)
+ {
+ // Also use these settings for all the groups
+ for (int g = 0; g < al.getGroups().size(); g++)
+ {
+ jalview.datamodel.SequenceGroup sg = al.getGroups().get(g);
+
+ if (sg.cs == null)
+ {
+ continue;
+ }
+
+ /*
+ * if (viewAnnColour.getColourScheme().equals("None" )) { sg.cs =
+ * new AnnotationColourGradient(
+ * annAlignment.getAlignmentAnnotation()[i], new
+ * java.awt.Color(viewAnnColour. getMinColour()), new
+ * java.awt.Color(viewAnnColour. getMaxColour()),
+ * viewAnnColour.getAboveThreshold()); } else
+ */
+ {
+ sg.cs = new AnnotationColourGradient(
+ annAlignment.getAlignmentAnnotation()[i], sg.cs,
+ viewAnnColour.getAboveThreshold());
+ if (cs instanceof AnnotationColourGradient)
+ {
+ if (viewAnnColour.hasPerSequence())
+ {
+ ((AnnotationColourGradient) cs)
+ .setSeqAssociated(viewAnnColour.isPerSequence());
+ }
+ if (viewAnnColour.hasPredefinedColours())
+ {
+ ((AnnotationColourGradient) cs)
+ .setPredefinedColours(viewAnnColour
+ .isPredefinedColours());
+ }
+ }
+ }
+
+ }
+ }
+
+ break;
+ }
+
+ }
+ }
+ return cs;
+ }
+
private void reorderAutoannotation(AlignFrame af, Alignment al,
ArrayList<JvAnnotRow> autoAlan)
{
}
}
- private void recoverDatasetFor(SequenceSet vamsasSet, Alignment al)
+ private void recoverDatasetFor(SequenceSet vamsasSet, Alignment al,
+ boolean ignoreUnrefed)
{
jalview.datamodel.Alignment ds = getDatasetFor(vamsasSet.getDatasetId());
Vector dseqs = null;
for (int i = 0, iSize = vamsasSet.getSequenceCount(); i < iSize; i++)
{
Sequence vamsasSeq = vamsasSet.getSequence(i);
- ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs);
+ ensureJalviewDatasetSequence(vamsasSeq, ds, dseqs, ignoreUnrefed);
}
// create a new dataset
if (ds == null)
addDatasetRef(vamsasSet.getDatasetId(), ds);
}
// set the dataset for the newly imported alignment.
- if (al.getDataset() == null)
+ if (al.getDataset() == null && !ignoreUnrefed)
{
al.setDataset(ds);
}
* vector to add new dataset sequence to
*/
private void ensureJalviewDatasetSequence(Sequence vamsasSeq,
- AlignmentI ds, Vector dseqs)
+ AlignmentI ds, Vector dseqs, boolean ignoreUnrefed)
{
// JBP TODO: Check this is called for AlCodonFrames to support recovery of
// xRef Codon Maps
{
dsq = sq.getDatasetSequence();
}
-
+ if (sq == null && ignoreUnrefed)
+ {
+ return;
+ }
String sqid = vamsasSeq.getDsseqid();
if (dsq == null)
{
}
}
else
+ {
Cache.log.debug("Ignoring " + jvobj.getClass() + " (ID = " + id);
+ }
}
}