JAL-1834 removed quotes around truncated strings with ellipsis
[jalview.git] / src / jalview / datamodel / HiddenSequences.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.datamodel;
22
23 import java.util.ArrayList;
24 import java.util.List;
25 import java.util.Map;
26
27 public class HiddenSequences
28 {
29   /**
30    * holds a list of hidden sequences associated with an alignment.
31    */
32   public SequenceI[] hiddenSequences;
33
34   AlignmentI alignment;
35
36   public HiddenSequences(AlignmentI al)
37   {
38     alignment = al;
39   }
40
41   public int getSize()
42   {
43     if (hiddenSequences == null)
44     {
45       return 0;
46     }
47     int count = 0;
48     for (int i = 0; i < hiddenSequences.length; i++)
49     {
50       if (hiddenSequences[i] != null)
51       {
52         count++;
53       }
54     }
55
56     return count;
57   }
58
59   public int getWidth()
60   {
61     int width = 0;
62     for (int i = 0; i < hiddenSequences.length; i++)
63     {
64       if (hiddenSequences[i] != null
65               && hiddenSequences[i].getLength() > width)
66       {
67         width = hiddenSequences[i].getLength();
68       }
69     }
70
71     return width;
72   }
73
74   /**
75    * Call this method if sequences are removed from the main alignment
76    */
77   public void adjustHeightSequenceDeleted(int seqIndex)
78   {
79     if (hiddenSequences == null)
80     {
81       return;
82     }
83
84     int alHeight = alignment.getHeight();
85
86     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
87     int deletionIndex = adjustForHiddenSeqs(seqIndex);
88
89     for (int i = 0; i < hiddenSequences.length; i++)
90     {
91       if (hiddenSequences[i] == null)
92       {
93         continue;
94       }
95
96       if (i > deletionIndex)
97       {
98         tmp[i - 1] = hiddenSequences[i];
99       }
100       else
101       {
102         tmp[i] = hiddenSequences[i];
103       }
104     }
105
106     hiddenSequences = tmp;
107
108   }
109
110   /**
111    * Call this method if sequences are added to or removed from the main
112    * alignment
113    */
114   public void adjustHeightSequenceAdded()
115   {
116     if (hiddenSequences == null)
117     {
118       return;
119     }
120
121     int alHeight = alignment.getHeight();
122
123     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
124     System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
125     hiddenSequences = tmp;
126   }
127
128   public void hideSequence(SequenceI sequence)
129   {
130     if (hiddenSequences == null)
131     {
132       hiddenSequences = new SequenceI[alignment.getHeight()];
133     }
134
135     int alignmentIndex = alignment.findIndex(sequence);
136     alignmentIndex = adjustForHiddenSeqs(alignmentIndex);
137
138     if (hiddenSequences[alignmentIndex] != null)
139     {
140       System.out.println("ERROR!!!!!!!!!!!");
141     }
142
143     hiddenSequences[alignmentIndex] = sequence;
144
145     alignment.deleteSequence(sequence);
146   }
147
148   public List<SequenceI> showAll(
149           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
150   {
151     List<SequenceI> revealedSeqs = new ArrayList<SequenceI>();
152     for (int i = 0; i < hiddenSequences.length; i++)
153     {
154       if (hiddenSequences[i] != null)
155       {
156         List<SequenceI> tmp = showSequence(i, hiddenRepSequences);
157         for (SequenceI seq : tmp)
158         {
159           revealedSeqs.add(seq);
160         }
161       }
162     }
163     return revealedSeqs;
164   }
165
166   public List<SequenceI> showSequence(int alignmentIndex,
167           Map<SequenceI, SequenceCollectionI> hiddenRepSequences)
168   {
169     List<SequenceI> revealedSeqs = new ArrayList<SequenceI>();
170     SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
171     if (repSequence != null && hiddenRepSequences != null
172             && hiddenRepSequences.containsKey(repSequence))
173     {
174       hiddenRepSequences.remove(repSequence);
175       revealedSeqs.add(repSequence);
176     }
177
178     int start = adjustForHiddenSeqs(alignmentIndex - 1);
179     int end = adjustForHiddenSeqs(alignmentIndex);
180     if (end >= hiddenSequences.length)
181     {
182       end = hiddenSequences.length - 1;
183     }
184
185     List<SequenceI> asequences;
186     synchronized (asequences = alignment.getSequences())
187     {
188       for (int index = end; index > start; index--)
189       {
190         SequenceI seq = hiddenSequences[index];
191         hiddenSequences[index] = null;
192
193         if (seq != null)
194         {
195           if (seq.getLength() > 0)
196           {
197             revealedSeqs.add(seq);
198             asequences.add(alignmentIndex, seq);
199           }
200           else
201           {
202             System.out.println(seq.getName()
203                     + " has been deleted whilst hidden");
204           }
205         }
206
207       }
208     }
209
210     return revealedSeqs;
211   }
212
213   public SequenceI getHiddenSequence(int alignmentIndex)
214   {
215     return hiddenSequences[alignmentIndex];
216   }
217
218   public int findIndexWithoutHiddenSeqs(int alignmentIndex)
219   {
220     int index = 0;
221     int hiddenSeqs = 0;
222     if (hiddenSequences.length <= alignmentIndex)
223     {
224       alignmentIndex = hiddenSequences.length - 1;
225     }
226
227     while (index <= alignmentIndex)
228     {
229       if (hiddenSequences[index] != null)
230       {
231         hiddenSeqs++;
232       }
233       index++;
234     }
235     ;
236
237     return (alignmentIndex - hiddenSeqs);
238   }
239
240   public int adjustForHiddenSeqs(int alignmentIndex)
241   {
242     int index = 0;
243     int hSize = hiddenSequences.length;
244     while (index <= alignmentIndex && index < hSize)
245     {
246       if (hiddenSequences[index] != null)
247       {
248         alignmentIndex++;
249       }
250       index++;
251     }
252     ;
253
254     return alignmentIndex;
255   }
256
257   public AlignmentI getFullAlignment()
258   {
259     int isize = hiddenSequences.length;
260     SequenceI[] seq = new Sequence[isize];
261
262     int index = 0;
263     for (int i = 0; i < hiddenSequences.length; i++)
264     {
265       if (hiddenSequences[i] != null)
266       {
267         seq[i] = hiddenSequences[i];
268       }
269       else
270       {
271         seq[i] = alignment.getSequenceAt(index);
272         index++;
273       }
274     }
275     Alignment fAlignmt = new Alignment(seq);
276     fAlignmt.annotations = alignment.getAlignmentAnnotation();
277     fAlignmt.alignmentProperties = alignment.getProperties();
278     fAlignmt.groups = alignment.getGroups();
279     fAlignmt.hasRNAStructure = alignment.hasRNAStructure();
280
281     return fAlignmt;
282   }
283
284   public boolean isHidden(SequenceI seq)
285   {
286     if (hiddenSequences != null)
287     {
288       for (int i = 0; i < hiddenSequences.length; i++)
289       {
290         if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
291         {
292           return true;
293         }
294       }
295     }
296
297     return false;
298   }
299 }