import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.util.Comparison;
-import jalview.util.Platform;
import jalview.viewmodel.seqfeatures.FeatureRendererModel;
import java.awt.AlphaComposite;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
-import java.util.ArrayList;
import java.util.List;
public class FeatureRenderer extends FeatureRendererModel
int pady = (y1 + charHeight) - charHeight / 5;
FontMetrics fm = g.getFontMetrics();
- char s = '\0';
for (int i = featureStart; i <= featureEnd; i++)
{
+ char s = seq.getCharAt(i);
- // colourOnly is just for Overview -- no need to check this again
-
- if (!colourOnly && Comparison.isGap(s = seq.getCharAt(i)))
+ if (Comparison.isGap(s))
{
continue;
}
g.fillRect((i - start) * charWidth, y1, charWidth, charHeight);
- if (colourOnly)
- {
- return true;
- }
-
- if (!validCharWidth)
+ if (colourOnly || !validCharWidth)
{
continue;
}
}
/**
- *
- * BH - this method is never called?
- *
* Renders the sequence using the given SCORE feature colour between the given
* start and end columns. Returns true if at least one column is drawn, else
* false (the feature range does not overlap the start and end positions).
@Override
public Color findFeatureColour(SequenceI seq, int column, Graphics g)
{
- // BH 2019.08.01
- // this is already checked in FeatureColorFinder
- // if (!av.isShowSequenceFeatures())
- // {
- // return null;
- // }
+ if (!av.isShowSequenceFeatures())
+ {
+ return null;
+ }
// column is 'base 1' but getCharAt is an array index (ie from 0)
if (Comparison.isGap(seq.getCharAt(column - 1)))
* applies), or null if no feature is drawn in the range given.
*
* @param g
- * the graphics context to draw on (may be null only if t == 1 from
- * colourOnly==true)
+ * the graphics context to draw on (may be null if colourOnly==true)
* @param seq
* @param start
* start column
final SequenceI seq, int start, int end, int y1,
boolean colourOnly)
{
- // from SeqCanvas and OverviewRender
/*
* if columns are all gapped, or sequence has no features, nothing to do
*/
- ContiguousI visiblePositions;
- if (!seq.getFeatures().hasFeatures() || (visiblePositions = seq
- .findPositions(start + 1, end + 1)) == null)
+ ContiguousI visiblePositions = seq.findPositions(start + 1, end + 1);
+ if (visiblePositions == null || !seq.getFeatures().hasFeatures())
{
return null;
}
- int vp0 = visiblePositions.getBegin();
- int vp1 = visiblePositions.getEnd();
-
updateFeatures();
- if (transparency != 1f) // g cannot be null here if trans == 1f - BH // && g
- // != null)
+ if (transparency != 1f && g != null)
{
- ((Graphics2D) g).setComposite(
- AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
+ Graphics2D g2 = (Graphics2D) g;
+ g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
transparency));
}
/*
* iterate over features in ordering of their rendering (last is on top)
*/
- for (int renderIndex = 0, n = renderOrder.length; renderIndex < n; renderIndex++)
+ for (int renderIndex = 0; renderIndex < renderOrder.length; renderIndex++)
{
String type = renderOrder[renderIndex];
- if (!seq.hasFeatures(type) || !showFeatureOfType(type))
+ if (!showFeatureOfType(type))
{
continue;
}
FeatureColourI fc = getFeatureStyle(type);
- List<SequenceFeature> overlaps = seq.getFeatures().findFeatures(vp0,
- vp1, type);
+ List<SequenceFeature> overlaps = seq.getFeatures().findFeatures(
+ visiblePositions.getBegin(), visiblePositions.getEnd(), type);
- // colourOnly (i.e. Overview) can only be here if translucent, so
- // there is no need to check for filtering
- if (!colourOnly && fc.isSimpleColour())
+ if (fc.isSimpleColour())
{
filterFeaturesForDisplay(overlaps);
}
- for (int i = overlaps.size(); --i >= 0;)
+ for (SequenceFeature sf : overlaps)
{
- SequenceFeature sf = overlaps.get(i);
Color featureColour = getColor(sf, fc);
if (featureColour == null)
{
* restrict to visible positions (or if a contact feature,
* to a single position)
*/
- int sf0 = sf.getBegin();
- int sf1 = sf.getEnd();
- int visibleStart = sf0;
- if (visibleStart < vp0)
+ int visibleStart = sf.getBegin();
+ if (visibleStart < visiblePositions.getBegin())
{
- visibleStart = sf.isContactFeature() ? sf1 : vp0;
+ visibleStart = sf.isContactFeature() ? sf.getEnd()
+ : visiblePositions.getBegin();
}
- int visibleEnd = sf1;
- if (visibleEnd > vp1)
+ int visibleEnd = sf.getEnd();
+ if (visibleEnd > visiblePositions.getEnd())
{
- visibleEnd = sf.isContactFeature() ? sf0 : vp1;
+ visibleEnd = sf.isContactFeature() ? sf.getBegin()
+ : visiblePositions.getEnd();
}
int featureStartCol = seq.findIndex(visibleStart);
- int featureEndCol = (sf.begin == sf.end ? featureStartCol
- : seq.findIndex(visibleEnd));
+ int featureEndCol = sf.begin == sf.end ? featureStartCol : seq
+ .findIndex(visibleEnd);
// Color featureColour = getColour(sequenceFeature);
else
{
*/
- boolean drawn = renderFeature(g, seq, featureStartCol - 1,
- featureEndCol - 1, featureColour, start, end, y1,
- colourOnly);
- if (drawn)
- {
- drawnColour = featureColour;
- }
+ boolean drawn = renderFeature(g, seq,
+ featureStartCol - 1,
+ featureEndCol - 1, featureColour,
+ start, end, y1, colourOnly);
+ if (drawn)
+ {
+ drawnColour = featureColour;
+ }
/*}*/
}
}
}
- if (transparency != 1.0f)
+ if (transparency != 1.0f && g != null)
{
/*
* reset transparency
*/
- ((Graphics2D) g).setComposite(NO_TRANSPARENCY);
+ Graphics2D g2 = (Graphics2D) g;
+ g2.setComposite(NO_TRANSPARENCY);
}
return drawnColour;
findAllFeatures();
}
- private List<SequenceFeature> overlaps = (Platform.isJS()
- ? new ArrayList<>()
- : null);
-
/**
* Returns the sequence feature colour rendered at the given column position,
* or null if none found. The feature of highest render order (i.e. on top) is
* colour for features enclosing a gapped column. Check for gap before calling
* if different behaviour is wanted.
*
- * BH 2019.07.30
- *
- * Adds a result ArrayList to parameters in order to avoid an unnecessary
- * construction of that for every pixel checked.
- *
- *
* @param seq
* @param column
* (1..)
* @return
*/
- private Color findFeatureColour(SequenceI seq, int column)
+ Color findFeatureColour(SequenceI seq, int column)
{
/*
* check for new feature added while processing
* inspect features in reverse renderOrder (the last in the array is
* displayed on top) until we find one that is rendered at the position
*/
- for (int renderIndex = renderOrder.length; --renderIndex >= 0;)
+ for (int renderIndex = renderOrder.length
+ - 1; renderIndex >= 0; renderIndex--)
{
String type = renderOrder[renderIndex];
- if (!seq.hasFeatures(type) || !showFeatureOfType(type))
+ if (!showFeatureOfType(type))
{
continue;
}
- if (overlaps != null)
+ List<SequenceFeature> overlaps = seq.findFeatures(column, column,
+ type);
+ for (SequenceFeature sequenceFeature : overlaps)
{
- overlaps.clear();
- }
- List<SequenceFeature> list = seq.findFeatures(column, type, overlaps);
- if (list.size() > 0)
- {
- for (int i = 0, n = list.size(); i < n; i++)
+ if (!featureGroupNotShown(sequenceFeature))
{
- SequenceFeature sf = list.get(i);
- if (featureGroupNotShown(sf))
- {
- continue;
- }
- Color col = getColour(sf);
+ Color col = getColour(sequenceFeature);
if (col != null)
{
return col;
git://source.jalview.org / jalview.git / blobdiff