a069dccdec4cee82c5292c3a1fb35d8c34647dda
[jalview.git] / src / jalview / controller / AlignViewController.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9.0b1)
3  * Copyright (C) 2015 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.controller;
22
23 import jalview.analysis.AlignmentSorter;
24 import jalview.api.AlignViewControllerGuiI;
25 import jalview.api.AlignViewControllerI;
26 import jalview.api.AlignViewportI;
27 import jalview.api.AlignmentViewPanel;
28 import jalview.api.FeatureRenderer;
29 import jalview.commands.OrderCommand;
30 import jalview.datamodel.AlignmentI;
31 import jalview.datamodel.ColumnSelection;
32 import jalview.datamodel.SequenceCollectionI;
33 import jalview.datamodel.SequenceFeature;
34 import jalview.datamodel.SequenceGroup;
35 import jalview.datamodel.SequenceI;
36 import jalview.io.FeaturesFile;
37 import jalview.util.MessageManager;
38
39 import java.awt.Color;
40 import java.util.ArrayList;
41 import java.util.BitSet;
42 import java.util.List;
43
44 public class AlignViewController implements AlignViewControllerI
45 {
46   AlignViewportI viewport = null;
47
48   AlignmentViewPanel alignPanel = null;
49
50   /**
51    * the GUI container that is handling interactions with the user
52    */
53   private AlignViewControllerGuiI avcg;
54
55   @Override
56   protected void finalize() throws Throwable
57   {
58     viewport = null;
59     alignPanel = null;
60     avcg = null;
61   };
62
63   public AlignViewController(AlignViewControllerGuiI alignFrame,
64           AlignViewportI viewport, AlignmentViewPanel alignPanel)
65   {
66     this.avcg = alignFrame;
67     this.viewport = viewport;
68     this.alignPanel = alignPanel;
69   }
70
71   @Override
72   public void setViewportAndAlignmentPanel(AlignViewportI viewport,
73           AlignmentViewPanel alignPanel)
74   {
75     this.alignPanel = alignPanel;
76     this.viewport = viewport;
77
78   }
79
80   @Override
81   public boolean makeGroupsFromSelection()
82   {
83     SequenceGroup sg = viewport.getSelectionGroup();
84     ColumnSelection cs = viewport.getColumnSelection();
85     SequenceGroup[] gps = null;
86     if (sg != null
87             && (cs == null || cs.getSelected() == null || cs.size() == 0))
88     {
89       gps = jalview.analysis.Grouping.makeGroupsFrom(viewport
90               .getSequenceSelection(), viewport.getAlignmentView(true)
91               .getSequenceStrings(viewport.getGapCharacter()), viewport
92               .getAlignment().getGroups());
93     }
94     else
95     {
96       if (cs != null)
97       {
98         gps = jalview.analysis.Grouping.makeGroupsFromCols(
99                 (sg == null) ? viewport.getAlignment().getSequencesArray()
100                         : sg.getSequences().toArray(new SequenceI[0]), cs,
101                 viewport.getAlignment().getGroups());
102       }
103     }
104     if (gps != null)
105     {
106       viewport.getAlignment().deleteAllGroups();
107       viewport.clearSequenceColours();
108       viewport.setSelectionGroup(null);
109       // set view properties for each group
110       for (int g = 0; g < gps.length; g++)
111       {
112         // gps[g].setShowunconserved(viewport.getShowUnconserved());
113         gps[g].setshowSequenceLogo(viewport.isShowSequenceLogo());
114         viewport.getAlignment().addGroup(gps[g]);
115         Color col = new Color((int) (Math.random() * 255),
116                 (int) (Math.random() * 255), (int) (Math.random() * 255));
117         col = col.brighter();
118         for (SequenceI sq : gps[g].getSequences(null))
119         {
120           viewport.setSequenceColour(sq, col);
121         }
122       }
123       return true;
124     }
125     return false;
126   }
127
128   @Override
129   public boolean createGroup()
130   {
131
132     SequenceGroup sg = viewport.getSelectionGroup();
133     if (sg != null)
134     {
135       viewport.getAlignment().addGroup(sg);
136       return true;
137     }
138     return false;
139   }
140
141   @Override
142   public boolean unGroup()
143   {
144     SequenceGroup sg = viewport.getSelectionGroup();
145     if (sg != null)
146     {
147       viewport.getAlignment().deleteGroup(sg);
148       return true;
149     }
150     return false;
151   }
152
153   @Override
154   public boolean deleteGroups()
155   {
156     if (viewport.getAlignment().getGroups() != null
157             && viewport.getAlignment().getGroups().size() > 0)
158     {
159       viewport.getAlignment().deleteAllGroups();
160       viewport.clearSequenceColours();
161       viewport.setSelectionGroup(null);
162       return true;
163     }
164     return false;
165   }
166
167   @Override
168   public boolean markColumnsContainingFeatures(boolean invert,
169           boolean extendCurrent, boolean toggle, String featureType)
170   {
171     // JBPNote this routine could also mark rows, not just columns.
172     // need a decent query structure to allow all types of feature searches
173     BitSet bs = new BitSet();
174     int alw, alStart;
175     SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null ? viewport
176             .getAlignment() : viewport.getSelectionGroup());
177     alStart = sqcol.getStartRes();
178     alw = sqcol.getEndRes() + 1;
179     List<SequenceI> seqs = sqcol.getSequences();
180     int nseq = 0;
181     for (SequenceI sq : seqs)
182     {
183       int tfeat = 0;
184       if (sq != null)
185       {
186         SequenceFeature[] sf = sq.getSequenceFeatures();
187         if (sf != null)
188         {
189           int ist = sq.findIndex(sq.getStart());
190           int iend = sq.findIndex(sq.getEnd());
191           if (iend < alStart || ist > alw)
192           {
193             // sequence not in region
194             continue;
195           }
196           for (SequenceFeature sfpos : sf)
197           {
198             // future functionalty - featureType == null means mark columns
199             // containing all displayed features
200             if (sfpos != null && (featureType.equals(sfpos.getType())))
201             {
202               tfeat++;
203               // optimisation - could consider 'spos,apos' like cursor argument
204               // - findIndex wastes time by starting from first character and
205               // counting
206
207               int i = sq.findIndex(sfpos.getBegin());
208               int j = sq.findIndex(sfpos.getEnd());
209               if (j < alStart || i > alw)
210               {
211                 // feature is outside selected region
212                 continue;
213               }
214               if (i < alStart)
215               {
216                 i = alStart;
217               }
218               if (i < ist)
219               {
220                 i = ist;
221               }
222               if (j > alw)
223               {
224                 j = alw;
225               }
226               for (; i <= j; i++)
227               {
228                 bs.set(i - 1);
229               }
230             }
231           }
232         }
233
234         if (tfeat > 0)
235         {
236           nseq++;
237         }
238       }
239     }
240     ColumnSelection cs = viewport.getColumnSelection();
241     if (bs.cardinality() > 0 || invert)
242     {
243       if (cs == null)
244       {
245         cs = new ColumnSelection();
246       }
247       else
248       {
249         if (!extendCurrent)
250         {
251           cs.clear();
252         }
253       }
254       if (invert)
255       {
256         // invert only in the currently selected sequence region
257         for (int i = bs.nextClearBit(alStart), ibs = bs.nextSetBit(alStart); i >= alStart
258                 && i < (alw);)
259         {
260           if (ibs < 0 || i < ibs)
261           {
262             if (toggle && cs.contains(i))
263             {
264               cs.removeElement(i++);
265             }
266             else
267             {
268               cs.addElement(i++);
269             }
270           }
271           else
272           {
273             i = bs.nextClearBit(ibs);
274             ibs = bs.nextSetBit(i);
275           }
276         }
277       }
278       else
279       {
280         for (int i = bs.nextSetBit(alStart); i >= alStart; i = bs
281                 .nextSetBit(i + 1))
282         {
283           if (toggle && cs.contains(i))
284           {
285             cs.removeElement(i);
286           }
287           else
288           {
289             cs.addElement(i);
290           }
291         }
292       }
293       viewport.setColumnSelection(cs);
294       alignPanel.paintAlignment(true);
295       avcg.setStatus(MessageManager.formatMessage(
296               "label.view_controller_toggled_marked",
297               new String[] {
298                   (toggle ? MessageManager.getString("label.toggled")
299                           : MessageManager.getString("label.marked")),
300                   (invert ? (Integer.valueOf((alw - alStart)
301                           - bs.cardinality()).toString()) : (Integer
302                           .valueOf(bs.cardinality()).toString())),
303                   featureType, Integer.valueOf(nseq).toString() }));
304       return true;
305     }
306     else
307     {
308       avcg.setStatus(MessageManager.formatMessage(
309               "label.no_feature_of_type_found",
310               new String[] { featureType }));
311       if (!extendCurrent && cs != null)
312       {
313         cs.clear();
314         alignPanel.paintAlignment(true);
315       }
316       return false;
317     }
318   }
319
320   @Override
321   public void sortAlignmentByFeatureDensity(String[] typ)
322   {
323     sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
324   }
325
326   protected void sortBy(String[] typ, String methodText, final String method)
327   {
328     FeatureRenderer fr = alignPanel.getFeatureRenderer();
329     if (typ == null)
330     {
331       typ = fr == null ? null : fr.getDisplayedFeatureTypes();
332     }
333     String gps[] = null;
334     gps = fr == null ? null : fr.getDisplayedFeatureGroups();
335     if (typ != null)
336     {
337       ArrayList types = new ArrayList();
338       for (int i = 0; i < typ.length; i++)
339       {
340         if (typ[i] != null)
341         {
342           types.add(typ[i]);
343         }
344         typ = new String[types.size()];
345         types.toArray(typ);
346       }
347     }
348     if (gps != null)
349     {
350       ArrayList grps = new ArrayList();
351
352       for (int i = 0; i < gps.length; i++)
353       {
354         if (gps[i] != null)
355         {
356           grps.add(gps[i]);
357         }
358       }
359       gps = new String[grps.size()];
360       grps.toArray(gps);
361     }
362     AlignmentI al = viewport.getAlignment();
363
364     int start, stop;
365     SequenceGroup sg = viewport.getSelectionGroup();
366     if (sg != null)
367     {
368       start = sg.getStartRes();
369       stop = sg.getEndRes();
370     }
371     else
372     {
373       start = 0;
374       stop = al.getWidth();
375     }
376     SequenceI[] oldOrder = al.getSequencesArray();
377     AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method);
378     avcg.addHistoryItem(new OrderCommand(methodText, oldOrder, viewport
379             .getAlignment()));
380     alignPanel.paintAlignment(true);
381
382   }
383
384   @Override
385   public void sortAlignmentByFeatureScore(String[] typ)
386   {
387     sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
388   }
389
390   @Override
391   public boolean parseFeaturesFile(String file, String protocol,
392           boolean relaxedIdMatching)
393   {
394     boolean featuresFile = false;
395     try
396     {
397       featuresFile = new FeaturesFile(file, protocol).parse(viewport
398               .getAlignment().getDataset(), alignPanel.getFeatureRenderer()
399               .getFeatureColours(), false, relaxedIdMatching);
400     } catch (Exception ex)
401     {
402       ex.printStackTrace();
403     }
404
405     if (featuresFile)
406     {
407       avcg.refreshFeatureUI(true);
408       if (alignPanel.getFeatureRenderer() != null)
409       {
410         // update the min/max ranges where necessary
411         alignPanel.getFeatureRenderer().findAllFeatures(true);
412       }
413       if (avcg.getFeatureSettingsUI() != null)
414       {
415         avcg.getFeatureSettingsUI().discoverAllFeatureData();
416       }
417       alignPanel.paintAlignment(true);
418     }
419
420     return featuresFile;
421
422   }
423 }