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