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 java.awt.BorderLayout;
  24 import java.awt.Checkbox;
  25 import java.awt.CheckboxGroup;
  26 import java.awt.FlowLayout;
  27 import java.awt.Font;
  28 import java.awt.GridLayout;
  29 import java.awt.event.ActionEvent;
  30 import java.awt.event.ActionListener;
  31 import java.awt.event.ItemEvent;
  32 import java.awt.event.ItemListener;
  33 import java.util.ArrayList;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37
  38 import javax.swing.JButton;
  39 import javax.swing.JInternalFrame;
  40 import javax.swing.JLayeredPane;
  41 import javax.swing.JPanel;
  42
  43 import jalview.datamodel.AlignmentAnnotation;
  44 import jalview.datamodel.AlignmentI;
  45 import jalview.datamodel.SequenceGroup;
  46 import jalview.util.MessageManager;
  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     ap.updateAnnotation();
 199   }
 200
 201   /**
 202    * Update display when an annotation type is selected or deselected.
 203    * <p>
 204    * If the type is selected, set visibility of annotations of that type which
 205    * are in the application scope (all, selected or unselected sequences).
 206    * <p>
 207    * If the type is unselected, set visibility to the opposite value. That is,
 208    * treat select/deselect as a 'toggle' operation.
 209    *
 210    * @param type
 211    */
 212   protected void changeTypeSelected_actionPerformed(String type)
 213   {
 214     boolean typeSelected = this.selectedTypes.containsKey(type);
 215     for (AlignmentAnnotation aa : this.ap.getAlignment()
 216             .getAlignmentAnnotation())
 217     {
 218       if (aa.sequenceRef != null && type.equals(aa.label)
 219               && isInActionScope(aa))
 220       {
 221         aa.visible = typeSelected ? this.showSelected : !this.showSelected;
 222       }
 223     }
 224     ap.updateAnnotation();
 225   }
 226
 227   /**
 228    * Update display on change of choice of Show or Hide
 229    * <p>
 230    * For annotations of any selected type, set visibility of annotations of that
 231    * type which are in the application scope (all, selected or unselected
 232    * sequences).
 233    *
 234    * @param dataSourceType
 235    */
 236   protected void changeShowHide_actionPerformed()
 237   {
 238     setAnnotationVisibility(false);
 239
 240     ap.updateAnnotation();
 241   }
 242
 243   /**
 244    * Update visibility flags on annotation rows as per the current user choices.
 245    *
 246    * @param updateAllRows
 247    */
 248   protected void setAnnotationVisibility(boolean updateAllRows)
 249   {
 250     for (AlignmentAnnotation aa : this.ap.getAlignment()
 251             .getAlignmentAnnotation())
 252     {
 253       if (aa.sequenceRef != null)
 254       {
 255         setAnnotationVisibility(aa, updateAllRows);
 256       }
 257     }
 258   }
 259
 260   /**
 261    * Determine and set the visibility of the given annotation from the currently
 262    * selected options.
 263    * <p>
 264    * Only update annotations whose type is one of the selected types.
 265    * <p>
 266    * If its sequence is in the selected application scope
 267    * (all/selected/unselected sequences), then we set its visibility according
 268    * to the current choice of Show or Hide.
 269    * <p>
 270    * If force update of all rows is wanted, then set rows not in the sequence
 271    * selection scope to the opposite visibility to those in scope.
 272    *
 273    * @param aa
 274    * @param updateAllRows
 275    */
 276   protected void setAnnotationVisibility(AlignmentAnnotation aa,
 277           boolean updateAllRows)
 278   {
 279     if (this.selectedTypes.containsKey(aa.label))
 280     {
 281       if (isInActionScope(aa))
 282       {
 283         aa.visible = this.showSelected;
 284       }
 285       else if (updateAllRows)
 286       {
 287         aa.visible = !this.showSelected;
 288       }
 289     }
 290     // TODO force not visible if associated sequence is hidden?
 291     // currently hiding a sequence does not hide its annotation rows
 292   }
 293
 294   /**
 295    * Answers true if the annotation falls in the current selection criteria for
 296    * show/hide.
 297    * <p>
 298    * It must be in the sequence selection group (for 'Apply to selection'), or
 299    * not in it (for 'Apply except to selection'). No check needed for 'Apply to
 300    * all'.
 301    *
 302    * @param aa
 303    * @return
 304    */
 305   protected boolean isInActionScope(AlignmentAnnotation aa)
 306   {
 307     boolean result = false;
 308     if (this.applyToSelectedSequences && this.applyToUnselectedSequences)
 309     {
 310       // we don't care if the annotation's sequence is selected or not
 311       result = true;
 312     }
 313     else if (this.sg == null)
 314     {
 315       // shouldn't happen - defensive programming
 316       result = true;
 317     }
 318     else if (this.sg.getSequences().contains(aa.sequenceRef))
 319     {
 320       // annotation is for a member of the selection group
 321       result = this.applyToSelectedSequences ? true : false;
 322     }
 323     else
 324     {
 325       // annotation is not associated with the selection group
 326       result = this.applyToUnselectedSequences ? true : false;
 327     }
 328     return result;
 329   }
 330
 331   /**
 332    * Get annotation 'types' for an alignment, optionally restricted to
 333    * sequence-specific annotations only. The label is currently used for 'type'.
 334    *
 335    * TODO refactor to helper class. See
 336    * AnnotationColourChooser.getAnnotationItems() for another client
 337    *
 338    * @param alignment
 339    * @param sequenceSpecific
 340    * @return
 341    */
 342   public static List<String> getAnnotationTypes(AlignmentI alignment,
 343           boolean sequenceSpecificOnly)
 344   {
 345     List<String> result = new ArrayList<>();
 346     for (AlignmentAnnotation aa : alignment.getAlignmentAnnotation())
 347     {
 348       if (!sequenceSpecificOnly || aa.sequenceRef != null)
 349       {
 350         String label = aa.label;
 351         if (!result.contains(label))
 352         {
 353           result.add(label);
 354         }
 355       }
 356     }
 357     return result;
 358   }
 359
 360   /**
 361    * Construct the panel with options to:
 362    * <p>
 363    * show or hide the selected annotation types
 364    * <p>
 365    * do this for the current selection group or its inverse
 366    *
 367    * @return
 368    */
 369   protected JPanel buildShowHideOptionsPanel()
 370   {
 371     JPanel jp = new JPanel();
 372     jp.setLayout(new BorderLayout());
 373
 374     JPanel showHideOptions = buildShowHidePanel();
 375     jp.add(showHideOptions, BorderLayout.CENTER);
 376
 377     JPanel applyToOptions = buildApplyToOptionsPanel();
 378     jp.add(applyToOptions, BorderLayout.SOUTH);
 379
 380     return jp;
 381   }
 382
 383   /**
 384    * Build a panel with radio buttons options for sequences to apply show/hide
 385    * to. Options are all, current selection, all except current selection.
 386    * Initial state has 'current selection' selected.
 387    * <p>
 388    * If the sequence group is null, then we are acting on the whole alignment,
 389    * and only 'all sequences' is enabled (and selected).
 390    *
 391    * @return
 392    */
 393   protected JPanel buildApplyToOptionsPanel()
 394   {
 395     final boolean wholeAlignment = this.sg == null;
 396     JPanel applyToOptions = new JPanel(new FlowLayout(FlowLayout.LEFT));
 397     CheckboxGroup actingOn = new CheckboxGroup();
 398
 399     String forAll = MessageManager.getString("label.all_sequences");
 400     final Checkbox allSequences = new Checkbox(forAll, actingOn,
 401             wholeAlignment);
 402     allSequences.addItemListener(new ItemListener()
 403     {
 404       @Override
 405       public void itemStateChanged(ItemEvent evt)
 406       {
 407         if (evt.getStateChange() == ItemEvent.SELECTED)
 408         {
 409           AnnotationChooser.this.setApplyToSelectedSequences(true);
 410           AnnotationChooser.this.setApplyToUnselectedSequences(true);
 411           AnnotationChooser.this.changeApplyTo_actionPerformed();
 412         }
 413       }
 414     });
 415     applyToOptions.add(allSequences);
 416
 417     String forSelected = MessageManager
 418             .getString("label.selected_sequences");
 419     final Checkbox selectedSequences = new Checkbox(forSelected, actingOn,
 420             !wholeAlignment);
 421     selectedSequences.setEnabled(!wholeAlignment);
 422     selectedSequences.addItemListener(new ItemListener()
 423     {
 424       @Override
 425       public void itemStateChanged(ItemEvent evt)
 426       {
 427         if (evt.getStateChange() == ItemEvent.SELECTED)
 428         {
 429           AnnotationChooser.this.setApplyToSelectedSequences(true);
 430           AnnotationChooser.this.setApplyToUnselectedSequences(false);
 431           AnnotationChooser.this.changeApplyTo_actionPerformed();
 432         }
 433       }
 434     });
 435     applyToOptions.add(selectedSequences);
 436
 437     String exceptSelected = MessageManager
 438             .getString("label.except_selected_sequences");
 439     final Checkbox unselectedSequences = new Checkbox(exceptSelected,
 440             actingOn, false);
 441     unselectedSequences.setEnabled(!wholeAlignment);
 442     unselectedSequences.addItemListener(new ItemListener()
 443     {
 444       @Override
 445       public void itemStateChanged(ItemEvent evt)
 446       {
 447         if (evt.getStateChange() == ItemEvent.SELECTED)
 448         {
 449           AnnotationChooser.this.setApplyToSelectedSequences(false);
 450           AnnotationChooser.this.setApplyToUnselectedSequences(true);
 451           AnnotationChooser.this.changeApplyTo_actionPerformed();
 452         }
 453       }
 454     });
 455     applyToOptions.add(unselectedSequences);
 456
 457     // set member variables to match the initial selection state
 458     this.applyToSelectedSequences = selectedSequences.getState()
 459             || allSequences.getState();
 460     this.applyToUnselectedSequences = unselectedSequences.getState()
 461             || allSequences.getState();
 462
 463     return applyToOptions;
 464   }
 465
 466   /**
 467    * Build a panel with radio button options to show or hide selected
 468    * annotations.
 469    *
 470    * @return
 471    */
 472   protected JPanel buildShowHidePanel()
 473   {
 474     JPanel showHideOptions = new JPanel(new FlowLayout(FlowLayout.LEFT));
 475     CheckboxGroup showOrHide = new CheckboxGroup();
 476
 477     /*
 478      * Radio button 'Show selected annotations' - initially unselected
 479      */
 480     String showLabel = MessageManager
 481             .getString("label.show_selected_annotations");
 482     final Checkbox showOption = new Checkbox(showLabel, showOrHide, false);
 483     showOption.addItemListener(new ItemListener()
 484     {
 485       @Override
 486       public void itemStateChanged(ItemEvent evt)
 487       {
 488         if (evt.getStateChange() == ItemEvent.SELECTED)
 489         {
 490           AnnotationChooser.this.setShowSelected(true);
 491           AnnotationChooser.this.changeShowHide_actionPerformed();
 492         }
 493       }
 494     });
 495     showHideOptions.add(showOption);
 496
 497     /*
 498      * Radio button 'hide selected annotations'- initially selected
 499      */
 500     String hideLabel = MessageManager
 501             .getString("label.hide_selected_annotations");
 502     final Checkbox hideOption = new Checkbox(hideLabel, showOrHide, true);
 503     hideOption.addItemListener(new ItemListener()
 504     {
 505       @Override
 506       public void itemStateChanged(ItemEvent evt)
 507       {
 508         if (evt.getStateChange() == ItemEvent.SELECTED)
 509         {
 510           AnnotationChooser.this.setShowSelected(false);
 511           AnnotationChooser.this.changeShowHide_actionPerformed();
 512         }
 513       }
 514     });
 515     showHideOptions.add(hideOption);
 516
 517     /*
 518      * Set member variable to match initial selection state
 519      */
 520     this.showSelected = showOption.getState();
 521
 522     return showHideOptions;
 523   }
 524
 525   /**
 526    * Construct the panel with OK and Cancel buttons.
 527    *
 528    * @return
 529    */
 530   protected JPanel buildActionButtonsPanel()
 531   {
 532     JPanel jp = new JPanel();
 533     final Font labelFont = JvSwingUtils.getLabelFont();
 534
 535     JButton ok = new JButton(MessageManager.getString("action.ok"));
 536     ok.setFont(labelFont);
 537     ok.addActionListener(new ActionListener()
 538     {
 539       @Override
 540       public void actionPerformed(ActionEvent e)
 541       {
 542         close_actionPerformed();
 543       }
 544     });
 545     jp.add(ok);
 546
 547     JButton cancel = new JButton(MessageManager.getString("action.cancel"));
 548     cancel.setFont(labelFont);
 549     cancel.addActionListener(new ActionListener()
 550     {
 551       @Override
 552       public void actionPerformed(ActionEvent e)
 553       {
 554         cancel_actionPerformed();
 555       }
 556     });
 557     jp.add(cancel);
 558
 559     return jp;
 560   }
 561
 562   /**
 563    * On 'Cancel' button, undo any changes.
 564    */
 565   protected void cancel_actionPerformed()
 566   {
 567     resetOriginalState();
 568     this.ap.repaint();
 569     close_actionPerformed();
 570   }
 571
 572   /**
 573    * Restore annotation visibility to their state on entry here, and repaint
 574    * alignment.
 575    */
 576   protected void resetOriginalState()
 577   {
 578     int i = 0;
 579     for (AlignmentAnnotation aa : this.ap.getAlignment()
 580             .getAlignmentAnnotation())
 581     {
 582       aa.visible = this.resetState[i++];
 583     }
 584   }
 585
 586   /**
 587    * On 'Close' button, close the dialog.
 588    */
 589   protected void close_actionPerformed()
 590   {
 591     try
 592     {
 593       this.frame.setClosed(true);
 594     } catch (Exception exe)
 595     {
 596     }
 597   }
 598
 599   /**
 600    * Render a frame containing this panel.
 601    */
 602   private void showFrame()
 603   {
 604     frame = new JInternalFrame();
 605     frame.setFrameIcon(null);
 606     frame.setContentPane(this);
 607     frame.setLayer(JLayeredPane.PALETTE_LAYER);
 608     Desktop.addInternalFrame(frame,
 609             MessageManager.getString("label.choose_annotations"),
 610             MY_FRAME_WIDTH, MY_FRAME_HEIGHT, true);
 611   }
 612
 613   protected void setShowSelected(boolean showSelected)
 614   {
 615     this.showSelected = showSelected;
 616   }
 617
 618   protected void setApplyToSelectedSequences(
 619           boolean applyToSelectedSequences)
 620   {
 621     this.applyToSelectedSequences = applyToSelectedSequences;
 622   }
 623
 624   protected void setApplyToUnselectedSequences(
 625           boolean applyToUnselectedSequences)
 626   {
 627     this.applyToUnselectedSequences = applyToUnselectedSequences;
 628   }
 629
 630   protected boolean isShowSelected()
 631   {
 632     return showSelected;
 633   }
 634
 635   protected boolean isApplyToSelectedSequences()
 636   {
 637     return applyToSelectedSequences;
 638   }
 639
 640   protected boolean isApplyToUnselectedSequences()
 641   {
 642     return applyToUnselectedSequences;
 643   }
 644
 645 }