X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fviewmodel%2Fseqfeatures%2FFeatureRendererModel.java;h=ec2c59134b8a245e2107587a1e27aba62baa7e46;hb=776d0215fb7a0935b228670f1d2a0e880921128e;hp=a53004d6aab18f6378f44e801aacbc45d46c0d68;hpb=1f491c8c9e66b3accb8bb9eae78c7d9caa63c1ac;p=jalview.git diff --git a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java index a53004d..ec2c591 100644 --- a/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java +++ b/src/jalview/viewmodel/seqfeatures/FeatureRendererModel.java @@ -1,6 +1,27 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.viewmodel.seqfeatures; import jalview.api.AlignViewportI; +import jalview.api.FeatureColourI; import jalview.api.FeaturesDisplayedI; import jalview.datamodel.AlignmentI; import jalview.datamodel.SequenceFeature; @@ -14,13 +35,12 @@ import java.beans.PropertyChangeListener; import java.beans.PropertyChangeSupport; import java.util.ArrayList; import java.util.Arrays; -import java.util.Enumeration; +import java.util.HashMap; import java.util.Hashtable; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; -import java.util.Vector; import java.util.concurrent.ConcurrentHashMap; public abstract class FeatureRendererModel implements @@ -38,6 +58,9 @@ public abstract class FeatureRendererModel implements protected Object currentColour; + /* + * feature types in ordering of rendering, where last means on top + */ protected String[] renderOrder; protected PropertyChangeSupport changeSupport = new PropertyChangeSupport( @@ -45,6 +68,13 @@ public abstract class FeatureRendererModel implements protected AlignmentViewport av; + /* + * map holds per feature type, {{min, max}, {min, max}} feature score + * values for positional and non-positional features respectively + */ + private Map minmax = new Hashtable(); + + @Override public AlignViewportI getViewport() { return av; @@ -121,8 +151,7 @@ public abstract class FeatureRendererModel implements } if (!fdi.isRegistered(featureType)) { - pushFeatureType(Arrays.asList(new String[] - { featureType })); + pushFeatureType(Arrays.asList(new String[] { featureType })); } fdi.setVisible(featureType); } @@ -165,15 +194,13 @@ public abstract class FeatureRendererModel implements types.toArray(neworder); if (renderOrder != null) { - System.arraycopy(neworder,0,neworder,renderOrder.length,ts); + System.arraycopy(neworder, 0, neworder, renderOrder.length, ts); System.arraycopy(renderOrder, 0, neworder, 0, renderOrder.length); } renderOrder = neworder; } - protected Hashtable minmax = new Hashtable(); - - public Hashtable getMinMax() + public Map getMinMax() { return minmax; } @@ -187,9 +214,8 @@ public abstract class FeatureRendererModel implements */ protected final byte[] normaliseScore(SequenceFeature sequenceFeature) { - float[] mm = ((float[][]) minmax.get(sequenceFeature.type))[0]; - final byte[] r = new byte[] - { 0, (byte) 255 }; + float[] mm = minmax.get(sequenceFeature.type)[0]; + final byte[] r = new byte[] { 0, (byte) 255 }; if (mm != null) { if (r[0] != 0 || mm[0] < 0.0) @@ -248,11 +274,12 @@ public abstract class FeatureRendererModel implements { ArrayList tmp = new ArrayList(); SequenceFeature[] features = sequence.getSequenceFeatures(); + if (features != null) { for (int i = 0; i < features.length; i++) { - if (av.areFeaturesDisplayed() + if (!av.areFeaturesDisplayed() || !av.getFeaturesDisplayed().isVisible( features[i].getType())) { @@ -262,9 +289,11 @@ public abstract class FeatureRendererModel implements if (features[i].featureGroup != null && featureGroups != null && featureGroups.containsKey(features[i].featureGroup) - && !((Boolean) featureGroups.get(features[i].featureGroup)) + && !featureGroups.get(features[i].featureGroup) .booleanValue()) + { continue; + } if ((features[i].getBegin() <= res) && (features[i].getEnd() >= res)) @@ -316,15 +345,13 @@ public abstract class FeatureRendererModel implements } if (minmax == null) { - minmax = new Hashtable(); + minmax = new Hashtable(); } AlignmentI alignment = av.getAlignment(); for (int i = 0; i < alignment.getHeight(); i++) { SequenceI asq = alignment.getSequenceAt(i); - SequenceI dasq = asq.getDatasetSequence(); - SequenceFeature[] features = dasq != null ? dasq - .getSequenceFeatures() : asq.getSequenceFeatures(); + SequenceFeature[] features = asq.getSequenceFeatures(); if (features == null) { @@ -345,7 +372,7 @@ public abstract class FeatureRendererModel implements groupDisplayed = Boolean.valueOf(newMadeVisible); featureGroups.put(fgrp, groupDisplayed); } - if (!((Boolean) groupDisplayed).booleanValue()) + if (!groupDisplayed.booleanValue()) { index++; continue; @@ -370,20 +397,19 @@ public abstract class FeatureRendererModel implements { allfeatures.add(features[index].getType()); } - if (features[index].score != Float.NaN) + if (!Float.isNaN(features[index].score)) { int nonpos = features[index].getBegin() >= 1 ? 0 : 1; - float[][] mm = (float[][]) minmax.get(features[index].getType()); + float[][] mm = minmax.get(features[index].getType()); if (mm == null) { - mm = new float[][] - { null, null }; + mm = new float[][] { null, null }; minmax.put(features[index].getType(), mm); } if (mm[nonpos] == null) { - mm[nonpos] = new float[] - { features[index].score, features[index].score }; + mm[nonpos] = new float[] { features[index].score, + features[index].score }; } else @@ -434,8 +460,7 @@ public abstract class FeatureRendererModel implements { if (initOrders) { - setOrder(oldRender[j], (1 - (1 + (float) j) - / (float) oldRender.length)); + setOrder(oldRender[j], (1 - (1 + (float) j) / oldRender.length)); } if (allfeatures.contains(oldRender[j])) { @@ -522,6 +547,7 @@ public abstract class FeatureRendererModel implements * @param featureType * @return java.awt.Color or GraduatedColor */ + @Override public Object getFeatureStyle(String featureType) { Object fc = featureColours.get(featureType); @@ -535,31 +561,6 @@ public abstract class FeatureRendererModel implements } /** - * return a nominal colour for this feature - * - * @param featureType - * @return standard color, or maximum colour for graduated colourscheme - */ - public Color getColour(String featureType) - { - Object fc = getFeatureStyle(featureType); - - if (fc instanceof Color) - { - return (Color) fc; - } - else - { - if (fc instanceof GraduatedColor) - { - return ((GraduatedColor) fc).getMaxColor(); - } - } - throw new Error("Implementation Error: Unrecognised render object " - + fc.getClass() + " for features of type " + featureType); - } - - /** * calculate the render colour for a specific feature using current feature * settings. * @@ -602,6 +603,7 @@ public abstract class FeatureRendererModel implements return av.getFeaturesDisplayed().isVisible(type); } + @Override public void setColour(String featureType, Object col) { // overwrite @@ -610,9 +612,18 @@ public abstract class FeatureRendererModel implements // Object c = featureColours.get(featureType); // if (c == null || c instanceof Color || (c instanceof GraduatedColor && // !((GraduatedColor)c).getMaxColor().equals(_col))) + if (col instanceof FeatureColourI) { - featureColours.put(featureType, col); + if (((FeatureColourI) col).isGraduatedColour()) + { + col = new GraduatedColor((FeatureColourI) col); + } + else + { + col = ((FeatureColourI) col).getColour(); + } } + featureColours.put(featureType, col); } public void setTransparency(float value) @@ -666,9 +677,9 @@ public abstract class FeatureRendererModel implements } @Override - public Map getFeatureColours() + public Map getFeatureColours() { - return new ConcurrentHashMap<>(featureColours); + return featureColours; } /** @@ -676,21 +687,32 @@ public abstract class FeatureRendererModel implements * * @param data * { String(Type), Colour(Type), Boolean(Displayed) } + * @return true if any visible features have been reordered, else false */ - public void setFeaturePriority(Object[][] data) + public boolean setFeaturePriority(Object[][] data) { - setFeaturePriority(data, true); + return setFeaturePriority(data, true); } /** + * Sets the priority order for features * * @param data * { String(Type), Colour(Type), Boolean(Displayed) } * @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) */ - public void setFeaturePriority(Object[][] data, boolean visibleNew) + public boolean setFeaturePriority(Object[][] data, boolean visibleNew) { + /* + * note visible feature ordering and colours before update + */ + List visibleFeatures = getDisplayedFeatureTypes(); + Map visibleColours = new HashMap( + getFeatureColours()); + FeaturesDisplayedI av_featuresdisplayed = null; if (visibleNew) { @@ -709,10 +731,10 @@ public abstract class FeatureRendererModel implements } if (data == null) { - return; + return false; } // The feature table will display high priority - // features at the top, but theses are the ones + // features at the top, but these are the ones // we need to render last, so invert the data renderOrder = new String[data.length]; @@ -732,6 +754,30 @@ public abstract class FeatureRendererModel implements } } + /* + * get the new visible ordering and return true if it has changed + * order or any colour has changed + */ + List reorderedVisibleFeatures = getDisplayedFeatureTypes(); + if (!visibleFeatures.equals(reorderedVisibleFeatures)) + { + /* + * the list of ordered visible features has changed + */ + return true; + } + + /* + * return true if any feature colour has changed + */ + for (String feature : visibleFeatures) + { + if (visibleColours.get(feature) != getFeatureStyle(feature)) + { + return true; + } + } + return false; } /** @@ -752,7 +798,7 @@ public abstract class FeatureRendererModel implements changeSupport.removePropertyChangeListener(listener); } - public Set getAllFeatureColours() + public Set getAllFeatureColours() { return featureColours.keySet(); } @@ -767,12 +813,14 @@ public abstract class FeatureRendererModel implements return renderOrder != null; } + /** + * Returns feature types in ordering of rendering, where last means on top + */ public List getRenderOrder() { if (renderOrder == null) { - return Arrays.asList(new String[] - {}); + return Arrays.asList(new String[] {}); } return Arrays.asList(renderOrder); } @@ -799,7 +847,7 @@ public abstract class FeatureRendererModel implements } if (featureGroups.containsKey(group)) { - return ((Boolean) featureGroups.get(group)).booleanValue(); + return featureGroups.get(group).booleanValue(); } if (newGroupsVisible) { @@ -825,7 +873,7 @@ public abstract class FeatureRendererModel implements for (Object grp : featureGroups.keySet()) { - Boolean state = (Boolean) featureGroups.get(grp); + Boolean state = featureGroups.get(grp); if (state.booleanValue() == visible) { gp.add(grp); @@ -854,7 +902,7 @@ public abstract class FeatureRendererModel implements featureGroups.put(gst, new Boolean(visible)); if (st != null) { - rdrw = rdrw || (visible != ((Boolean) st).booleanValue()); + rdrw = rdrw || (visible != st.booleanValue()); } } if (rdrw) @@ -877,7 +925,7 @@ public abstract class FeatureRendererModel implements while (en.hasNext()) { String col = en.next(); - fcols.put(col, getColour(col)); + fcols.put(col, featureColours.get(col)); } return fcols; } @@ -888,39 +936,39 @@ public abstract class FeatureRendererModel implements return av.getFeaturesDisplayed(); } + /** + * Returns a (possibly empty) list of visible feature types, in render order + * (last is on top) + */ @Override - public String[] getDisplayedFeatureTypes() + public List getDisplayedFeatureTypes() { - String[] typ = null; - typ = getRenderOrder().toArray(new String[0]); + List typ = getRenderOrder(); + List displayed = new ArrayList(); FeaturesDisplayedI feature_disp = av.getFeaturesDisplayed(); if (feature_disp != null) { synchronized (feature_disp) { - for (int i = 0; i < typ.length; i++) + for (String type : typ) { - if (feature_disp.isVisible(typ[i])) + if (feature_disp.isVisible(type)) { - typ[i] = null; + displayed.add(type); } } } } - return typ; + return displayed; } @Override - public String[] getDisplayedFeatureGroups() + public List getDisplayedFeatureGroups() { - String[] gps = null; - ArrayList _gps = new ArrayList(); - Iterator en = getFeatureGroups().iterator(); - int g = 0; + List _gps = new ArrayList(); boolean valid = false; - while (en.hasNext()) + for (String gp : getFeatureGroups()) { - String gp = (String) en.next(); if (checkGroupVisibility(gp, false)) { valid = true; @@ -932,11 +980,11 @@ public abstract class FeatureRendererModel implements } else { - gps = new String[_gps.size()]; - _gps.toArray(gps); + // gps = new String[_gps.size()]; + // _gps.toArray(gps); } } - return gps; + return _gps; } }