JAL-2094 new classes ColorI, Colour added
[jalview.git] / src / jalview / viewmodel / seqfeatures / FeatureRendererModel.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
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.
11  *  
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.
16  * 
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.
20  */
21 package jalview.viewmodel.seqfeatures;
22
23 import jalview.api.AlignViewportI;
24 import jalview.api.FeatureColourI;
25 import jalview.api.FeaturesDisplayedI;
26 import jalview.datamodel.AlignmentI;
27 import jalview.datamodel.SequenceFeature;
28 import jalview.datamodel.SequenceI;
29 import jalview.renderer.seqfeatures.FeatureRenderer;
30 import jalview.schemes.Colour;
31 import jalview.schemes.FeatureColour;
32 import jalview.schemes.UserColourScheme;
33 import jalview.util.ColorUtils;
34 import jalview.viewmodel.AlignmentViewport;
35
36 import java.awt.Color;
37 import java.beans.PropertyChangeListener;
38 import java.beans.PropertyChangeSupport;
39 import java.util.ArrayList;
40 import java.util.Arrays;
41 import java.util.HashMap;
42 import java.util.Hashtable;
43 import java.util.Iterator;
44 import java.util.List;
45 import java.util.Map;
46 import java.util.Set;
47 import java.util.concurrent.ConcurrentHashMap;
48
49 public abstract class FeatureRendererModel implements
50         jalview.api.FeatureRenderer
51 {
52
53   /**
54    * global transparency for feature
55    */
56   protected float transparency = 1.0f;
57
58   protected Map<String, FeatureColourI> featureColours = new ConcurrentHashMap<String, FeatureColourI>();
59
60   protected Map<String, Boolean> featureGroups = new ConcurrentHashMap<String, Boolean>();
61
62   protected String[] renderOrder;
63
64   Map<String, Float> featureOrder = null;
65
66   protected PropertyChangeSupport changeSupport = new PropertyChangeSupport(
67           this);
68
69   protected AlignmentViewport av;
70
71   /*
72    * map holds per feature type, {{min, max}, {min, max}} feature score
73    * values for positional and non-positional features respectively
74    */
75   private Map<String, float[][]> minmax = new Hashtable<String, float[][]>();
76
77   @Override
78   public AlignViewportI getViewport()
79   {
80     return av;
81   }
82
83   public FeatureRendererSettings getSettings()
84   {
85     return new FeatureRendererSettings(this);
86   }
87
88   public void transferSettings(FeatureRendererSettings fr)
89   {
90     this.renderOrder = fr.renderOrder;
91     this.featureGroups = fr.featureGroups;
92     this.featureColours = fr.featureColours;
93     this.transparency = fr.transparency;
94     this.featureOrder = fr.featureOrder;
95   }
96
97   /**
98    * update from another feature renderer
99    * 
100    * @param fr
101    *          settings to copy
102    */
103   public void transferSettings(jalview.api.FeatureRenderer _fr)
104   {
105     FeatureRenderer fr = (FeatureRenderer) _fr;
106     FeatureRendererSettings frs = new FeatureRendererSettings(fr);
107     this.renderOrder = frs.renderOrder;
108     this.featureGroups = frs.featureGroups;
109     this.featureColours = frs.featureColours;
110     this.transparency = frs.transparency;
111     this.featureOrder = frs.featureOrder;
112     if (av != null && av != fr.getViewport())
113     {
114       // copy over the displayed feature settings
115       if (_fr.getFeaturesDisplayed() != null)
116       {
117         FeaturesDisplayedI fd = getFeaturesDisplayed();
118         if (fd == null)
119         {
120           setFeaturesDisplayedFrom(_fr.getFeaturesDisplayed());
121         }
122         else
123         {
124           synchronized (fd)
125           {
126             fd.clear();
127             java.util.Iterator<String> fdisp = _fr.getFeaturesDisplayed()
128                     .getVisibleFeatures();
129             while (fdisp.hasNext())
130             {
131               fd.setVisible(fdisp.next());
132             }
133           }
134         }
135       }
136     }
137   }
138
139   public void setFeaturesDisplayedFrom(FeaturesDisplayedI featuresDisplayed)
140   {
141     av.setFeaturesDisplayed(new FeaturesDisplayed(featuresDisplayed));
142   }
143
144   @Override
145   public void setVisible(String featureType)
146   {
147     FeaturesDisplayedI fdi = av.getFeaturesDisplayed();
148     if (fdi == null)
149     {
150       av.setFeaturesDisplayed(fdi = new FeaturesDisplayed());
151     }
152     if (!fdi.isRegistered(featureType))
153     {
154       pushFeatureType(Arrays.asList(new String[] { featureType }));
155     }
156     fdi.setVisible(featureType);
157   }
158
159   @Override
160   public void setAllVisible(List<String> featureTypes)
161   {
162     FeaturesDisplayedI fdi = av.getFeaturesDisplayed();
163     if (fdi == null)
164     {
165       av.setFeaturesDisplayed(fdi = new FeaturesDisplayed());
166     }
167     List<String> nft = new ArrayList<String>();
168     for (String featureType : featureTypes)
169     {
170       if (!fdi.isRegistered(featureType))
171       {
172         nft.add(featureType);
173       }
174     }
175     if (nft.size() > 0)
176     {
177       pushFeatureType(nft);
178     }
179     fdi.setAllVisible(featureTypes);
180   }
181
182   /**
183    * push a set of new types onto the render order stack. Note - this is a
184    * direct mechanism rather than the one employed in updateRenderOrder
185    * 
186    * @param types
187    */
188   private void pushFeatureType(List<String> types)
189   {
190
191     int ts = types.size();
192     String neworder[] = new String[(renderOrder == null ? 0
193             : renderOrder.length) + ts];
194     types.toArray(neworder);
195     if (renderOrder != null)
196     {
197       System.arraycopy(neworder, 0, neworder, renderOrder.length, ts);
198       System.arraycopy(renderOrder, 0, neworder, 0, renderOrder.length);
199     }
200     renderOrder = neworder;
201   }
202
203   public Map<String, float[][]> getMinMax()
204   {
205     return minmax;
206   }
207
208   /**
209    * normalise a score against the max/min bounds for the feature type.
210    * 
211    * @param sequenceFeature
212    * @return byte[] { signed, normalised signed (-127 to 127) or unsigned
213    *         (0-255) value.
214    */
215   protected final byte[] normaliseScore(SequenceFeature sequenceFeature)
216   {
217     float[] mm = minmax.get(sequenceFeature.type)[0];
218     final byte[] r = new byte[] { 0, (byte) 255 };
219     if (mm != null)
220     {
221       if (r[0] != 0 || mm[0] < 0.0)
222       {
223         r[0] = 1;
224         r[1] = (byte) ((int) 128.0 + 127.0 * (sequenceFeature.score / mm[1]));
225       }
226       else
227       {
228         r[1] = (byte) ((int) 255.0 * (sequenceFeature.score / mm[1]));
229       }
230     }
231     return r;
232   }
233
234   boolean newFeatureAdded = false;
235
236   boolean findingFeatures = false;
237
238   protected boolean updateFeatures()
239   {
240     if (av.getFeaturesDisplayed() == null || renderOrder == null
241             || newFeatureAdded)
242     {
243       findAllFeatures();
244       if (av.getFeaturesDisplayed().getVisibleFeatureCount() < 1)
245       {
246         return false;
247       }
248     }
249     // TODO: decide if we should check for the visible feature count first
250     return true;
251   }
252
253   /**
254    * search the alignment for all new features, give them a colour and display
255    * them. Then fires a PropertyChangeEvent on the changeSupport object.
256    * 
257    */
258   protected void findAllFeatures()
259   {
260     synchronized (firing)
261     {
262       if (firing.equals(Boolean.FALSE))
263       {
264         firing = Boolean.TRUE;
265         findAllFeatures(true); // add all new features as visible
266         changeSupport.firePropertyChange("changeSupport", null, null);
267         firing = Boolean.FALSE;
268       }
269     }
270   }
271
272   @Override
273   public List<SequenceFeature> findFeaturesAtRes(SequenceI sequence, int res)
274   {
275     ArrayList<SequenceFeature> tmp = new ArrayList<SequenceFeature>();
276     SequenceFeature[] features = sequence.getSequenceFeatures();
277
278     if (features != null)
279     {
280       for (int i = 0; i < features.length; i++)
281       {
282         if (!av.areFeaturesDisplayed()
283                 || !av.getFeaturesDisplayed().isVisible(
284                         features[i].getType()))
285         {
286           continue;
287         }
288
289         if (features[i].featureGroup != null
290                 && featureGroups != null
291                 && featureGroups.containsKey(features[i].featureGroup)
292                 && !featureGroups.get(features[i].featureGroup)
293                         .booleanValue())
294         {
295           continue;
296         }
297
298         if ((features[i].getBegin() <= res)
299                 && (features[i].getEnd() >= res))
300         {
301           tmp.add(features[i]);
302         }
303       }
304     }
305     return tmp;
306   }
307
308   /**
309    * Searches alignment for all features and updates colours
310    * 
311    * @param newMadeVisible
312    *          if true newly added feature types will be rendered immediatly
313    *          TODO: check to see if this method should actually be proxied so
314    *          repaint events can be propagated by the renderer code
315    */
316   @Override
317   public synchronized void findAllFeatures(boolean newMadeVisible)
318   {
319     newFeatureAdded = false;
320
321     if (findingFeatures)
322     {
323       newFeatureAdded = true;
324       return;
325     }
326
327     findingFeatures = true;
328     if (av.getFeaturesDisplayed() == null)
329     {
330       av.setFeaturesDisplayed(new FeaturesDisplayed());
331     }
332     FeaturesDisplayedI featuresDisplayed = av.getFeaturesDisplayed();
333
334     ArrayList<String> allfeatures = new ArrayList<String>();
335     ArrayList<String> oldfeatures = new ArrayList<String>();
336     if (renderOrder != null)
337     {
338       for (int i = 0; i < renderOrder.length; i++)
339       {
340         if (renderOrder[i] != null)
341         {
342           oldfeatures.add(renderOrder[i]);
343         }
344       }
345     }
346     if (minmax == null)
347     {
348       minmax = new Hashtable<String, float[][]>();
349     }
350     AlignmentI alignment = av.getAlignment();
351     for (int i = 0; i < alignment.getHeight(); i++)
352     {
353       SequenceI asq = alignment.getSequenceAt(i);
354       SequenceFeature[] features = asq.getSequenceFeatures();
355
356       if (features == null)
357       {
358         continue;
359       }
360
361       int index = 0;
362       while (index < features.length)
363       {
364         if (!featuresDisplayed.isRegistered(features[index].getType()))
365         {
366           String fgrp = features[index].getFeatureGroup();
367           if (fgrp != null)
368           {
369             Boolean groupDisplayed = featureGroups.get(fgrp);
370             if (groupDisplayed == null)
371             {
372               groupDisplayed = Boolean.valueOf(newMadeVisible);
373               featureGroups.put(fgrp, groupDisplayed);
374             }
375             if (!groupDisplayed.booleanValue())
376             {
377               index++;
378               continue;
379             }
380           }
381           if (!(features[index].begin == 0 && features[index].end == 0))
382           {
383             // If beginning and end are 0, the feature is for the whole sequence
384             // and we don't want to render the feature in the normal way
385
386             if (newMadeVisible
387                     && !oldfeatures.contains(features[index].getType()))
388             {
389               // this is a new feature type on the alignment. Mark it for
390               // display.
391               featuresDisplayed.setVisible(features[index].getType());
392               setOrder(features[index].getType(), 0);
393             }
394           }
395         }
396         if (!allfeatures.contains(features[index].getType()))
397         {
398           allfeatures.add(features[index].getType());
399         }
400         if (!Float.isNaN(features[index].score))
401         {
402           int nonpos = features[index].getBegin() >= 1 ? 0 : 1;
403           float[][] mm = minmax.get(features[index].getType());
404           if (mm == null)
405           {
406             mm = new float[][] { null, null };
407             minmax.put(features[index].getType(), mm);
408           }
409           if (mm[nonpos] == null)
410           {
411             mm[nonpos] = new float[] { features[index].score,
412                 features[index].score };
413
414           }
415           else
416           {
417             if (mm[nonpos][0] > features[index].score)
418             {
419               mm[nonpos][0] = features[index].score;
420             }
421             if (mm[nonpos][1] < features[index].score)
422             {
423               mm[nonpos][1] = features[index].score;
424             }
425           }
426         }
427         index++;
428       }
429     }
430     updateRenderOrder(allfeatures);
431     findingFeatures = false;
432   }
433
434   protected Boolean firing = Boolean.FALSE;
435
436   /**
437    * replaces the current renderOrder with the unordered features in
438    * allfeatures. The ordering of any types in both renderOrder and allfeatures
439    * is preserved, and all new feature types are rendered on top of the existing
440    * types, in the order given by getOrder or the order given in allFeatures.
441    * Note. this operates directly on the featureOrder hash for efficiency. TODO:
442    * eliminate the float storage for computing/recalling the persistent ordering
443    * New Cability: updates min/max for colourscheme range if its dynamic
444    * 
445    * @param allFeatures
446    */
447   private void updateRenderOrder(List<String> allFeatures)
448   {
449     List<String> allfeatures = new ArrayList<String>(allFeatures);
450     String[] oldRender = renderOrder;
451     renderOrder = new String[allfeatures.size()];
452     boolean initOrders = (featureOrder == null);
453     int opos = 0;
454     if (oldRender != null && oldRender.length > 0)
455     {
456       for (int j = 0; j < oldRender.length; j++)
457       {
458         if (oldRender[j] != null)
459         {
460           if (initOrders)
461           {
462             setOrder(oldRender[j], (1 - (1 + (float) j) / oldRender.length));
463           }
464           if (allfeatures.contains(oldRender[j]))
465           {
466             renderOrder[opos++] = oldRender[j]; // existing features always
467             // appear below new features
468             allfeatures.remove(oldRender[j]);
469             if (minmax != null)
470             {
471               float[][] mmrange = minmax.get(oldRender[j]);
472               if (mmrange != null)
473               {
474                 FeatureColourI fc = featureColours.get(oldRender[j]);
475                 if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
476                 {
477                   fc.updateBounds(mmrange[0][0], mmrange[0][1]);
478                 }
479               }
480             }
481           }
482         }
483       }
484     }
485     if (allfeatures.size() == 0)
486     {
487       // no new features - leave order unchanged.
488       return;
489     }
490     int i = allfeatures.size() - 1;
491     int iSize = i;
492     boolean sort = false;
493     String[] newf = new String[allfeatures.size()];
494     float[] sortOrder = new float[allfeatures.size()];
495     for (String newfeat : allfeatures)
496     {
497       newf[i] = newfeat;
498       if (minmax != null)
499       {
500         // update from new features minmax if necessary
501         float[][] mmrange = minmax.get(newf[i]);
502         if (mmrange != null)
503         {
504           FeatureColourI fc = featureColours.get(newf[i]);
505           if (fc != null && !fc.isSimpleColour() && fc.isAutoScaled())
506           {
507             fc.updateBounds(mmrange[0][0], mmrange[0][1]);
508           }
509         }
510       }
511       if (initOrders || !featureOrder.containsKey(newf[i]))
512       {
513         int denom = initOrders ? allfeatures.size() : featureOrder.size();
514         // new unordered feature - compute persistent ordering at head of
515         // existing features.
516         setOrder(newf[i], i / (float) denom);
517       }
518       // set order from newly found feature from persisted ordering.
519       sortOrder[i] = 2 - featureOrder.get(newf[i]).floatValue();
520       if (i < iSize)
521       {
522         // only sort if we need to
523         sort = sort || sortOrder[i] > sortOrder[i + 1];
524       }
525       i--;
526     }
527     if (iSize > 1 && sort)
528     {
529       jalview.util.QuickSort.sort(sortOrder, newf);
530     }
531     sortOrder = null;
532     System.arraycopy(newf, 0, renderOrder, opos, newf.length);
533   }
534
535   /**
536    * get a feature style object for the given type string. Creates a
537    * java.awt.Color for a featureType with no existing colourscheme.
538    * 
539    * @param featureType
540    * @return
541    */
542   @Override
543   public FeatureColourI getFeatureStyle(String featureType)
544   {
545     FeatureColourI fc = featureColours.get(featureType);
546     if (fc == null)
547     {
548       Color col = UserColourScheme.createColourFromName(featureType);
549       fc = new FeatureColour(new Colour(col));
550       featureColours.put(featureType, fc);
551     }
552     return fc;
553   }
554
555   /**
556    * calculate the render colour for a specific feature using current feature
557    * settings.
558    * 
559    * @param feature
560    * @return render colour for the given feature
561    */
562   public Color getColour(SequenceFeature feature)
563   {
564     FeatureColourI fc = getFeatureStyle(feature.getType());
565     return ColorUtils.getColor(fc.getColor(feature));
566   }
567
568   protected boolean showFeature(SequenceFeature sequenceFeature)
569   {
570     FeatureColourI fc = getFeatureStyle(sequenceFeature.type);
571     return fc.isColored(sequenceFeature);
572   }
573
574   protected boolean showFeatureOfType(String type)
575   {
576     return av.getFeaturesDisplayed().isVisible(type);
577   }
578
579   @Override
580   public void setColour(String featureType, FeatureColourI col)
581   {
582      featureColours.put(featureType, col);
583   }
584
585   public void setTransparency(float value)
586   {
587     transparency = value;
588   }
589
590   public float getTransparency()
591   {
592     return transparency;
593   }
594
595   /**
596    * analogous to colour - store a normalized ordering for all feature types in
597    * this rendering context.
598    * 
599    * @param type
600    *          Feature type string
601    * @param position
602    *          normalized priority - 0 means always appears on top, 1 means
603    *          always last.
604    */
605   public float setOrder(String type, float position)
606   {
607     if (featureOrder == null)
608     {
609       featureOrder = new Hashtable<String, Float>();
610     }
611     featureOrder.put(type, new Float(position));
612     return position;
613   }
614
615   /**
616    * get the global priority (0 (top) to 1 (bottom))
617    * 
618    * @param type
619    * @return [0,1] or -1 for a type without a priority
620    */
621   public float getOrder(String type)
622   {
623     if (featureOrder != null)
624     {
625       if (featureOrder.containsKey(type))
626       {
627         return featureOrder.get(type).floatValue();
628       }
629     }
630     return -1;
631   }
632
633   @Override
634   public Map<String, FeatureColourI> getFeatureColours()
635   {
636     return featureColours;
637   }
638
639   /**
640    * Replace current ordering with new ordering
641    * 
642    * @param data
643    *          { String(Type), Colour(Type), Boolean(Displayed) }
644    * @return true if any visible features have been reordered, else false
645    */
646   public boolean setFeaturePriority(Object[][] data)
647   {
648     return setFeaturePriority(data, true);
649   }
650
651   /**
652    * Sets the priority order for features
653    * 
654    * @param data
655    *          { String(Type), Colour(Type), Boolean(Displayed) }
656    * @param visibleNew
657    *          when true current featureDisplay list will be cleared
658    * @return true if any visible features have been reordered or recoloured,
659    *         else false (i.e. no need to repaint)
660    */
661   public boolean setFeaturePriority(Object[][] data, boolean visibleNew)
662   {
663     /*
664      * note visible feature ordering and colours before update
665      */
666     List<String> visibleFeatures = getDisplayedFeatureTypes();
667     Map<String, Object> visibleColours = new HashMap<String, Object>(
668             getFeatureColours());
669
670     FeaturesDisplayedI av_featuresdisplayed = null;
671     if (visibleNew)
672     {
673       if ((av_featuresdisplayed = av.getFeaturesDisplayed()) != null)
674       {
675         av.getFeaturesDisplayed().clear();
676       }
677       else
678       {
679         av.setFeaturesDisplayed(av_featuresdisplayed = new FeaturesDisplayed());
680       }
681     }
682     else
683     {
684       av_featuresdisplayed = av.getFeaturesDisplayed();
685     }
686     if (data == null)
687     {
688       return false;
689     }
690     // The feature table will display high priority
691     // features at the top, but these are the ones
692     // we need to render last, so invert the data
693     renderOrder = new String[data.length];
694
695     if (data.length > 0)
696     {
697       for (int i = 0; i < data.length; i++)
698       {
699         String type = data[i][0].toString();
700         setColour(type, (FeatureColourI) data[i][1]);
701         if (((Boolean) data[i][2]).booleanValue())
702         {
703           av_featuresdisplayed.setVisible(type);
704         }
705
706         renderOrder[data.length - i - 1] = type;
707       }
708     }
709
710     /*
711      * get the new visible ordering and return true if it has changed
712      * order or any colour has changed
713      */
714     List<String> reorderedVisibleFeatures = getDisplayedFeatureTypes();
715     if (!visibleFeatures.equals(reorderedVisibleFeatures))
716     {
717       /*
718        * the list of ordered visible features has changed
719        */
720       return true;
721     }
722
723     /*
724      * return true if any feature colour has changed
725      */
726     for (String feature : visibleFeatures)
727     {
728       if (visibleColours.get(feature) != getFeatureStyle(feature))
729       {
730         return true;
731       }
732     }
733     return false;
734   }
735
736   /**
737    * @param listener
738    * @see java.beans.PropertyChangeSupport#addPropertyChangeListener(java.beans.PropertyChangeListener)
739    */
740   public void addPropertyChangeListener(PropertyChangeListener listener)
741   {
742     changeSupport.addPropertyChangeListener(listener);
743   }
744
745   /**
746    * @param listener
747    * @see java.beans.PropertyChangeSupport#removePropertyChangeListener(java.beans.PropertyChangeListener)
748    */
749   public void removePropertyChangeListener(PropertyChangeListener listener)
750   {
751     changeSupport.removePropertyChangeListener(listener);
752   }
753
754   public Set<String> getAllFeatureColours()
755   {
756     return featureColours.keySet();
757   }
758
759   public void clearRenderOrder()
760   {
761     renderOrder = null;
762   }
763
764   public boolean hasRenderOrder()
765   {
766     return renderOrder != null;
767   }
768
769   public List<String> getRenderOrder()
770   {
771     if (renderOrder == null)
772     {
773       return Arrays.asList(new String[] {});
774     }
775     return Arrays.asList(renderOrder);
776   }
777
778   public int getFeatureGroupsSize()
779   {
780     return featureGroups != null ? 0 : featureGroups.size();
781   }
782
783   @Override
784   public List<String> getFeatureGroups()
785   {
786     // conflict between applet and desktop - featureGroups returns the map in
787     // the desktop featureRenderer
788     return (featureGroups == null) ? Arrays.asList(new String[0]) : Arrays
789             .asList(featureGroups.keySet().toArray(new String[0]));
790   }
791
792   public boolean checkGroupVisibility(String group, boolean newGroupsVisible)
793   {
794     if (featureGroups == null)
795     {
796       // then an exception happens next..
797     }
798     if (featureGroups.containsKey(group))
799     {
800       return featureGroups.get(group).booleanValue();
801     }
802     if (newGroupsVisible)
803     {
804       featureGroups.put(group, new Boolean(true));
805       return true;
806     }
807     return false;
808   }
809
810   /**
811    * get visible or invisible groups
812    * 
813    * @param visible
814    *          true to return visible groups, false to return hidden ones.
815    * @return list of groups
816    */
817   @Override
818   public List<String> getGroups(boolean visible)
819   {
820     if (featureGroups != null)
821     {
822       List<String> gp = new ArrayList<String>();
823
824       for (String grp : featureGroups.keySet())
825       {
826         Boolean state = featureGroups.get(grp);
827         if (state.booleanValue() == visible)
828         {
829           gp.add(grp);
830         }
831       }
832       return gp;
833     }
834     return null;
835   }
836
837   @Override
838   public void setGroupVisibility(String group, boolean visible)
839   {
840     featureGroups.put(group, new Boolean(visible));
841   }
842
843   @Override
844   public void setGroupVisibility(List<String> toset, boolean visible)
845   {
846     if (toset != null && toset.size() > 0 && featureGroups != null)
847     {
848       boolean rdrw = false;
849       for (String gst : toset)
850       {
851         Boolean st = featureGroups.get(gst);
852         featureGroups.put(gst, new Boolean(visible));
853         if (st != null)
854         {
855           rdrw = rdrw || (visible != st.booleanValue());
856         }
857       }
858       if (rdrw)
859       {
860         // set local flag indicating redraw needed ?
861       }
862     }
863   }
864
865   @Override
866   public Map<String, FeatureColourI> getDisplayedFeatureCols()
867   {
868     Map<String, FeatureColourI> fcols = new Hashtable<String, FeatureColourI>();
869     if (getViewport().getFeaturesDisplayed() == null)
870     {
871       return fcols;
872     }
873     Iterator<String> features = getViewport().getFeaturesDisplayed()
874             .getVisibleFeatures();
875     while (features.hasNext())
876     {
877       String feature = features.next();
878       fcols.put(feature, getFeatureStyle(feature));
879     }
880     return fcols;
881   }
882
883   @Override
884   public FeaturesDisplayedI getFeaturesDisplayed()
885   {
886     return av.getFeaturesDisplayed();
887   }
888
889   @Override
890   public List<String> getDisplayedFeatureTypes()
891   {
892     List<String> typ = getRenderOrder();
893     List<String> displayed = new ArrayList<String>();
894     FeaturesDisplayedI feature_disp = av.getFeaturesDisplayed();
895     if (feature_disp != null)
896     {
897       synchronized (feature_disp)
898       {
899         for (String type : typ)
900         {
901           if (feature_disp.isVisible(type))
902           {
903             displayed.add(type);
904           }
905         }
906       }
907     }
908     return displayed;
909   }
910
911   @Override
912   public List<String> getDisplayedFeatureGroups()
913   {
914     List<String> _gps = new ArrayList<String>();
915     boolean valid = false;
916     for (String gp : getFeatureGroups())
917     {
918       if (checkGroupVisibility(gp, false))
919       {
920         valid = true;
921         _gps.add(gp);
922       }
923       if (!valid)
924       {
925         return null;
926       }
927       else
928       {
929         // gps = new String[_gps.size()];
930         // _gps.toArray(gps);
931       }
932     }
933     return _gps;
934   }
935
936 }