src/jalview/gui/ViewSelectionMenu.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.util.MessageManager;
  24
  25 import java.awt.Component;
  26 import java.awt.event.ActionEvent;
  27 import java.awt.event.ActionListener;
  28 import java.awt.event.ItemEvent;
  29 import java.awt.event.ItemListener;
  30 import java.awt.event.MouseAdapter;
  31 import java.awt.event.MouseEvent;
  32 import java.util.List;
  33
  34 import javax.swing.JCheckBoxMenuItem;
  35 import javax.swing.JMenu;
  36 import javax.swing.JMenuItem;
  37 import javax.swing.event.MenuEvent;
  38 import javax.swing.event.MenuListener;
  39
  40 /**
  41  * this is an implementation of an abstract Jalview GUI class that provides a
  42  * dialog/menu which allows the user to select/deselect specific views from a
  43  * list of associated views.
  44  *
  45  * Includes patches related to JAL-641
  46  *
  47  * @author JimP
  48  *
  49  */
  50 public class ViewSelectionMenu extends JMenu
  51 {
  52   public interface ViewSetProvider
  53   {
  54     public AlignmentPanel[] getAllAlignmentPanels();
  55   }
  56
  57   private ViewSetProvider _allviews;
  58
  59   private List<AlignmentPanel> _selectedviews;
  60
  61   private ItemListener _handler;
  62
  63   @Override
  64   protected void finalize() throws Throwable
  65   {
  66     _selectedviews = null;
  67     _handler = null;
  68     _allviews = null;
  69     super.finalize();
  70   }
  71
  72   /**
  73    * create a new view selection menu. This menu has some standard entries
  74    * (select all, invert selection), and a checkbox for every view. Mousing over
  75    * a view entry will cause it to be raised/selected in the Desktop, allowing
  76    * the user to easily identify which view is being referred to.
  77    *
  78    * @param title
  79    *          Name of menu
  80    * @param allviews
  81    *          all the views that might be selected
  82    * @param selectedviews
  83    *          the list of selected views which will be updated when
  84    *          selection/deselections occur
  85    * @param handler
  86    *          a handler called for each selection/deselection - use this to
  87    *          update any gui elements which need to reflect current
  88    *          selection/deselection state
  89    */
  90   public ViewSelectionMenu(String title, final ViewSetProvider allviews,
  91           final List<AlignmentPanel> selectedviews,
  92           final ItemListener handler)
  93   {
  94     super(title);
  95     this._allviews = allviews;
  96     this._selectedviews = selectedviews;
  97     this._handler = handler;
  98     addMenuListener(new MenuListener()
  99     {
 100
 101       @Override
 102       public void menuSelected(MenuEvent e)
 103       {
 104         rebuild();
 105
 106       }
 107
 108       @Override
 109       public void menuDeselected(MenuEvent e)
 110       {
 111         // TODO Auto-generated method stub
 112
 113       }
 114
 115       @Override
 116       public void menuCanceled(MenuEvent e)
 117       {
 118         // TODO Auto-generated method stub
 119
 120       }
 121     });
 122   }
 123
 124   /**
 125    * view selection modifier flag - indicates if an action key is pressed when
 126    * menu selection event occurred.
 127    */
 128   private boolean append = false;
 129
 130   /**
 131    * flag indicating if the itemStateChanged listener for view associated menu
 132    * items is currently enabled
 133    */
 134   private boolean enabled = true;
 135
 136   private JMenuItem selectAll, invertSel;
 137
 138   private JCheckBoxMenuItem toggleview = null;
 139
 140   private void rebuild()
 141   {
 142     removeAll();
 143     AlignmentPanel[] allviews = _allviews.getAllAlignmentPanels();
 144     if (allviews == null)
 145     {
 146       setVisible(false);
 147       return;
 148     }
 149     if (allviews.length >= 2)
 150     {
 151       // ensure we update menu state to reflect external selection list state
 152       append = append || _selectedviews.size() > 1;
 153       toggleview = new JCheckBoxMenuItem(
 154               MessageManager.getString("label.select_many_views"), append);
 155       toggleview.setToolTipText(MessageManager
 156               .getString("label.toggle_enabled_views"));
 157       toggleview.addItemListener(new ItemListener()
 158       {
 159
 160         @Override
 161         public void itemStateChanged(ItemEvent arg0)
 162         {
 163           if (enabled)
 164           {
 165             append = !append;
 166             selectAll.setEnabled(append);
 167             invertSel.setEnabled(append);
 168           }
 169
 170         }
 171
 172       });
 173       add(toggleview);
 174       add(selectAll = new JMenuItem(
 175               MessageManager.getString("label.select_all_views")));
 176       selectAll.addActionListener(new ActionListener()
 177       {
 178
 179         @Override
 180         public void actionPerformed(ActionEvent e)
 181         {
 182           for (Component c : getMenuComponents())
 183           {
 184             boolean t = append;
 185             append = true;
 186             if (c instanceof JCheckBoxMenuItem)
 187             {
 188               if (toggleview != c && !((JCheckBoxMenuItem) c).isSelected())
 189               {
 190                 ((JCheckBoxMenuItem) c).doClick();
 191               }
 192             }
 193             append = t;
 194           }
 195         }
 196       });
 197       add(invertSel = new JMenuItem(
 198               MessageManager.getString("label.invert_selection")));
 199       invertSel.addActionListener(new ActionListener()
 200       {
 201
 202         @Override
 203         public void actionPerformed(ActionEvent e)
 204         {
 205           boolean t = append;
 206           append = true;
 207           for (Component c : getMenuComponents())
 208           {
 209             if (toggleview != c && c instanceof JCheckBoxMenuItem)
 210             {
 211               ((JCheckBoxMenuItem) c).doClick();
 212             }
 213           }
 214           append = t;
 215         }
 216       });
 217       invertSel.setEnabled(append);
 218       selectAll.setEnabled(append);
 219     }
 220     for (final AlignmentPanel ap : allviews)
 221     {
 222       String nm = ((ap.getViewName() == null || ap.getViewName().length() == 0) ? ""
 223               : ap.getViewName() + " for ")
 224               + ap.alignFrame.getTitle();
 225       final JCheckBoxMenuItem checkBox = new JCheckBoxMenuItem(nm,
 226               _selectedviews.contains(ap));
 227       checkBox.addItemListener(new ItemListener()
 228       {
 229         @Override
 230         public void itemStateChanged(ItemEvent e)
 231         {
 232           if (enabled)
 233           {
 234             if (append)
 235             {
 236               enabled = false;
 237               // toggle the inclusion state
 238               if (_selectedviews.indexOf(ap) == -1)
 239               {
 240                 _selectedviews.add(ap);
 241                 checkBox.setSelected(true);
 242               }
 243               else
 244               {
 245                 _selectedviews.remove(ap);
 246                 checkBox.setSelected(false);
 247               }
 248               enabled = true;
 249               _handler.itemStateChanged(e);
 250             }
 251             else
 252             {
 253               // Deselect everything and select this item only
 254               _selectedviews.clear();
 255               _selectedviews.add(ap);
 256               enabled = false;
 257               for (Component c : getMenuComponents())
 258               {
 259                 if (c instanceof JCheckBoxMenuItem)
 260                 {
 261                   ((JCheckBoxMenuItem) c).setSelected(checkBox == c);
 262                 }
 263               }
 264               enabled = true;
 265               // only fire event if we weren't selected before
 266               _handler.itemStateChanged(e);
 267             }
 268           }
 269         }
 270       });
 271       checkBox.addMouseListener(new MouseAdapter()
 272       {
 273         @Override
 274         public void mouseExited(MouseEvent e)
 275         {
 276           try
 277           {
 278             ap.setSelected(false);
 279           } catch (Exception ex)
 280           {
 281           }
 282         }
 283
 284         @Override
 285         public void mouseEntered(MouseEvent e)
 286         {
 287           try
 288           {
 289             ap.setSelected(true);
 290           } catch (Exception ex)
 291           {
 292           }
 293         }
 294       });
 295       add(checkBox);
 296     }
 297   }
 298
 299 }