Send gapChar to print original Data
[jalview.git] / src / jalview / datamodel / ColumnSelection.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer
3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
18  */
19 package jalview.datamodel;
20
21 import java.util.*;
22
23 /**
24  * NOTE: Columns are zero based.
25  */
26 public class ColumnSelection
27 {
28     Vector selected = new Vector();
29
30     //Vector of int [] {startCol, endCol}
31     Vector hiddenColumns;
32
33     /**
34      * Add a column to the selection
35      *
36      * @param col index of column
37      */
38     public void addElement(int col)
39     {
40         Integer column = new Integer(col);
41         if (!selected.contains(column))
42         {
43             selected.addElement(column);
44         }
45     }
46
47     /**
48      * clears column selection
49      */
50     public void clear()
51     {
52         selected.removeAllElements();
53     }
54
55     /**
56      * removes col from selection
57      *
58      * @param col index of column to be removed
59      */
60     public void removeElement(int col)
61     {
62         Integer colInt = new Integer(col);
63
64         if (selected.contains(colInt))
65         {
66             selected.removeElement(colInt);
67         }
68     }
69
70     /**
71      * removes a range of columns from the selection
72      * @param start int - first column in range to be removed
73      * @param end int - last col
74      */
75     public void removeElements(int start, int end)
76     {
77       Integer colInt;
78       for(int i=start; i<end; i++)
79       {
80         colInt = new Integer(i);
81         if (selected.contains(colInt))
82         {
83             selected.removeElement(colInt);
84         }
85       }
86     }
87     /**
88      *
89      * @return Vector containing selected columns as Integers
90      */
91     public Vector getSelected()
92     {
93       return selected;
94     }
95
96     /**
97      *
98      * @param col index to search for in column selection
99      *
100      * @return true if Integer(col) is in selection.
101      */
102     public boolean contains(int col)
103     {
104         return selected.contains(new Integer(col));
105     }
106
107     /**
108      * DOCUMENT ME!
109      *
110      * @param i DOCUMENT ME!
111      *
112      * @return DOCUMENT ME!
113      */
114     public int columnAt(int i)
115     {
116         return ((Integer) selected.elementAt(i)).intValue();
117     }
118
119     /**
120      * DOCUMENT ME!
121      *
122      * @return DOCUMENT ME!
123      */
124     public int size()
125     {
126         return selected.size();
127     }
128
129     /**
130      * DOCUMENT ME!
131      *
132      * @return DOCUMENT ME!
133      */
134     public int getMax()
135     {
136         int max = -1;
137
138         for (int i = 0; i < selected.size(); i++)
139         {
140             if (columnAt(i) > max)
141             {
142                 max = columnAt(i);
143             }
144         }
145
146         return max;
147     }
148
149     /**
150      * DOCUMENT ME!
151      *
152      * @return DOCUMENT ME!
153      */
154     public int getMin()
155     {
156         int min = 1000000000;
157
158         for (int i = 0; i < selected.size(); i++)
159         {
160             if (columnAt(i) < min)
161             {
162                 min = columnAt(i);
163             }
164         }
165
166         return min;
167     }
168
169
170     /**
171      * DOCUMENT ME!
172      *
173      * @param start DOCUMENT ME!
174      * @param change DOCUMENT ME!
175      */
176     public void compensateForEdit(int start, int change)
177     {
178         for (int i = 0; i < size(); i++)
179         {
180             int temp = columnAt(i);
181
182             if (temp >= start)
183             {
184                 selected.setElementAt(new Integer(temp - change), i);
185             }
186         }
187
188         if(hiddenColumns!=null)
189         {
190           for(int i=0; i<hiddenColumns.size(); i++)
191           {
192             int[] region = (int[]) hiddenColumns.elementAt(i);
193             if(region[0] > start)
194             {
195               region[0] -= change;
196               region[1] -= change;
197             }
198             if(region[0]<0)
199               region[0] = 0;
200             if(region[1] <0)
201              region[1] = 0;
202           }
203         }
204     }
205
206     /**
207      * This Method is used to return all the HiddenColumn regions
208      * less than the given index.
209      * @param end int
210      * @return Vector
211      */
212     public Vector getHiddenColumns()
213     {
214       return hiddenColumns;
215     }
216     /**
217      * Return absolute column index for a visible column index
218      * @param column int column index in alignment view
219      * @return alignment column index for column
220      */
221     public int adjustForHiddenColumns(int column)
222     {
223       int result = column;
224       if (hiddenColumns != null)
225       {
226         for (int i = 0; i < hiddenColumns.size(); i++)
227         {
228           int[] region = (int[]) hiddenColumns.elementAt(i);
229           if (result >= region[0])
230           {
231             result += region[1] - region[0] + 1;
232           }
233         }
234       }
235       return result;
236     }
237
238     /**
239      * Use this method to find out where a visible column is in the alignment
240      * when hidden columns exist
241      * @param hiddenColumn int
242      * @return int
243      */
244     public int findColumnPosition(int hiddenColumn)
245     {
246       int result = hiddenColumn;
247       if (hiddenColumns != null)
248       {
249         int index = 0;
250         int gaps = 0;
251         do
252         {
253           int[] region = (int[]) hiddenColumns.elementAt(index);
254           if (hiddenColumn > region[1])
255           {
256             result -= region[1]+1-region[0];
257           }
258           index++;
259         }
260         while (index < hiddenColumns.size());
261
262         result -= gaps;
263       }
264
265       return result;
266     }
267
268     /**
269      * Use this method to determine where the next hiddenRegion starts
270     */
271     public int findHiddenRegionPosition(int hiddenRegion)
272     {
273       int result = 0;
274       if (hiddenColumns != null)
275       {
276         int index = 0;
277         int gaps = 0;
278         do
279         {
280           int[] region = (int[]) hiddenColumns.elementAt(index);
281           if(hiddenRegion==0)
282           {
283             return region[0];
284           }
285
286             gaps +=  region[1] +1 - region[0];
287             result = region[1] +1;
288             index++;
289         }
290         while(index < hiddenRegion+1);
291
292         result -= gaps;
293       }
294
295       return result;
296     }
297
298     /**
299      * THis method returns the rightmost limit of a
300      * region of an alignment with hidden columns.
301      * In otherwords, the next hidden column.
302      * @param index int
303      */
304     public int getHiddenBoundaryRight(int alPos)
305     {
306       if (hiddenColumns != null)
307       {
308         int index = 0;
309         do
310         {
311           int[] region = (int[]) hiddenColumns.elementAt(index);
312           if(alPos < region[0])
313             return region[0];
314
315           index++;
316         }
317         while(index < hiddenColumns.size());
318       }
319
320       return alPos;
321
322     }
323     /**
324      * THis method returns the rightmost limit of a
325      * region of an alignment with hidden columns.
326      * In otherwords, the next hidden column.
327      * @param index int
328      */
329     public int getHiddenBoundaryLeft(int alPos)
330     {
331       if (hiddenColumns != null)
332       {
333         int index = hiddenColumns.size()-1;
334         do
335         {
336           int[] region = (int[]) hiddenColumns.elementAt(index);
337           if(alPos > region[1])
338             return region[1];
339
340           index--;
341         }
342         while(index >-1);
343       }
344
345       return alPos;
346
347     }
348
349     public void hideSelectedColumns()
350     {
351       while (size() > 0)
352       {
353         int column = ( (Integer) getSelected().firstElement()).intValue();
354         hideColumns(column);
355       }
356
357     }
358
359     public void hideColumns(int start, int end)
360     {
361       if(hiddenColumns==null)
362         hiddenColumns = new Vector();
363
364       boolean added = false;
365       boolean overlap = false;
366
367       for (int i = 0; i < hiddenColumns.size(); i++)
368       {
369         int[] region = (int[]) hiddenColumns.elementAt(i);
370         if ( start<=region[1] && end>=region[0])
371         {
372           hiddenColumns.removeElementAt(i);
373           overlap = true;
374           break;
375         }
376         else if (end < region[0] && start < region[0])
377         {
378           hiddenColumns.insertElementAt(new int[]
379                                         {start, end}, i);
380           added = true;
381           break;
382         }
383       }
384
385       if(overlap)
386       {
387          hideColumns(start, end);
388       }
389       else if (!added)
390         hiddenColumns.addElement(new int[] {start, end});
391
392     }
393
394     /**
395      * This method will find a range of selected columns
396      * around the column specified
397      * @param res int
398      */
399     public void hideColumns(int col)
400     {
401       // First find out range of columns to hide
402       int min = col, max = col+1;
403       while( contains(min) )
404       {  removeElement(min); min --;  }
405
406       while( contains(max) )
407       { removeElement(max);  max ++;  }
408
409       min++; max--;
410
411       hideColumns(min, max);
412     }
413
414     public void revealAllHiddenColumns()
415     {
416       if(hiddenColumns!=null)
417       {
418         for (int i = 0; i < hiddenColumns.size(); i++)
419         {
420           int[] region = (int[]) hiddenColumns.elementAt(i);
421           for (int j = region[0]; j < region[1]; j++)
422           {
423             addElement(j);
424           }
425         }
426       }
427
428       hiddenColumns = null;
429     }
430
431     public void revealHiddenColumns(int res)
432     {
433       for(int i=0; i<hiddenColumns.size(); i++)
434       {
435         int [] region = (int[])hiddenColumns.elementAt(i);
436         if( res == region[0])
437         {
438           for (int j = region[0]; j < region[1]; j++)
439           {
440             addElement(j);
441           }
442
443           hiddenColumns.removeElement(region);
444           break;
445         }
446       }
447       if(hiddenColumns.size()==0)
448         hiddenColumns = null;
449     }
450
451     public boolean isVisible(int column)
452     {
453       for(int i=0; i<hiddenColumns.size(); i++)
454       {
455         int [] region = (int[])hiddenColumns.elementAt(i);
456         if( column >= region[0] && column <= region[1])
457         {
458           return false;
459         }
460       }
461       return true;
462     }
463
464 }