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