tidy imports
[jalview.git] / src / jalview / appletgui / FeatureSettings.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
3  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
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 of the License, or (at your option) any later version.
10  * 
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 package jalview.appletgui;
19
20 import java.util.*;
21
22 import java.awt.*;
23 import java.awt.event.*;
24
25 import jalview.analysis.AlignmentSorter;
26 import jalview.commands.OrderCommand;
27 import jalview.datamodel.*;
28 import jalview.schemes.AnnotationColourGradient;
29 import jalview.schemes.GraduatedColor;
30
31 public class FeatureSettings extends Panel implements ItemListener,
32         MouseListener, MouseMotionListener, ActionListener,
33         AdjustmentListener
34 {
35   FeatureRenderer fr;
36
37   AlignmentPanel ap;
38
39   AlignViewport av;
40
41   Frame frame;
42
43   Panel groupPanel;
44
45   Panel featurePanel = new Panel();
46
47   ScrollPane scrollPane;
48
49   boolean alignmentHasFeatures = false;
50
51   Image linkImage;
52
53   Scrollbar transparency;
54
55   public FeatureSettings(final AlignmentPanel ap)
56   {
57     this.ap = ap;
58     this.av = ap.av;
59     ap.av.featureSettings = this;
60     fr = ap.seqPanel.seqCanvas.getFeatureRenderer();
61
62     transparency = new Scrollbar(Scrollbar.HORIZONTAL,
63             100 - (int) (fr.transparency * 100), 1, 1, 100);
64
65     if (fr.transparencySetter != null)
66     {
67       transparency.addAdjustmentListener(this);
68     }
69     else
70     {
71       transparency.setEnabled(false);
72     }
73
74     java.net.URL url = getClass().getResource("/images/link.gif");
75     if (url != null)
76     {
77       linkImage = java.awt.Toolkit.getDefaultToolkit().getImage(url);
78     }
79
80     if (av.featuresDisplayed == null)
81     {
82       fr.findAllFeatures();
83     }
84
85     setTableData();
86
87     this.setLayout(new BorderLayout());
88     scrollPane = new ScrollPane();
89     scrollPane.add(featurePanel);
90     if (alignmentHasFeatures)
91     {
92       add(scrollPane, BorderLayout.CENTER);
93     }
94
95     Button invert = new Button("Invert Selection");
96     invert.addActionListener(this);
97
98     Panel lowerPanel = new Panel(new GridLayout(2, 1, 5, 10));
99     lowerPanel.add(invert);
100
101     Panel tPanel = new Panel(new BorderLayout());
102
103     if (fr.transparencySetter != null)
104     {
105       tPanel.add(transparency, BorderLayout.CENTER);
106       tPanel.add(new Label("Transparency"), BorderLayout.EAST);
107     }
108     else
109     {
110       tPanel.add(
111               new Label("Transparency not available in this web browser"),
112               BorderLayout.CENTER);
113     }
114
115     lowerPanel.add(tPanel, BorderLayout.SOUTH);
116
117     add(lowerPanel, BorderLayout.SOUTH);
118
119     if (groupPanel != null)
120     {
121       groupPanel
122               .setLayout(new GridLayout(
123                       (fr.featureGroups.size() - fr.hiddenGroups.size()) / 4 + 1,
124                       4));
125       groupPanel.validate();
126
127       add(groupPanel, BorderLayout.NORTH);
128     }
129     frame = new Frame();
130     frame.add(this);
131     final FeatureSettings me = this;
132     frame.addWindowListener(new WindowAdapter()
133     {
134       public void windowClosing(WindowEvent e)
135       {
136         if (me.av.featureSettings == me)
137         {
138           me.av.featureSettings = null;
139           me.ap = null;
140           me.av = null;
141         }
142       }
143     });
144     int height = featurePanel.getComponentCount() * 50 + 60;
145
146     height = Math.max(200, height);
147     height = Math.min(400, height);
148     int width = 300;
149     jalview.bin.JalviewLite.addFrame(frame, "Feature Settings", width,
150             height);
151   }
152
153   public void paint(Graphics g)
154   {
155     g.setColor(Color.black);
156     g.drawString("No Features added to this alignment!!", 10, 20);
157     g.drawString("(Features can be added from searches or", 10, 40);
158     g.drawString("from Jalview / GFF features files)", 10, 60);
159   }
160
161   protected void popupSort(final MyCheckbox check, final Hashtable minmax,
162           int x, int y)
163   {
164     final String type = check.type;
165     final Object typeCol = fr.getFeatureStyle(type);
166     java.awt.PopupMenu men = new PopupMenu("Settings for " + type);
167     java.awt.MenuItem scr = new MenuItem("Sort by Score");
168     men.add(scr);
169     final FeatureSettings me = this;
170     scr.addActionListener(new ActionListener()
171     {
172
173       public void actionPerformed(ActionEvent e)
174       {
175         me.sortByScore(new String[]
176         { type });
177       }
178
179     });
180     MenuItem dens = new MenuItem("Sort by Density");
181     dens.addActionListener(new ActionListener()
182     {
183
184       public void actionPerformed(ActionEvent e)
185       {
186         me.sortByDens(new String[]
187         { type });
188       }
189
190     });
191     men.add(dens);
192     if (minmax != null)
193     {
194       final Object typeMinMax = minmax.get(type);
195       /*
196        * final java.awt.CheckboxMenuItem chb = new
197        * java.awt.CheckboxMenuItem("Vary Height"); // this is broken at the
198        * moment chb.setState(minmax.get(type) != null);
199        * chb.addActionListener(new ActionListener() {
200        * 
201        * public void actionPerformed(ActionEvent e) {
202        * chb.setState(chb.getState()); if (chb.getState()) { minmax.put(type,
203        * null); } else { minmax.put(type, typeMinMax); } }
204        * 
205        * }); men.add(chb);
206        */
207       if (typeMinMax != null && ((float[][]) typeMinMax)[0] != null)
208       {
209         // graduated colourschemes for those where minmax exists for the
210         // positional features
211         MenuItem mxcol = new MenuItem(
212                 (typeCol instanceof Color) ? "Graduated Colour"
213                         : "Single Colour");
214         men.add(mxcol);
215         mxcol.addActionListener(new ActionListener()
216         {
217
218           public void actionPerformed(ActionEvent e)
219           {
220             if (typeCol instanceof Color)
221             {
222               new FeatureColourChooser(me, type);
223               // write back the current colour object to update the table
224               check.updateColor(fr.getFeatureStyle(type));
225             }
226             else
227             {
228               new UserDefinedColours(me, check.type,
229                       ((GraduatedColor) typeCol));
230             }
231           }
232
233         });
234       }
235     }
236     this.featurePanel.add(men);
237     men.show(this.featurePanel, x, y);
238   }
239
240   public void setTableData()
241   {
242     alignmentHasFeatures = fr.buildGroupHash();
243     if (alignmentHasFeatures)
244     {
245       rebuildGroups();
246
247     }
248     resetTable(false);
249   }
250
251   /**
252    * rebuilds the group panel
253    */
254   public void rebuildGroups()
255   {
256     boolean rdrw = false;
257     if (groupPanel == null)
258     {
259       groupPanel = new Panel();
260     }
261     else
262     {
263       rdrw = true;
264       groupPanel.removeAll();
265     }
266     // TODO: JAL-964 - smoothly incorporate new group entries if panel already displayed and new groups present
267     Enumeration gps = fr.featureGroups.keys();
268     while (gps.hasMoreElements())
269     {
270       String group = (String) gps.nextElement();
271       Boolean vis = (Boolean) fr.featureGroups.get(group);
272       Checkbox check = new MyCheckbox(group, vis.booleanValue(),
273               (fr.featureLinks != null && fr.featureLinks
274                       .containsKey(group)));
275       check.addMouseListener(this);
276       check.setFont(new Font("Serif", Font.BOLD, 12));
277       check.addItemListener(this);
278       check.setVisible(fr.hiddenGroups.contains(group));
279       groupPanel.add(check);
280     }
281     if (rdrw)
282     {
283       groupPanel.validate();
284     }
285   }
286
287   // This routine adds and removes checkboxes depending on
288   // Group selection states
289   void resetTable(boolean groupsChanged)
290   {
291     SequenceFeature[] tmpfeatures;
292     String group = null, type;
293     Vector visibleChecks = new Vector();
294     AlignmentI alignment=av.getAlignment();
295     for (int i = 0; i < alignment.getHeight(); i++)
296     {
297       if (alignment.getSequenceAt(i).getSequenceFeatures() == null)
298       {
299         continue;
300       }
301
302       tmpfeatures = alignment.getSequenceAt(i).getSequenceFeatures();
303       int index = 0;
304       while (index < tmpfeatures.length)
305       {
306         group = tmpfeatures[index].featureGroup;
307
308         if (group == null || fr.featureGroups.get(group) == null
309                 || ((Boolean) fr.featureGroups.get(group)).booleanValue())
310         {
311           type = tmpfeatures[index].getType();
312           if (!visibleChecks.contains(type))
313           {
314             visibleChecks.addElement(type);
315           }
316         }
317         index++;
318       }
319     }
320
321     Component[] comps;
322     int cSize = featurePanel.getComponentCount();
323     MyCheckbox check;
324     // This will remove any checkboxes which shouldn't be
325     // visible
326     for (int i = 0; i < cSize; i++)
327     {
328       comps = featurePanel.getComponents();
329       check = (MyCheckbox) comps[i];
330       if (!visibleChecks.contains(check.type))
331       {
332         featurePanel.remove(i);
333         cSize--;
334         i--;
335       }
336     }
337
338     if (fr.renderOrder != null)
339     {
340       // First add the checks in the previous render order,
341       // in case the window has been closed and reopened
342       for (int ro = fr.renderOrder.length - 1; ro > -1; ro--)
343       {
344         String item = fr.renderOrder[ro];
345
346         if (!visibleChecks.contains(item))
347         {
348           continue;
349         }
350
351         visibleChecks.removeElement(item);
352
353         addCheck(false, item);
354       }
355     }
356
357     // now add checkboxes which should be visible,
358     // if they have not already been added
359     Enumeration en = visibleChecks.elements();
360
361     while (en.hasMoreElements())
362     {
363       addCheck(groupsChanged, en.nextElement().toString());
364     }
365
366     featurePanel.setLayout(new GridLayout(featurePanel.getComponentCount(),
367             1, 10, 5));
368     featurePanel.validate();
369
370     if (scrollPane != null)
371     {
372       scrollPane.validate();
373     }
374
375     itemStateChanged(null);
376   }
377
378   /**
379    * update the checklist of feature types with the given type
380    * 
381    * @param groupsChanged
382    *          true means if the type is not in the display list then it will be
383    *          added and displayed
384    * @param type
385    *          feature type to be checked for in the list.
386    */
387   void addCheck(boolean groupsChanged, String type)
388   {
389     boolean addCheck;
390     Component[] comps = featurePanel.getComponents();
391     MyCheckbox check;
392     addCheck = true;
393     for (int i = 0; i < featurePanel.getComponentCount(); i++)
394     {
395       check = (MyCheckbox) comps[i];
396       if (check.type.equals(type))
397       {
398         addCheck = false;
399         break;
400       }
401     }
402
403     if (addCheck)
404     {
405       boolean selected = false;
406       if (groupsChanged || av.featuresDisplayed.containsKey(type))
407       {
408         selected = true;
409       }
410
411       check = new MyCheckbox(
412               type,
413               selected,
414               (fr.featureLinks != null && fr.featureLinks.containsKey(type)),
415               fr.getFeatureStyle(type));
416
417       check.addMouseListener(this);
418       check.addMouseMotionListener(this);
419       check.addItemListener(this);
420       if (groupsChanged)
421       {
422         // add at beginning of stack.
423         featurePanel.add(check, 0);
424       }
425       else
426       {
427         // add at end of stack.
428         featurePanel.add(check);
429       }
430     }
431   }
432
433   public void actionPerformed(ActionEvent evt)
434   {
435     for (int i = 0; i < featurePanel.getComponentCount(); i++)
436     {
437       Checkbox check = (Checkbox) featurePanel.getComponent(i);
438       check.setState(!check.getState());
439     }
440     selectionChanged();
441   }
442
443   public void itemStateChanged(ItemEvent evt)
444   {
445     if (evt != null)
446     {
447       // Is the source a top level featureGroup?
448       Checkbox source = (Checkbox) evt.getSource();
449       if (fr.featureGroups.containsKey(source.getLabel()))
450       {
451         fr.featureGroups.put(source.getLabel(),
452                 new Boolean(source.getState()));
453         ap.seqPanel.seqCanvas.repaint();
454         if (ap.overviewPanel != null)
455         {
456           ap.overviewPanel.updateOverviewImage();
457         }
458
459         resetTable(true);
460         return;
461       }
462     }
463     selectionChanged();
464   }
465
466   void selectionChanged()
467   {
468     Component[] comps = featurePanel.getComponents();
469     int cSize = comps.length;
470
471     Object[][] tmp = new Object[cSize][3];
472     int tmpSize = 0;
473     for (int i = 0; i < cSize; i++)
474     {
475       MyCheckbox check = (MyCheckbox) comps[i];
476       tmp[tmpSize][0] = check.type;
477       tmp[tmpSize][1] = fr.getFeatureStyle(check.type);
478       tmp[tmpSize][2] = new Boolean(check.getState());
479       tmpSize++;
480     }
481
482     Object[][] data = new Object[tmpSize][3];
483     System.arraycopy(tmp, 0, data, 0, tmpSize);
484
485     fr.setFeaturePriority(data);
486
487     ap.paintAlignment(true);
488   }
489
490   MyCheckbox selectedCheck;
491
492   boolean dragging = false;
493
494   public void mousePressed(MouseEvent evt)
495   {
496
497     selectedCheck = (MyCheckbox) evt.getSource();
498
499     if (fr.featureLinks != null
500             && fr.featureLinks.containsKey(selectedCheck.type))
501     {
502       if (evt.getX() > selectedCheck.stringWidth + 20)
503       {
504         evt.consume();
505       }
506     }
507
508   }
509
510   public void mouseDragged(MouseEvent evt)
511   {
512     if (((Component) evt.getSource()).getParent() != featurePanel)
513     {
514       return;
515     }
516     dragging = true;
517   }
518
519   public void mouseReleased(MouseEvent evt)
520   {
521     if (((Component) evt.getSource()).getParent() != featurePanel)
522     {
523       return;
524     }
525
526     Component comp = null;
527     Checkbox target = null;
528
529     int height = evt.getY() + evt.getComponent().getLocation().y;
530
531     if (height > featurePanel.getSize().height)
532     {
533
534       comp = featurePanel
535               .getComponent(featurePanel.getComponentCount() - 1);
536     }
537     else if (height < 0)
538     {
539       comp = featurePanel.getComponent(0);
540     }
541     else
542     {
543       comp = featurePanel.getComponentAt(evt.getX(), evt.getY()
544               + evt.getComponent().getLocation().y);
545     }
546
547     if (comp != null && comp instanceof Checkbox)
548     {
549       target = (Checkbox) comp;
550     }
551
552     if (selectedCheck != null && target != null && selectedCheck != target)
553     {
554       int targetIndex = -1;
555       for (int i = 0; i < featurePanel.getComponentCount(); i++)
556       {
557         if (target == featurePanel.getComponent(i))
558         {
559           targetIndex = i;
560           break;
561         }
562       }
563
564       featurePanel.remove(selectedCheck);
565       featurePanel.add(selectedCheck, targetIndex);
566       featurePanel.validate();
567       itemStateChanged(null);
568     }
569   }
570
571   public void setUserColour(String feature, Object originalColour)
572   {
573     if (originalColour instanceof Color
574             || originalColour instanceof GraduatedColor)
575     {
576       fr.setColour(feature, originalColour);
577     }
578     else
579     {
580       throw new Error(
581               "Implementation error: Unsupported feature colour object.");
582     }
583     refreshTable();
584   }
585
586   public void refreshTable()
587   {
588     featurePanel.removeAll();
589     resetTable(false);
590     ap.paintAlignment(true);
591   }
592
593   public void mouseEntered(MouseEvent evt)
594   {
595   }
596
597   public void mouseExited(MouseEvent evt)
598   {
599   }
600
601   public void mouseClicked(MouseEvent evt)
602   {
603     MyCheckbox check = (MyCheckbox) evt.getSource();
604     if ((evt.getModifiers() & InputEvent.BUTTON3_MASK) != 0)
605     {
606       this.popupSort(check, fr.minmax, evt.getX(), evt.getY());
607     }
608     if (fr.featureLinks != null && fr.featureLinks.containsKey(check.type))
609     {
610       if (evt.getX() > check.stringWidth + 20)
611       {
612         evt.consume();
613         String link = fr.featureLinks.get(check.type).toString();
614         ap.alignFrame.showURL(link.substring(link.indexOf("|") + 1),
615                 link.substring(0, link.indexOf("|")));
616       }
617     }
618
619     if (check.getParent() != featurePanel)
620     {
621       return;
622     }
623
624     if (evt.getClickCount() > 1)
625     {
626       Object fcol = fr.getFeatureStyle(check.type);
627       if (fcol instanceof Color)
628       {
629         new UserDefinedColours(this, check.type, (Color) fcol);
630       }
631       else
632       {
633         new FeatureColourChooser(this, check.type);
634         // write back the current colour object to update the table
635         check.updateColor(fr.getFeatureStyle(check.type));
636       }
637     }
638   }
639
640   public void mouseMoved(MouseEvent evt)
641   {
642   }
643
644   public void adjustmentValueChanged(AdjustmentEvent evt)
645   {
646     fr.transparency = ((float) (100 - transparency.getValue()) / 100f);
647     ap.seqPanel.seqCanvas.repaint();
648
649   }
650
651   class MyCheckbox extends Checkbox
652   {
653     public String type;
654
655     public int stringWidth;
656
657     boolean hasLink;
658
659     GraduatedColor gcol;
660
661     Color col;
662
663     public void updateColor(Object newcol)
664     {
665       if (newcol instanceof Color)
666       {
667         col = (Color) newcol;
668         gcol = null;
669       }
670       else if (newcol instanceof GraduatedColor)
671       {
672         gcol = (GraduatedColor) newcol;
673         col = null;
674       }
675       else
676       {
677         throw new Error("Invalid color for MyCheckBox");
678       }
679       if (col != null)
680       {
681         setBackground(col);
682       }
683       else
684       {
685         String vlabel = type;
686         if (gcol.getThreshType() != AnnotationColourGradient.NO_THRESHOLD)
687         {
688           vlabel += " "
689                   + ((gcol.getThreshType() == AnnotationColourGradient.ABOVE_THRESHOLD) ? "(>)"
690                           : "(<)");
691         }
692         if (gcol.isColourByLabel())
693         {
694           setBackground(Color.white);
695           vlabel += " (by Label)";
696         }
697         else
698         {
699           setBackground(gcol.getMinColor());
700         }
701         this.setLabel(vlabel);
702       }
703       repaint();
704     }
705
706     public MyCheckbox(String label, boolean checked, boolean haslink)
707     {
708       super(label, checked);
709       type = label;
710       FontMetrics fm = av.nullFrame.getFontMetrics(av.nullFrame.getFont());
711       stringWidth = fm.stringWidth(label);
712       this.hasLink = haslink;
713     }
714
715     public MyCheckbox(String type, boolean selected, boolean b,
716             Object featureStyle)
717     {
718       this(type, selected, b);
719       updateColor(featureStyle);
720     }
721
722     public void paint(Graphics g)
723     {
724       Dimension d = getSize();
725       if (gcol != null)
726       {
727         if (gcol.isColourByLabel())
728         {
729           g.setColor(Color.white);
730           g.fillRect(d.width / 2, 0, d.width / 2, d.height);
731           /*
732            * g.setColor(Color.black); Font f=g.getFont().deriveFont(9);
733            * g.setFont(f);
734            * 
735            * // g.setFont(g.getFont().deriveFont( //
736            * AffineTransform.getScaleInstance( //
737            * width/g.getFontMetrics().stringWidth("Label"), //
738            * height/g.getFontMetrics().getHeight()))); g.drawString("Label",
739            * width/2, 0);
740            */
741
742         }
743         else
744         {
745           Color maxCol = gcol.getMaxColor();
746           g.setColor(maxCol);
747           g.fillRect(d.width / 2, 0, d.width / 2, d.height);
748
749         }
750       }
751
752       if (hasLink)
753       {
754         g.drawImage(linkImage, stringWidth + 25,
755                 (getSize().height - linkImage.getHeight(this)) / 2, this);
756       }
757     }
758   }
759
760   protected void sortByDens(String[] typ)
761   {
762     sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
763   }
764
765   private String[] getDisplayedFeatureTypes()
766   {
767     String[] typ = null;
768     if (fr != null)
769     {
770       synchronized (fr.renderOrder)
771       {
772         typ = new String[fr.renderOrder.length];
773         System.arraycopy(fr.renderOrder, 0, typ, 0, typ.length);
774         for (int i = 0; i < typ.length; i++)
775         {
776           if (av.featuresDisplayed.get(typ[i]) == null)
777           {
778             typ[i] = null;
779           }
780         }
781       }
782     }
783     return typ;
784   }
785
786   protected void sortBy(String[] typ, String methodText, final String method)
787   {
788     if (typ == null)
789     {
790       typ = getDisplayedFeatureTypes();
791     }
792     String gps[] = null;
793     gps = fr.getGroups(true);
794     if (typ != null)
795     {
796       for (int i = 0; i < typ.length; i++)
797       {
798         System.err.println("Sorting on Types:" + typ[i]);
799       }
800     }
801     if (gps != null)
802     {
803
804       for (int i = 0; i < gps.length; i++)
805       {
806         System.err.println("Sorting on groups:" + gps[i]);
807       }
808     }
809     AlignmentPanel alignPanel = ap;
810     AlignmentI al = alignPanel.av.getAlignment();
811
812     int start, stop;
813     SequenceGroup sg = alignPanel.av.getSelectionGroup();
814     if (sg != null)
815     {
816       start = sg.getStartRes();
817       stop = sg.getEndRes();
818     }
819     else
820     {
821       start = 0;
822       stop = al.getWidth();
823     }
824     SequenceI[] oldOrder = al.getSequencesArray();
825     AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method);
826     this.ap.alignFrame.addHistoryItem(new OrderCommand(methodText,
827             oldOrder, alignPanel.av.getAlignment()));
828     alignPanel.paintAlignment(true);
829
830   }
831
832   protected void sortByScore(String[] typ)
833   {
834     sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
835   }
836
837 }