*/
package jalview.viewmodel.seqfeatures;
+import java.awt.Color;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
import jalview.api.AlignViewportI;
+import jalview.api.AlignmentViewPanel;
import jalview.api.FeatureColourI;
import jalview.api.FeaturesDisplayedI;
import jalview.datamodel.AlignedCodonFrame;
+import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.MappedFeatures;
-import jalview.datamodel.Mapping;
import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResults;
import jalview.datamodel.SearchResultsI;
import jalview.renderer.seqfeatures.FeatureRenderer;
import jalview.schemes.FeatureColour;
import jalview.util.ColorUtils;
-
-import java.awt.Color;
-import java.beans.PropertyChangeListener;
-import java.beans.PropertyChangeSupport;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Hashtable;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
+import jalview.util.Platform;
public abstract class FeatureRendererModel
implements jalview.api.FeatureRenderer
Map<String, Float> featureOrder = null;
- protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
- this);
-
protected AlignViewportI av;
+ private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
+ this);
+
@Override
public AlignViewportI getViewport()
{
{
firing = Boolean.TRUE;
findAllFeatures(true); // add all new features as visible
- changeSupport.firePropertyChange("changeSupport", null, null);
+ notifyFeaturesChanged();
firing = Boolean.FALSE;
}
}
}
@Override
- public List<SequenceFeature> findFeaturesAtColumn(SequenceI sequence, int column)
+ public void notifyFeaturesChanged()
+ {
+ changeSupport.firePropertyChange("changeSupport", null, null);
+ }
+
+ @Override
+ public List<SequenceFeature> findFeaturesAtColumn(SequenceI sequence,
+ int column)
{
/*
* include features at the position provided their feature type is
}
if (groupDisplayed)
{
- Set<String> types = asq.getFeatures().getFeatureTypesForGroups(
- true, group);
+ Set<String> types = asq.getFeatures()
+ .getFeatureTypesForGroups(true, group);
for (String type : types)
{
if (!allfeatures.contains(type)) // or use HashSet and no test?
}
}
}
+
protected Boolean firing = Boolean.FALSE;
/**
* @param type
* @return
*/
- protected boolean showFeatureOfType(String type)
+ public boolean showFeatureOfType(String type)
{
- return type == null ? false : (av.getFeaturesDisplayed() == null ? true
- : av.getFeaturesDisplayed().isVisible(type));
+ return type == null ? false
+ : (av.getFeaturesDisplayed() == null ? true
+ : av.getFeaturesDisplayed().isVisible(type));
}
@Override
{
featureOrder = new Hashtable<>();
}
- featureOrder.put(type, new Float(position));
+ featureOrder.put(type, Float.valueOf(position));
return position;
}
}
/**
- * Sets the priority order for features, with the highest priority (displayed on
- * top) at the start of the data array
+ * Sets the priority order for features, with the highest priority (displayed
+ * on top) at the start of the data array
*
* @param data
* an array of { Type, Colour, Filter, Boolean }
* @param visibleNew
* when true current featureDisplay list will be cleared
- * @return true if any visible features have been reordered or recoloured, else
- * false (i.e. no need to repaint)
+ * @return true if any visible features have been reordered or recoloured,
+ * else false (i.e. no need to repaint)
*/
public boolean setFeaturePriority(FeatureSettingsBean[] data,
boolean visibleNew)
* @param listener
* @see java.beans.PropertyChangeSupport#addPropertyChangeListener(java.beans.PropertyChangeListener)
*/
+ @Override
public void addPropertyChangeListener(PropertyChangeListener listener)
{
changeSupport.addPropertyChangeListener(listener);
* @param listener
* @see java.beans.PropertyChangeSupport#removePropertyChangeListener(java.beans.PropertyChangeListener)
*/
+ @Override
public void removePropertyChangeListener(PropertyChangeListener listener)
{
changeSupport.removePropertyChangeListener(listener);
}
if (newGroupsVisible)
{
- featureGroups.put(group, new Boolean(true));
+ featureGroups.put(group, Boolean.valueOf(true));
return true;
}
return false;
@Override
public void setGroupVisibility(String group, boolean visible)
{
- featureGroups.put(group, new Boolean(visible));
+ featureGroups.put(group, Boolean.valueOf(visible));
}
@Override
for (String gst : toset)
{
Boolean st = featureGroups.get(gst);
- featureGroups.put(gst, new Boolean(visible));
+ featureGroups.put(gst, Boolean.valueOf(visible));
if (st != null)
{
rdrw = rdrw || (visible != st.booleanValue());
*/
public boolean featureGroupNotShown(final SequenceFeature sequenceFeature)
{
- return featureGroups != null
- && sequenceFeature.featureGroup != null
+ return featureGroups != null && sequenceFeature.featureGroup != null
&& sequenceFeature.featureGroup.length() != 0
&& featureGroups.containsKey(sequenceFeature.featureGroup)
&& !featureGroups.get(sequenceFeature.featureGroup)
List<String> visibleFeatures = getDisplayedFeatureTypes();
String[] visibleTypes = visibleFeatures
.toArray(new String[visibleFeatures.size()]);
- List<SequenceFeature> features = sequence.getFeatures().findFeatures(
- fromResNo, toResNo, visibleTypes);
-
+ List<SequenceFeature> features = sequence.getFeatures()
+ .findFeatures(fromResNo, toResNo, visibleTypes);
+
for (SequenceFeature sf : features)
{
if (!featureGroupNotShown(sf) && getColour(sf) != null)
}
/**
- * Removes from the list of features any that duplicate the location of a
- * feature of the same type. Should be used only for features of the same,
- * simple, feature colour (which normally implies the same feature type). Does
- * not check visibility settings for feature type or feature group. No
- * filtering is done if transparency, or any feature filters, are in force.
+ * Removes from the list of features any whose group is not shown, or that are
+ * visible and duplicate the location of a visible feature of the same type.
+ * Should be used only for features of the same, simple, feature colour (which
+ * normally implies the same feature type). No filtering is done if
+ * transparency, or any feature filters, are in force.
*
* @param features
*/
public void filterFeaturesForDisplay(List<SequenceFeature> features)
{
/*
+ * fudge: JalviewJS's IntervalStore lacks the sort method called :-(
+ */
+ if (Platform.isJS())
+ {
+ return;
+ }
+
+ /*
* don't remove 'redundant' features if
* - transparency is applied (feature count affects depth of feature colour)
* - filters are applied (not all features may be displayable)
while (it.hasNext())
{
SequenceFeature sf = it.next();
+ if (featureGroupNotShown(sf))
+ {
+ it.remove();
+ continue;
+ }
/*
* a feature is redundant for rendering purposes if it has the
}
@Override
- public void setFeatureFilter(String featureType, FeatureMatcherSetI filter)
+ public void setFeatureFilter(String featureType,
+ FeatureMatcherSetI filter)
{
if (filter == null || filter.isEmpty())
{
/**
* Answers the colour for the feature, or null if the feature is excluded by
* feature group visibility, by filters, or by colour threshold settings. This
- * method does not take feature visibility into account.
+ * method does not take feature type visibility into account.
*
* @param sf
* @param fc
{
return null;
}
-
+
return fc.getColor(sf);
}
}
/**
- * Answers a bean containing a mapping, and a list of features in this
- * alignment at a position (or range) which is mappable from the given
- * sequence residue position in a mapped alignment. Features are returned in
- * render order of feature type (on top last), with order within feature type
- * undefined. If no features or mapping are found, answers null.
+ * Answers true unless the specified group is set to hidden. Defaults to true
+ * if group visibility is not set.
*
- * @param sequence
- * @param pos
+ * @param group
* @return
*/
- public MappedFeatures findComplementFeaturesAtResidue(SequenceI sequence,
- int pos)
+ public boolean isGroupVisible(String group)
+ {
+ if (!featureGroups.containsKey(group))
+ {
+ return true;
+ }
+ return featureGroups.get(group);
+ }
+
+ /**
+ * Orders features in render precedence (last in order is last to render, so
+ * displayed on top of other features)
+ *
+ * @param order
+ */
+ public void orderFeatures(Comparator<String> order)
+ {
+ Arrays.sort(renderOrder, order);
+ }
+
+ @Override
+ public MappedFeatures findComplementFeaturesAtResidue(
+ final SequenceI sequence, final int pos)
{
SequenceI ds = sequence.getDatasetSequence();
if (ds == null)
.getCodonFrame(sequence);
/*
+ * fudge: if no mapping found, check the complementary alignment
+ * todo: only store in one place? StructureSelectionManager?
+ */
+ if (mappings.isEmpty())
+ {
+ mappings = this.av.getCodingComplement().getAlignment()
+ .getCodonFrame(sequence);
+ }
+
+ /*
* todo: direct lookup of CDS for peptide and vice-versa; for now,
* have to search through an unordered list of mappings for a candidate
*/
- Mapping mapping = null;
+ SequenceToSequenceMapping mapping = null;
SequenceI mapFrom = null;
for (AlignedCodonFrame acf : mappings)
{
- mapping = acf.getMappingForSequence(sequence, true);
- if (mapping == null || mapping.getMap().getFromRatio() == mapping
- .getMap().getToRatio())
+ mapping = acf.getCoveringCodonMapping(ds);
+ if (mapping == null)
{
- continue; // we are only looking for 3:1 or 1:3 mappings
+ continue;
}
SearchResultsI sr = new SearchResults();
- acf.markMappedRegion(ds, pos, sr);
+ mapping.markMappedRegion(ds, pos, sr);
for (SearchResultMatchI match : sr.getResults())
{
int fromRes = match.getStart();
int toRes = match.getEnd();
mapFrom = match.getSequence();
- List<SequenceFeature> fs = findFeaturesAtResidue(
- match.getSequence(), fromRes, toRes);
+ List<SequenceFeature> fs = findFeaturesAtResidue(mapFrom, fromRes,
+ toRes);
for (SequenceFeature sf : fs)
{
if (!found.contains(sf))
}
/*
- * sort by renderorder, inefficiently
+ * sort by renderorder (inefficiently but ok for small scale);
+ * NB this sorts 'on top' feature to end, for rendering
*/
List<SequenceFeature> result = new ArrayList<>();
+ final int toAdd = found.size();
+ int added = 0;
for (String type : renderOrder)
{
for (SequenceFeature sf : found)
if (type.equals(sf.getType()))
{
result.add(sf);
- if (result.size() == found.size())
- {
- return new MappedFeatures(mapping, mapFrom, pos, residue,
- result);
- }
+ added++;
+ }
+ if (added == toAdd)
+ {
+ break;
}
}
}
-
- return new MappedFeatures(mapping, mapFrom, pos, residue, result);
+
+ return new MappedFeatures(mapping.getMapping(), mapFrom, pos, residue,
+ result);
+ }
+
+ @Override
+ public boolean isVisible(SequenceFeature feature)
+ {
+ if (feature == null)
+ {
+ return false;
+ }
+ if (getFeaturesDisplayed() == null
+ || !getFeaturesDisplayed().isVisible(feature.getType()))
+ {
+ return false;
+ }
+ if (featureGroupNotShown(feature))
+ {
+ return false;
+ }
+ FeatureColourI fc = featureColours.get(feature.getType());
+ if (fc != null && fc.isOutwithThreshold(feature))
+ {
+ return false;
+ }
+ if (!featureMatchesFilters(feature))
+ {
+ return false;
+ }
+ return true;
}
+ @Override
+ public AlignmentViewPanel getAlignPanel()
+ {
+ return null;
+ }
}