src/jalview/gui/Finder.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.SearchResultMatchI;
  24 import jalview.datamodel.SearchResultsI;
  25 import jalview.datamodel.SequenceFeature;
  26 import jalview.datamodel.SequenceI;
  27 import jalview.io.cache.AppCache;
  28 import jalview.jbgui.GFinder;
  29 import jalview.util.MessageManager;
  30 import jalview.viewmodel.AlignmentViewport;
  31
  32 import java.awt.event.ActionEvent;
  33 import java.awt.event.KeyEvent;
  34 import java.util.Vector;
  35 import java.util.regex.Pattern;
  36 import java.util.regex.PatternSyntaxException;
  37
  38 import javax.swing.AbstractAction;
  39 import javax.swing.JComponent;
  40 import javax.swing.JInternalFrame;
  41 import javax.swing.JLayeredPane;
  42 import javax.swing.KeyStroke;
  43 import javax.swing.event.InternalFrameEvent;
  44
  45 /**
  46  * Performs the menu option for searching the alignment, for the next or all
  47  * matches. If matches are found, they are highlighted, and the user has the
  48  * option to create a new feature on the alignment for the matched positions.
  49  *
  50  * Searches can be for a simple base sequence, or may use a regular expression.
  51  * Any gaps are ignored.
  52  *
  53  * @author $author$
  54  * @version $Revision$
  55  */
  56 public class Finder extends GFinder
  57 {
  58   private static final int HEIGHT = 110;
  59
  60   private static final int WIDTH = 340;
  61
  62   AlignmentViewport av;
  63
  64   AlignmentPanel ap;
  65
  66   JInternalFrame frame;
  67
  68   int seqIndex = 0;
  69
  70   int resIndex = -1;
  71
  72   SearchResultsI searchResults;
  73
  74   /**
  75    * Creates a new Finder object with no associated viewport or panel.
  76    */
  77   public Finder()
  78   {
  79     this(null, null);
  80     focusfixed = false;
  81   }
  82
  83   /**
  84    * Constructor given an associated viewport and alignment panel. Constructs
  85    * and displays an internal frame where the user can enter a search string.
  86    *
  87    * @param viewport
  88    * @param alignPanel
  89    */
  90   public Finder(AlignmentViewport viewport, AlignmentPanel alignPanel)
  91   {
  92     av = viewport;
  93     ap = alignPanel;
  94     focusfixed = true;
  95     frame = new JInternalFrame();
  96     frame.setContentPane(this);
  97     frame.setLayer(JLayeredPane.PALETTE_LAYER);
  98     frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
  99     {
 100       @Override
 101       public void internalFrameClosing(InternalFrameEvent e)
 102       {
 103         closeAction();
 104       }
 105     });
 106     addEscapeHandler();
 107     Desktop.addInternalFrame(frame, MessageManager.getString("label.find"),
 108             WIDTH, HEIGHT);
 109
 110     searchBox.requestFocus();
 111   }
 112
 113   /**
 114    * Add a handler for the Escape key when the window has focus
 115    */
 116   private void addEscapeHandler()
 117   {
 118     getRootPane().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(
 119             KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "Cancel");
 120     getRootPane().getActionMap().put("Cancel", new AbstractAction()
 121     {
 122       @Override
 123       public void actionPerformed(ActionEvent e)
 124       {
 125         escapeActionPerformed();
 126       }
 127     });
 128   }
 129
 130   /**
 131    * Close the panel on Escape key press
 132    */
 133   protected void escapeActionPerformed()
 134   {
 135     setVisible(false);
 136     frame.dispose();
 137   }
 138
 139   /**
 140    * Performs the 'Find Next' action.
 141    *
 142    * @param e
 143    */
 144   @Override
 145   public void findNext_actionPerformed(ActionEvent e)
 146   {
 147     if (getFocusedViewport())
 148     {
 149       doSearch(false);
 150     }
 151   }
 152
 153   /**
 154    * Performs the 'Find All' action.
 155    *
 156    * @param e
 157    */
 158   @Override
 159   public void findAll_actionPerformed(ActionEvent e)
 160   {
 161     if (getFocusedViewport())
 162     {
 163       resIndex = -1;
 164       seqIndex = 0;
 165       doSearch(true);
 166     }
 167   }
 168
 169   /**
 170    * do we only search a given alignment view ?
 171    */
 172   private boolean focusfixed;
 173
 174   /**
 175    * if !focusfixed and not in a desktop environment, checks that av and ap are
 176    * valid. Otherwise, gets the topmost alignment window and sets av and ap
 177    * accordingly
 178    *
 179    * @return false if no alignment window was found
 180    */
 181   boolean getFocusedViewport()
 182   {
 183     if (focusfixed || Desktop.desktop == null)
 184     {
 185       if (ap != null && av != null)
 186       {
 187         return true;
 188       }
 189       // we aren't in a desktop environment, so give up now.
 190       return false;
 191     }
 192     // now checks further down the window stack to fix bug
 193     // https://mantis.lifesci.dundee.ac.uk/view.php?id=36008
 194     JInternalFrame[] frames = Desktop.desktop.getAllFrames();
 195     for (int f = 0; f < frames.length; f++)
 196     {
 197       JInternalFrame frame = frames[f];
 198       if (frame != null && frame instanceof AlignFrame)
 199       {
 200         av = ((AlignFrame) frame).viewport;
 201         ap = ((AlignFrame) frame).alignPanel;
 202         return true;
 203       }
 204     }
 205     return false;
 206   }
 207
 208   /**
 209    * DOCUMENT ME!
 210    *
 211    * @param e
 212    *          DOCUMENT ME!
 213    */
 214   @Override
 215   public void createNewGroup_actionPerformed(ActionEvent e)
 216   {
 217     SequenceI[] seqs = new SequenceI[searchResults.getSize()];
 218     SequenceFeature[] features = new SequenceFeature[searchResults
 219             .getSize()];
 220
 221     int i = 0;
 222     for (SearchResultMatchI match : searchResults.getResults())
 223     {
 224       seqs[i] = match.getSequence().getDatasetSequence();
 225
 226       features[i] = new SequenceFeature(searchBox.getEditor().getItem()
 227               .toString().trim(),
 228               "Search Results", null, match.getStart(), match.getEnd(),
 229               "Search Results");
 230       i++;
 231     }
 232
 233     if (ap.getSeqPanel().seqCanvas.getFeatureRenderer().amendFeatures(seqs,
 234             features, true, ap))
 235     {
 236       ap.alignFrame.showSeqFeatures.setSelected(true);
 237       av.setShowSequenceFeatures(true);
 238       ap.highlightSearchResults(null);
 239     }
 240   }
 241
 242   /**
 243    * Search the alignment for the next or all matches. If 'all matches', a
 244    * dialog is shown with the number of sequence ids and subsequences matched.
 245    *
 246    * @param findAll
 247    */
 248   void doSearch(boolean findAll)
 249   {
 250     createNewGroup.setEnabled(false);
 251
 252     String searchString = searchBox.getEditor().getItem().toString().trim();
 253
 254     if (isInvalidSearchString(searchString))
 255     {
 256       return;
 257     }
 258     // TODO: extend finder to match descriptions, features and annotation, and
 259     // other stuff
 260     // TODO: add switches to control what is searched - sequences, IDS,
 261     // descriptions, features
 262     jalview.analysis.Finder finder = new jalview.analysis.Finder(
 263             av.getAlignment(), av.getSelectionGroup(), seqIndex, resIndex);
 264     finder.setCaseSensitive(caseSensitive.isSelected());
 265     finder.setIncludeDescription(searchDescription.isSelected());
 266
 267     finder.setFindAll(findAll);
 268
 269     finder.find(searchString); // returns true if anything was actually found
 270
 271     seqIndex = finder.getSeqIndex();
 272     resIndex = finder.getResIndex();
 273
 274     searchResults = finder.getSearchResults(); // find(regex,
 275     // caseSensitive.isSelected(), )
 276     Vector<SequenceI> idMatch = finder.getIdMatch();
 277     boolean haveResults = false;
 278     // set or reset the GUI
 279     if ((idMatch.size() > 0))
 280     {
 281       haveResults = true;
 282       ap.getIdPanel().highlightSearchResults(idMatch);
 283     }
 284     else
 285     {
 286       ap.getIdPanel().highlightSearchResults(null);
 287     }
 288
 289     if (searchResults.getSize() > 0)
 290     {
 291       haveResults = true;
 292       createNewGroup.setEnabled(true);
 293     }
 294     else
 295     {
 296       searchResults = null;
 297     }
 298
 299     // if allResults is null, this effectively switches displaySearch flag in
 300     // seqCanvas
 301     ap.highlightSearchResults(searchResults);
 302     // TODO: add enablers for 'SelectSequences' or 'SelectColumns' or
 303     // 'SelectRegion' selection
 304     if (!haveResults)
 305     {
 306       JvOptionPane.showInternalMessageDialog(this,
 307               MessageManager.getString("label.finished_searching"), null,
 308               JvOptionPane.INFORMATION_MESSAGE);
 309       resIndex = -1;
 310       seqIndex = 0;
 311     }
 312     else
 313     {
 314       if (findAll)
 315       {
 316         // then we report the matches that were found
 317         String message = (idMatch.size() > 0) ? "" + idMatch.size()
 318                 + " IDs" : "";
 319         if (searchResults != null)
 320         {
 321           if (idMatch.size() > 0 && searchResults.getSize() > 0)
 322           {
 323             message += " and ";
 324           }
 325           message += searchResults.getSize()
 326                   + " subsequence matches found.";
 327         }
 328         JvOptionPane.showInternalMessageDialog(this, message, null,
 329                 JvOptionPane.INFORMATION_MESSAGE);
 330         resIndex = -1;
 331         seqIndex = 0;
 332       }
 333     }
 334     searchBox.updateCache();
 335   }
 336
 337   /**
 338    * Displays an error dialog, and answers false, if the search string is
 339    * invalid, else answers true.
 340    *
 341    * @param searchString
 342    * @return
 343    */
 344   protected boolean isInvalidSearchString(String searchString)
 345   {
 346     String error = getSearchValidationError(searchString);
 347     if (error == null)
 348     {
 349       return false;
 350     }
 351     JvOptionPane.showInternalMessageDialog(this, error,
 352             MessageManager.getString("label.invalid_search"), // $NON-NLS-1$
 353             JvOptionPane.ERROR_MESSAGE);
 354     return true;
 355   }
 356
 357   /**
 358    * Returns an error message string if the search string is invalid, else
 359    * returns null.
 360    *
 361    * Currently validation is limited to checking the string is not empty, and is
 362    * a valid regular expression (simple searches for base sub-sequences will
 363    * pass this test). Additional validations may be added in future if the
 364    * search syntax is expanded.
 365    *
 366    * @param searchString
 367    * @return
 368    */
 369   protected String getSearchValidationError(String searchString)
 370   {
 371     String error = null;
 372     if (searchString == null || searchString.length() == 0)
 373     {
 374       error = MessageManager.getString("label.invalid_search");
 375     }
 376     try
 377     {
 378       Pattern.compile(searchString);
 379     } catch (PatternSyntaxException e)
 380     {
 381       error = MessageManager.getString("error.invalid_regex") + ": "
 382               + e.getDescription();
 383     }
 384     return error;
 385   }
 386
 387   protected void closeAction()
 388   {
 389     frame.dispose();
 390     AppCache.getInstance().persistCache(getCacheKey());
 391   }
 392 }