JAL-2668 fix broken factory method for colour scheme
[jalview.git] / src / jalview / gui / AnnotationChooser.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.gui;
22
23 import jalview.datamodel.AlignmentAnnotation;
24 import jalview.datamodel.AlignmentI;
25 import jalview.datamodel.SequenceGroup;
26 import jalview.util.MessageManager;
27
28 import java.awt.BorderLayout;
29 import java.awt.Checkbox;
30 import java.awt.CheckboxGroup;
31 import java.awt.FlowLayout;
32 import java.awt.Font;
33 import java.awt.GridLayout;
34 import java.awt.event.ActionEvent;
35 import java.awt.event.ActionListener;
36 import java.awt.event.ItemEvent;
37 import java.awt.event.ItemListener;
38 import java.util.ArrayList;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.Map;
42
43 import javax.swing.JButton;
44 import javax.swing.JInternalFrame;
45 import javax.swing.JLayeredPane;
46 import javax.swing.JPanel;
47
48 /**
49  * A panel that allows the user to select which sequence-associated annotation
50  * rows to show or hide.
51  * 
52  * @author gmcarstairs
53  *
54  */
55 @SuppressWarnings("serial")
56 public class AnnotationChooser extends JPanel
57 {
58
59   private static final Font CHECKBOX_FONT = new Font("Serif", Font.BOLD,
60           12);
61
62   private static final int MY_FRAME_WIDTH = 600;
63
64   private static final int MY_FRAME_HEIGHT = 250;
65
66   private JInternalFrame frame;
67
68   private AlignmentPanel ap;
69
70   private SequenceGroup sg;
71
72   // all annotation rows' original visible state
73   private boolean[] resetState = null;
74
75   // is 'Show' selected?
76   private boolean showSelected;
77
78   // apply settings to selected (or all) sequences?
79   private boolean applyToSelectedSequences;
80
81   // apply settings to unselected (or all) sequences?
82   private boolean applyToUnselectedSequences;
83
84   // currently selected 'annotation type' checkboxes
85   private Map<String, String> selectedTypes = new HashMap<>();
86
87   /**
88    * Constructor.
89    * 
90    * @param alignPane
91    */
92   public AnnotationChooser(AlignmentPanel alignPane)
93   {
94     super();
95     this.ap = alignPane;
96     this.sg = alignPane.av.getSelectionGroup();
97     saveResetState(alignPane.getAlignment());
98
99     try
100     {
101       jbInit();
102     } catch (Exception ex)
103     {
104       ex.printStackTrace();
105     }
106     showFrame();
107   }
108
109   /**
110    * Save the initial show/hide state of all annotations to allow a Cancel
111    * operation.
112    * 
113    * @param alignment
114    */
115   protected void saveResetState(AlignmentI alignment)
116   {
117     AlignmentAnnotation[] annotations = alignment.getAlignmentAnnotation();
118     final int count = annotations.length;
119     this.resetState = new boolean[count];
120     for (int i = 0; i < count; i++)
121     {
122       this.resetState[i] = annotations[i].visible;
123     }
124   }
125
126   /**
127    * Populate this frame with:
128    * <p>
129    * checkboxes for the types of annotation to show or hide (i.e. any annotation
130    * type shown for any sequence in the whole alignment)
131    * <p>
132    * option to show or hide selected types
133    * <p>
134    * option to show/hide for the currently selected group, or its inverse
135    * <p>
136    * OK and Cancel (reset) buttons
137    */
138   protected void jbInit()
139   {
140     setLayout(new GridLayout(3, 1));
141     add(buildAnnotationTypesPanel());
142     add(buildShowHideOptionsPanel());
143     add(buildActionButtonsPanel());
144     validate();
145   }
146
147   /**
148    * Construct the panel with checkboxes for annotation types.
149    * 
150    * @return
151    */
152   protected JPanel buildAnnotationTypesPanel()
153   {
154     JPanel jp = new JPanel(new FlowLayout(FlowLayout.LEFT));
155
156     List<String> annotationTypes = getAnnotationTypes(
157             this.ap.getAlignment(), true);
158
159     for (final String type : annotationTypes)
160     {
161       final Checkbox check = new Checkbox(type);
162       check.setFont(CHECKBOX_FONT);
163       check.addItemListener(new ItemListener()
164       {
165         @Override
166         public void itemStateChanged(ItemEvent evt)
167         {
168           if (evt.getStateChange() == ItemEvent.SELECTED)
169           {
170             AnnotationChooser.this.selectedTypes.put(type, type);
171           }
172           else
173           {
174             AnnotationChooser.this.selectedTypes.remove(type);
175           }
176           changeTypeSelected_actionPerformed(type);
177         }
178       });
179       jp.add(check);
180     }
181     return jp;
182   }
183
184   /**
185    * Update display when scope (All/Selected sequences/Unselected) is changed.
186    * <p>
187    * Set annotations (with one of the selected types) to the selected Show/Hide
188    * visibility, if they are in the new application scope. Set to the opposite
189    * if outside the scope.
190    * <p>
191    * Note this only affects sequence-specific annotations, others are left
192    * unchanged.
193    */
194   protected void changeApplyTo_actionPerformed()
195   {
196     setAnnotationVisibility(true);
197
198     // copied from AnnotationLabel.actionPerformed (after show/hide row)...
199     // TODO should drive this functionality into AlignmentPanel
200     ap.updateAnnotation();
201     // this.ap.annotationPanel.adjustPanelHeight();
202     // this.ap.alabels.setSize(this.ap.alabels.getSize().width,
203     // this.ap.annotationPanel.getSize().height);
204     // this.ap.validate();
205     this.ap.paintAlignment(true, false);
206   }
207
208   /**
209    * Update display when an annotation type is selected or deselected.
210    * <p>
211    * If the type is selected, set visibility of annotations of that type which
212    * are in the application scope (all, selected or unselected sequences).
213    * <p>
214    * If the type is unselected, set visibility to the opposite value. That is,
215    * treat select/deselect as a 'toggle' operation.
216    * 
217    * @param type
218    */
219   protected void changeTypeSelected_actionPerformed(String type)
220   {
221     boolean typeSelected = this.selectedTypes.containsKey(type);
222     for (AlignmentAnnotation aa : this.ap.getAlignment()
223             .getAlignmentAnnotation())
224     {
225       if (aa.sequenceRef != null && type.equals(aa.label)
226               && isInActionScope(aa))
227       {
228         aa.visible = typeSelected ? this.showSelected : !this.showSelected;
229       }
230     }
231     ap.updateAnnotation();
232     // // this.ap.annotationPanel.adjustPanelHeight();
233     // this.ap.alabels.setSize(this.ap.alabels.getSize().width,
234     // this.ap.annotationPanel.getSize().height);
235     // this.ap.validate();
236     this.ap.paintAlignment(true, false);
237   }
238
239   /**
240    * Update display on change of choice of Show or Hide
241    * <p>
242    * For annotations of any selected type, set visibility of annotations of that
243    * type which are in the application scope (all, selected or unselected
244    * sequences).
245    * 
246    * @param dataSourceType
247    */
248   protected void changeShowHide_actionPerformed()
249   {
250     setAnnotationVisibility(false);
251
252     this.ap.updateAnnotation();
253     // this.ap.annotationPanel.adjustPanelHeight();
254     this.ap.paintAlignment(true, false);
255   }
256
257   /**
258    * Update visibility flags on annotation rows as per the current user choices.
259    * 
260    * @param updateAllRows
261    */
262   protected void setAnnotationVisibility(boolean updateAllRows)
263   {
264     for (AlignmentAnnotation aa : this.ap.getAlignment()
265             .getAlignmentAnnotation())
266     {
267       if (aa.sequenceRef != null)
268       {
269         setAnnotationVisibility(aa, updateAllRows);
270       }
271     }
272   }
273
274   /**
275    * Determine and set the visibility of the given annotation from the currently
276    * selected options.
277    * <p>
278    * Only update annotations whose type is one of the selected types.
279    * <p>
280    * If its sequence is in the selected application scope
281    * (all/selected/unselected sequences), then we set its visibility according
282    * to the current choice of Show or Hide.
283    * <p>
284    * If force update of all rows is wanted, then set rows not in the sequence
285    * selection scope to the opposite visibility to those in scope.
286    * 
287    * @param aa
288    * @param updateAllRows
289    */
290   protected void setAnnotationVisibility(AlignmentAnnotation aa,
291           boolean updateAllRows)
292   {
293     if (this.selectedTypes.containsKey(aa.label))
294     {
295       if (isInActionScope(aa))
296       {
297         aa.visible = this.showSelected;
298       }
299       else if (updateAllRows)
300       {
301         aa.visible = !this.showSelected;
302       }
303     }
304     // TODO force not visible if associated sequence is hidden?
305     // currently hiding a sequence does not hide its annotation rows
306   }
307
308   /**
309    * Answers true if the annotation falls in the current selection criteria for
310    * show/hide.
311    * <p>
312    * It must be in the sequence selection group (for 'Apply to selection'), or
313    * not in it (for 'Apply except to selection'). No check needed for 'Apply to
314    * all'.
315    * 
316    * @param aa
317    * @return
318    */
319   protected boolean isInActionScope(AlignmentAnnotation aa)
320   {
321     boolean result = false;
322     if (this.applyToSelectedSequences && this.applyToUnselectedSequences)
323     {
324       // we don't care if the annotation's sequence is selected or not
325       result = true;
326     }
327     else if (this.sg == null)
328     {
329       // shouldn't happen - defensive programming
330       result = true;
331     }
332     else if (this.sg.getSequences().contains(aa.sequenceRef))
333     {
334       // annotation is for a member of the selection group
335       result = this.applyToSelectedSequences ? true : false;
336     }
337     else
338     {
339       // annotation is not associated with the selection group
340       result = this.applyToUnselectedSequences ? true : false;
341     }
342     return result;
343   }
344
345   /**
346    * Get annotation 'types' for an alignment, optionally restricted to
347    * sequence-specific annotations only. The label is currently used for 'type'.
348    * 
349    * TODO refactor to helper class. See
350    * AnnotationColourChooser.getAnnotationItems() for another client
351    * 
352    * @param alignment
353    * @param sequenceSpecific
354    * @return
355    */
356   public static List<String> getAnnotationTypes(AlignmentI alignment,
357           boolean sequenceSpecificOnly)
358   {
359     List<String> result = new ArrayList<>();
360     for (AlignmentAnnotation aa : alignment.getAlignmentAnnotation())
361     {
362       if (!sequenceSpecificOnly || aa.sequenceRef != null)
363       {
364         String label = aa.label;
365         if (!result.contains(label))
366         {
367           result.add(label);
368         }
369       }
370     }
371     return result;
372   }
373
374   /**
375    * Construct the panel with options to:
376    * <p>
377    * show or hide the selected annotation types
378    * <p>
379    * do this for the current selection group or its inverse
380    * 
381    * @return
382    */
383   protected JPanel buildShowHideOptionsPanel()
384   {
385     JPanel jp = new JPanel();
386     jp.setLayout(new BorderLayout());
387
388     JPanel showHideOptions = buildShowHidePanel();
389     jp.add(showHideOptions, BorderLayout.CENTER);
390
391     JPanel applyToOptions = buildApplyToOptionsPanel();
392     jp.add(applyToOptions, BorderLayout.SOUTH);
393
394     return jp;
395   }
396
397   /**
398    * Build a panel with radio buttons options for sequences to apply show/hide
399    * to. Options are all, current selection, all except current selection.
400    * Initial state has 'current selection' selected.
401    * <p>
402    * If the sequence group is null, then we are acting on the whole alignment,
403    * and only 'all sequences' is enabled (and selected).
404    * 
405    * @return
406    */
407   protected JPanel buildApplyToOptionsPanel()
408   {
409     final boolean wholeAlignment = this.sg == null;
410     JPanel applyToOptions = new JPanel(new FlowLayout(FlowLayout.LEFT));
411     CheckboxGroup actingOn = new CheckboxGroup();
412
413     String forAll = MessageManager.getString("label.all_sequences");
414     final Checkbox allSequences = new Checkbox(forAll, actingOn,
415             wholeAlignment);
416     allSequences.addItemListener(new ItemListener()
417     {
418       @Override
419       public void itemStateChanged(ItemEvent evt)
420       {
421         if (evt.getStateChange() == ItemEvent.SELECTED)
422         {
423           AnnotationChooser.this.setApplyToSelectedSequences(true);
424           AnnotationChooser.this.setApplyToUnselectedSequences(true);
425           AnnotationChooser.this.changeApplyTo_actionPerformed();
426         }
427       }
428     });
429     applyToOptions.add(allSequences);
430
431     String forSelected = MessageManager
432             .getString("label.selected_sequences");
433     final Checkbox selectedSequences = new Checkbox(forSelected, actingOn,
434             !wholeAlignment);
435     selectedSequences.setEnabled(!wholeAlignment);
436     selectedSequences.addItemListener(new ItemListener()
437     {
438       @Override
439       public void itemStateChanged(ItemEvent evt)
440       {
441         if (evt.getStateChange() == ItemEvent.SELECTED)
442         {
443           AnnotationChooser.this.setApplyToSelectedSequences(true);
444           AnnotationChooser.this.setApplyToUnselectedSequences(false);
445           AnnotationChooser.this.changeApplyTo_actionPerformed();
446         }
447       }
448     });
449     applyToOptions.add(selectedSequences);
450
451     String exceptSelected = MessageManager
452             .getString("label.except_selected_sequences");
453     final Checkbox unselectedSequences = new Checkbox(exceptSelected,
454             actingOn, false);
455     unselectedSequences.setEnabled(!wholeAlignment);
456     unselectedSequences.addItemListener(new ItemListener()
457     {
458       @Override
459       public void itemStateChanged(ItemEvent evt)
460       {
461         if (evt.getStateChange() == ItemEvent.SELECTED)
462         {
463           AnnotationChooser.this.setApplyToSelectedSequences(false);
464           AnnotationChooser.this.setApplyToUnselectedSequences(true);
465           AnnotationChooser.this.changeApplyTo_actionPerformed();
466         }
467       }
468     });
469     applyToOptions.add(unselectedSequences);
470
471     // set member variables to match the initial selection state
472     this.applyToSelectedSequences = selectedSequences.getState()
473             || allSequences.getState();
474     this.applyToUnselectedSequences = unselectedSequences.getState()
475             || allSequences.getState();
476
477     return applyToOptions;
478   }
479
480   /**
481    * Build a panel with radio button options to show or hide selected
482    * annotations.
483    * 
484    * @return
485    */
486   protected JPanel buildShowHidePanel()
487   {
488     JPanel showHideOptions = new JPanel(new FlowLayout(FlowLayout.LEFT));
489     CheckboxGroup showOrHide = new CheckboxGroup();
490
491     /*
492      * Radio button 'Show selected annotations' - initially unselected
493      */
494     String showLabel = MessageManager
495             .getString("label.show_selected_annotations");
496     final Checkbox showOption = new Checkbox(showLabel, showOrHide, false);
497     showOption.addItemListener(new ItemListener()
498     {
499       @Override
500       public void itemStateChanged(ItemEvent evt)
501       {
502         if (evt.getStateChange() == ItemEvent.SELECTED)
503         {
504           AnnotationChooser.this.setShowSelected(true);
505           AnnotationChooser.this.changeShowHide_actionPerformed();
506         }
507       }
508     });
509     showHideOptions.add(showOption);
510
511     /*
512      * Radio button 'hide selected annotations'- initially selected
513      */
514     String hideLabel = MessageManager
515             .getString("label.hide_selected_annotations");
516     final Checkbox hideOption = new Checkbox(hideLabel, showOrHide, true);
517     hideOption.addItemListener(new ItemListener()
518     {
519       @Override
520       public void itemStateChanged(ItemEvent evt)
521       {
522         if (evt.getStateChange() == ItemEvent.SELECTED)
523         {
524           AnnotationChooser.this.setShowSelected(false);
525           AnnotationChooser.this.changeShowHide_actionPerformed();
526         }
527       }
528     });
529     showHideOptions.add(hideOption);
530
531     /*
532      * Set member variable to match initial selection state
533      */
534     this.showSelected = showOption.getState();
535
536     return showHideOptions;
537   }
538
539   /**
540    * Construct the panel with OK and Cancel buttons.
541    * 
542    * @return
543    */
544   protected JPanel buildActionButtonsPanel()
545   {
546     JPanel jp = new JPanel();
547     final Font labelFont = JvSwingUtils.getLabelFont();
548
549     JButton ok = new JButton(MessageManager.getString("action.ok"));
550     ok.setFont(labelFont);
551     ok.addActionListener(new ActionListener()
552     {
553       @Override
554       public void actionPerformed(ActionEvent e)
555       {
556         close_actionPerformed();
557       }
558     });
559     jp.add(ok);
560
561     JButton cancel = new JButton(MessageManager.getString("action.cancel"));
562     cancel.setFont(labelFont);
563     cancel.addActionListener(new ActionListener()
564     {
565       @Override
566       public void actionPerformed(ActionEvent e)
567       {
568         cancel_actionPerformed();
569       }
570     });
571     jp.add(cancel);
572
573     return jp;
574   }
575
576   /**
577    * On 'Cancel' button, undo any changes.
578    */
579   protected void cancel_actionPerformed()
580   {
581     resetOriginalState();
582     this.ap.repaint();
583     close_actionPerformed();
584   }
585
586   /**
587    * Restore annotation visibility to their state on entry here, and repaint
588    * alignment.
589    */
590   protected void resetOriginalState()
591   {
592     int i = 0;
593     for (AlignmentAnnotation aa : this.ap.getAlignment()
594             .getAlignmentAnnotation())
595     {
596       aa.visible = this.resetState[i++];
597     }
598   }
599
600   /**
601    * On 'Close' button, close the dialog.
602    */
603   protected void close_actionPerformed()
604   {
605     try
606     {
607       this.frame.setClosed(true);
608     } catch (Exception exe)
609     {
610     }
611   }
612
613   /**
614    * Render a frame containing this panel.
615    */
616   private void showFrame()
617   {
618     frame = new JInternalFrame();
619     frame.setContentPane(this);
620     frame.setLayer(JLayeredPane.PALETTE_LAYER);
621     Desktop.addInternalFrame(frame,
622             MessageManager.getString("label.choose_annotations"),
623             MY_FRAME_WIDTH, MY_FRAME_HEIGHT, true);
624   }
625
626   protected void setShowSelected(boolean showSelected)
627   {
628     this.showSelected = showSelected;
629   }
630
631   protected void setApplyToSelectedSequences(
632           boolean applyToSelectedSequences)
633   {
634     this.applyToSelectedSequences = applyToSelectedSequences;
635   }
636
637   protected void setApplyToUnselectedSequences(
638           boolean applyToUnselectedSequences)
639   {
640     this.applyToUnselectedSequences = applyToUnselectedSequences;
641   }
642
643   protected boolean isShowSelected()
644   {
645     return showSelected;
646   }
647
648   protected boolean isApplyToSelectedSequences()
649   {
650     return applyToSelectedSequences;
651   }
652
653   protected boolean isApplyToUnselectedSequences()
654   {
655     return applyToUnselectedSequences;
656   }
657
658 }