JAL-1834 removed quotes around truncated strings with ellipsis
[jalview.git] / src / jalview / datamodel / ColumnSelection.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 jalview.util.ShiftList;
24 import jalview.viewmodel.annotationfilter.AnnotationFilterParameter;
25 import jalview.viewmodel.annotationfilter.AnnotationFilterParameter.SearchableAnnotationField;
26
27 import java.util.ArrayList;
28 import java.util.Collections;
29 import java.util.List;
30 import java.util.Vector;
31
32 /**
33  * NOTE: Columns are zero based.
34  */
35 public class ColumnSelection
36 {
37   Vector<Integer> selected = new Vector<Integer>();
38
39   // Vector of int [] {startCol, endCol}
40   Vector<int[]> hiddenColumns;
41
42   /**
43    * Add a column to the selection
44    * 
45    * @param col
46    *          index of column
47    */
48   public void addElement(int col)
49   {
50     Integer column = new Integer(col);
51     if (!selected.contains(column))
52     {
53       selected.addElement(column);
54     }
55   }
56
57   /**
58    * clears column selection
59    */
60   public void clear()
61   {
62     selected.removeAllElements();
63   }
64
65   /**
66    * Removes value 'col' from the selection (not the col'th item)
67    * 
68    * @param col
69    *          index of column to be removed
70    */
71   public void removeElement(int col)
72   {
73     Integer colInt = new Integer(col);
74
75     if (selected.contains(colInt))
76     {
77       // if this ever changes to List.remove(), ensure Integer not int argument
78       // as List.remove(int i) removes the i'th item which is wrong
79       selected.removeElement(colInt);
80     }
81   }
82
83   /**
84    * removes a range of columns from the selection
85    * 
86    * @param start
87    *          int - first column in range to be removed
88    * @param end
89    *          int - last col
90    */
91   public void removeElements(int start, int end)
92   {
93     Integer colInt;
94     for (int i = start; i < end; i++)
95     {
96       colInt = new Integer(i);
97       if (selected.contains(colInt))
98       {
99         selected.removeElement(colInt);
100       }
101     }
102   }
103
104   /**
105    * 
106    * @return Vector containing selected columns as Integers
107    */
108   public Vector<Integer> getSelected()
109   {
110     return selected;
111   }
112
113   /**
114    * 
115    * @param col
116    *          index to search for in column selection
117    * 
118    * @return true if Integer(col) is in selection.
119    */
120   public boolean contains(int col)
121   {
122     return selected.contains(new Integer(col));
123   }
124
125   /**
126    * Column number at position i in selection
127    * 
128    * @param i
129    *          index into selected columns
130    * 
131    * @return column number in alignment
132    */
133   public int columnAt(int i)
134   {
135     return selected.elementAt(i).intValue();
136   }
137
138   /**
139    * DOCUMENT ME!
140    * 
141    * @return DOCUMENT ME!
142    */
143   public int size()
144   {
145     return selected.size();
146   }
147
148   /**
149    * rightmost selected column
150    * 
151    * @return rightmost column in alignment that is selected
152    */
153   public int getMax()
154   {
155     int max = -1;
156
157     for (int i = 0; i < selected.size(); i++)
158     {
159       if (columnAt(i) > max)
160       {
161         max = columnAt(i);
162       }
163     }
164
165     return max;
166   }
167
168   /**
169    * Leftmost column in selection
170    * 
171    * @return column index of leftmost column in selection
172    */
173   public int getMin()
174   {
175     int min = 1000000000;
176
177     for (int i = 0; i < selected.size(); i++)
178     {
179       if (columnAt(i) < min)
180       {
181         min = columnAt(i);
182       }
183     }
184
185     return min;
186   }
187
188   /**
189    * propagate shift in alignment columns to column selection
190    * 
191    * @param start
192    *          beginning of edit
193    * @param left
194    *          shift in edit (+ve for removal, or -ve for inserts)
195    */
196   public List<int[]> compensateForEdit(int start, int change)
197   {
198     List<int[]> deletedHiddenColumns = null;
199     for (int i = 0; i < size(); i++)
200     {
201       int temp = columnAt(i);
202
203       if (temp >= start)
204       {
205         // if this ever changes to List.set(), swap parameter order!!
206         selected.setElementAt(new Integer(temp - change), i);
207       }
208     }
209
210     if (hiddenColumns != null)
211     {
212       deletedHiddenColumns = new ArrayList<int[]>();
213       int hSize = hiddenColumns.size();
214       for (int i = 0; i < hSize; i++)
215       {
216         int[] region = hiddenColumns.elementAt(i);
217         if (region[0] > start && start + change > region[1])
218         {
219           deletedHiddenColumns.add(region);
220
221           hiddenColumns.removeElementAt(i);
222           i--;
223           hSize--;
224           continue;
225         }
226
227         if (region[0] > start)
228         {
229           region[0] -= change;
230           region[1] -= change;
231         }
232
233         if (region[0] < 0)
234         {
235           region[0] = 0;
236         }
237
238       }
239
240       this.revealHiddenColumns(0);
241     }
242
243     return deletedHiddenColumns;
244   }
245
246   /**
247    * propagate shift in alignment columns to column selection special version of
248    * compensateForEdit - allowing for edits within hidden regions
249    * 
250    * @param start
251    *          beginning of edit
252    * @param left
253    *          shift in edit (+ve for removal, or -ve for inserts)
254    */
255   private void compensateForDelEdits(int start, int change)
256   {
257     for (int i = 0; i < size(); i++)
258     {
259       int temp = columnAt(i);
260
261       if (temp >= start)
262       {
263         // if this ever changes to List.set(), swap parameter order!!
264         selected.setElementAt(new Integer(temp - change), i);
265       }
266     }
267
268     if (hiddenColumns != null)
269     {
270       for (int i = 0; i < hiddenColumns.size(); i++)
271       {
272         int[] region = hiddenColumns.elementAt(i);
273         if (region[0] >= start)
274         {
275           region[0] -= change;
276         }
277         if (region[1] >= start)
278         {
279           region[1] -= change;
280         }
281         if (region[1] < region[0])
282         {
283           hiddenColumns.removeElementAt(i--);
284         }
285
286         if (region[0] < 0)
287         {
288           region[0] = 0;
289         }
290         if (region[1] < 0)
291         {
292           region[1] = 0;
293         }
294       }
295     }
296   }
297
298   /**
299    * Adjust hidden column boundaries based on a series of column additions or
300    * deletions in visible regions.
301    * 
302    * @param shiftrecord
303    * @return
304    */
305   public ShiftList compensateForEdits(ShiftList shiftrecord)
306   {
307     if (shiftrecord != null)
308     {
309       final List<int[]> shifts = shiftrecord.getShifts();
310       if (shifts != null && shifts.size() > 0)
311       {
312         int shifted = 0;
313         for (int i = 0, j = shifts.size(); i < j; i++)
314         {
315           int[] sh = shifts.get(i);
316           // compensateForEdit(shifted+sh[0], sh[1]);
317           compensateForDelEdits(shifted + sh[0], sh[1]);
318           shifted -= sh[1];
319         }
320       }
321       return shiftrecord.getInverse();
322     }
323     return null;
324   }
325
326   /**
327    * removes intersection of position,length ranges in deletions from the
328    * start,end regions marked in intervals.
329    * 
330    * @param shifts
331    * @param intervals
332    * @return
333    */
334   private boolean pruneIntervalVector(final List<int[]> shifts,
335           Vector<int[]> intervals)
336   {
337     boolean pruned = false;
338     int i = 0, j = intervals.size() - 1, s = 0, t = shifts.size() - 1;
339     int hr[] = intervals.elementAt(i);
340     int sr[] = shifts.get(s);
341     while (i <= j && s <= t)
342     {
343       boolean trailinghn = hr[1] >= sr[0];
344       if (!trailinghn)
345       {
346         if (i < j)
347         {
348           hr = intervals.elementAt(++i);
349         }
350         else
351         {
352           i++;
353         }
354         continue;
355       }
356       int endshift = sr[0] + sr[1]; // deletion ranges - -ve means an insert
357       if (endshift < hr[0] || endshift < sr[0])
358       { // leadinghc disjoint or not a deletion
359         if (s < t)
360         {
361           sr = shifts.get(++s);
362         }
363         else
364         {
365           s++;
366         }
367         continue;
368       }
369       boolean leadinghn = hr[0] >= sr[0];
370       boolean leadinghc = hr[0] < endshift;
371       boolean trailinghc = hr[1] < endshift;
372       if (leadinghn)
373       {
374         if (trailinghc)
375         { // deleted hidden region.
376           intervals.removeElementAt(i);
377           pruned = true;
378           j--;
379           if (i <= j)
380           {
381             hr = intervals.elementAt(i);
382           }
383           continue;
384         }
385         if (leadinghc)
386         {
387           hr[0] = endshift; // clip c terminal region
388           leadinghn = !leadinghn;
389           pruned = true;
390         }
391       }
392       if (!leadinghn)
393       {
394         if (trailinghc)
395         {
396           if (trailinghn)
397           {
398             hr[1] = sr[0] - 1;
399             pruned = true;
400           }
401         }
402         else
403         {
404           // sr contained in hr
405           if (s < t)
406           {
407             sr = shifts.get(++s);
408           }
409           else
410           {
411             s++;
412           }
413           continue;
414         }
415       }
416     }
417     return pruned; // true if any interval was removed or modified by
418     // operations.
419   }
420
421   private boolean pruneColumnList(final List<int[]> shifts,
422           Vector<Integer> list)
423   {
424     int s = 0, t = shifts.size();
425     int[] sr = shifts.get(s++);
426     boolean pruned = false;
427     int i = 0, j = list.size();
428     while (i < j && s <= t)
429     {
430       int c = list.elementAt(i++).intValue();
431       if (sr[0] <= c)
432       {
433         if (sr[1] + sr[0] >= c)
434         { // sr[1] -ve means inseriton.
435           list.removeElementAt(--i);
436           j--;
437         }
438         else
439         {
440           if (s < t)
441           {
442             sr = shifts.get(s);
443           }
444           s++;
445         }
446       }
447     }
448     return pruned;
449   }
450
451   /**
452    * remove any hiddenColumns or selected columns and shift remaining based on a
453    * series of position, range deletions.
454    * 
455    * @param deletions
456    */
457   public void pruneDeletions(ShiftList deletions)
458   {
459     if (deletions != null)
460     {
461       final List<int[]> shifts = deletions.getShifts();
462       if (shifts != null && shifts.size() > 0)
463       {
464         // delete any intervals intersecting.
465         if (hiddenColumns != null)
466         {
467           pruneIntervalVector(shifts, hiddenColumns);
468           if (hiddenColumns != null && hiddenColumns.size() == 0)
469           {
470             hiddenColumns = null;
471           }
472         }
473         if (selected != null && selected.size() > 0)
474         {
475           pruneColumnList(shifts, selected);
476           if (selected != null && selected.size() == 0)
477           {
478             selected = null;
479           }
480         }
481         // and shift the rest.
482         this.compensateForEdits(deletions);
483       }
484     }
485   }
486
487   /**
488    * This Method is used to return all the HiddenColumn regions
489    * @return empty list or List of hidden column intervals
490    */
491   public List<int[]> getHiddenColumns()
492   {
493     return hiddenColumns == null ? Collections.<int[]> emptyList()
494             : hiddenColumns;
495   }
496
497   /**
498    * Return absolute column index for a visible column index
499    * 
500    * @param column
501    *          int column index in alignment view
502    * @return alignment column index for column
503    */
504   public int adjustForHiddenColumns(int column)
505   {
506     int result = column;
507     if (hiddenColumns != null)
508     {
509       for (int i = 0; i < hiddenColumns.size(); i++)
510       {
511         int[] region = hiddenColumns.elementAt(i);
512         if (result >= region[0])
513         {
514           result += region[1] - region[0] + 1;
515         }
516       }
517     }
518     return result;
519   }
520
521   /**
522    * Use this method to find out where a column will appear in the visible
523    * alignment when hidden columns exist. If the column is not visible, then the
524    * left-most visible column will always be returned.
525    * 
526    * @param hiddenColumn
527    *          int
528    * @return int
529    */
530   public int findColumnPosition(int hiddenColumn)
531   {
532     int result = hiddenColumn;
533     if (hiddenColumns != null)
534     {
535       int index = 0;
536       int[] region;
537       do
538       {
539         region = hiddenColumns.elementAt(index++);
540         if (hiddenColumn > region[1])
541         {
542           result -= region[1] + 1 - region[0];
543         }
544       } while ((hiddenColumn > region[1]) && (index < hiddenColumns.size()));
545       if (hiddenColumn > region[0] && hiddenColumn < region[1])
546       {
547         return region[0] + hiddenColumn - result;
548       }
549     }
550     return result; // return the shifted position after removing hidden columns.
551   }
552
553   /**
554    * Use this method to determine where the next hiddenRegion starts
555    */
556   public int findHiddenRegionPosition(int hiddenRegion)
557   {
558     int result = 0;
559     if (hiddenColumns != null)
560     {
561       int index = 0;
562       int gaps = 0;
563       do
564       {
565         int[] region = hiddenColumns.elementAt(index);
566         if (hiddenRegion == 0)
567         {
568           return region[0];
569         }
570
571         gaps += region[1] + 1 - region[0];
572         result = region[1] + 1;
573         index++;
574       } while (index < hiddenRegion + 1);
575
576       result -= gaps;
577     }
578
579     return result;
580   }
581
582   /**
583    * THis method returns the rightmost limit of a region of an alignment with
584    * hidden columns. In otherwords, the next hidden column.
585    * 
586    * @param index
587    *          int
588    */
589   public int getHiddenBoundaryRight(int alPos)
590   {
591     if (hiddenColumns != null)
592     {
593       int index = 0;
594       do
595       {
596         int[] region = hiddenColumns.elementAt(index);
597         if (alPos < region[0])
598         {
599           return region[0];
600         }
601
602         index++;
603       } while (index < hiddenColumns.size());
604     }
605
606     return alPos;
607
608   }
609
610   /**
611    * This method returns the leftmost limit of a region of an alignment with
612    * hidden columns. In otherwords, the previous hidden column.
613    * 
614    * @param index
615    *          int
616    */
617   public int getHiddenBoundaryLeft(int alPos)
618   {
619     if (hiddenColumns != null)
620     {
621       int index = hiddenColumns.size() - 1;
622       do
623       {
624         int[] region = hiddenColumns.elementAt(index);
625         if (alPos > region[1])
626         {
627           return region[1];
628         }
629
630         index--;
631       } while (index > -1);
632     }
633
634     return alPos;
635
636   }
637
638   public void hideSelectedColumns()
639   {
640     while (size() > 0)
641     {
642       int column = getSelected().firstElement().intValue();
643       hideColumns(column);
644     }
645
646   }
647
648   public void hideColumns(int start, int end)
649   {
650     if (hiddenColumns == null)
651     {
652       hiddenColumns = new Vector<int[]>();
653     }
654
655     boolean added = false;
656     boolean overlap = false;
657
658     for (int i = 0; i < hiddenColumns.size(); i++)
659     {
660       int[] region = hiddenColumns.elementAt(i);
661       if (start <= region[1] && end >= region[0])
662       {
663         hiddenColumns.removeElementAt(i);
664         overlap = true;
665         break;
666       }
667       else if (end < region[0] && start < region[0])
668       {
669         hiddenColumns.insertElementAt(new int[]
670         { start, end }, i);
671         added = true;
672         break;
673       }
674     }
675
676     if (overlap)
677     {
678       hideColumns(start, end);
679     }
680     else if (!added)
681     {
682       hiddenColumns.addElement(new int[]
683       { start, end });
684     }
685
686   }
687
688   /**
689    * This method will find a range of selected columns around the column
690    * specified
691    * 
692    * @param res
693    *          int
694    */
695   public void hideColumns(int col)
696   {
697     // First find out range of columns to hide
698     int min = col, max = col + 1;
699     while (contains(min))
700     {
701       removeElement(min);
702       min--;
703     }
704
705     while (contains(max))
706     {
707       removeElement(max);
708       max++;
709     }
710
711     min++;
712     max--;
713     if (min > max)
714     {
715       min = max;
716     }
717
718     hideColumns(min, max);
719   }
720
721   public void revealAllHiddenColumns()
722   {
723     if (hiddenColumns != null)
724     {
725       for (int i = 0; i < hiddenColumns.size(); i++)
726       {
727         int[] region = hiddenColumns.elementAt(i);
728         for (int j = region[0]; j < region[1] + 1; j++)
729         {
730           addElement(j);
731         }
732       }
733     }
734
735     hiddenColumns = null;
736   }
737
738   public void revealHiddenColumns(int res)
739   {
740     for (int i = 0; i < hiddenColumns.size(); i++)
741     {
742       int[] region = hiddenColumns.elementAt(i);
743       if (res == region[0])
744       {
745         for (int j = region[0]; j < region[1] + 1; j++)
746         {
747           addElement(j);
748         }
749
750         hiddenColumns.removeElement(region);
751         break;
752       }
753     }
754     if (hiddenColumns.size() == 0)
755     {
756       hiddenColumns = null;
757     }
758   }
759
760   public boolean isVisible(int column)
761   {
762     if (hiddenColumns != null)
763     {
764       for (int i = 0; i < hiddenColumns.size(); i++)
765       {
766         int[] region = hiddenColumns.elementAt(i);
767         if (column >= region[0] && column <= region[1])
768         {
769           return false;
770         }
771       }
772     }
773
774     return true;
775   }
776
777   /**
778    * Copy constructor
779    * 
780    * @param copy
781    */
782   public ColumnSelection(ColumnSelection copy)
783   {
784     if (copy != null)
785     {
786       if (copy.selected != null)
787       {
788         selected = new Vector<Integer>();
789         for (int i = 0, j = copy.selected.size(); i < j; i++)
790         {
791           selected.addElement(copy.selected.elementAt(i));
792         }
793       }
794       if (copy.hiddenColumns != null)
795       {
796         hiddenColumns = new Vector<int[]>(copy.hiddenColumns.size());
797         for (int i = 0, j = copy.hiddenColumns.size(); i < j; i++)
798         {
799           int[] rh, cp;
800           rh = copy.hiddenColumns.elementAt(i);
801           if (rh != null)
802           {
803             cp = new int[rh.length];
804             System.arraycopy(rh, 0, cp, 0, rh.length);
805             hiddenColumns.addElement(cp);
806           }
807         }
808       }
809     }
810   }
811
812   /**
813    * ColumnSelection
814    */
815   public ColumnSelection()
816   {
817   }
818
819   public String[] getVisibleSequenceStrings(int start, int end,
820           SequenceI[] seqs)
821   {
822     int i, iSize = seqs.length;
823     String selection[] = new String[iSize];
824     if (hiddenColumns != null && hiddenColumns.size() > 0)
825     {
826       for (i = 0; i < iSize; i++)
827       {
828         StringBuffer visibleSeq = new StringBuffer();
829         List<int[]> regions = getHiddenColumns();
830
831         int blockStart = start, blockEnd = end;
832         int[] region;
833         int hideStart, hideEnd;
834
835         for (int j = 0; j < regions.size(); j++)
836         {
837           region = regions.get(j);
838           hideStart = region[0];
839           hideEnd = region[1];
840
841           if (hideStart < start)
842           {
843             continue;
844           }
845
846           blockStart = Math.min(blockStart, hideEnd + 1);
847           blockEnd = Math.min(blockEnd, hideStart);
848
849           if (blockStart > blockEnd)
850           {
851             break;
852           }
853
854           visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd));
855
856           blockStart = hideEnd + 1;
857           blockEnd = end;
858         }
859
860         if (end > blockStart)
861         {
862           visibleSeq.append(seqs[i].getSequence(blockStart, end));
863         }
864
865         selection[i] = visibleSeq.toString();
866       }
867     }
868     else
869     {
870       for (i = 0; i < iSize; i++)
871       {
872         selection[i] = seqs[i].getSequenceAsString(start, end);
873       }
874     }
875
876     return selection;
877   }
878
879   /**
880    * return all visible segments between the given start and end boundaries
881    * 
882    * @param start
883    *          (first column inclusive from 0)
884    * @param end
885    *          (last column - not inclusive)
886    * @return int[] {i_start, i_end, ..} where intervals lie in
887    *         start<=i_start<=i_end<end
888    */
889   public int[] getVisibleContigs(int start, int end)
890   {
891     if (hiddenColumns != null && hiddenColumns.size() > 0)
892     {
893       List<int[]> visiblecontigs = new ArrayList<int[]>();
894       List<int[]> regions = getHiddenColumns();
895
896       int vstart = start;
897       int[] region;
898       int hideStart, hideEnd;
899
900       for (int j = 0; vstart < end && j < regions.size(); j++)
901       {
902         region = regions.get(j);
903         hideStart = region[0];
904         hideEnd = region[1];
905
906         if (hideEnd < vstart)
907         {
908           continue;
909         }
910         if (hideStart > vstart)
911         {
912           visiblecontigs.add(new int[]
913           { vstart, hideStart - 1 });
914         }
915         vstart = hideEnd + 1;
916       }
917
918       if (vstart < end)
919       {
920         visiblecontigs.add(new int[]
921         { vstart, end - 1 });
922       }
923       int[] vcontigs = new int[visiblecontigs.size() * 2];
924       for (int i = 0, j = visiblecontigs.size(); i < j; i++)
925       {
926         int[] vc = visiblecontigs.get(i);
927         visiblecontigs.set(i, null);
928         vcontigs[i * 2] = vc[0];
929         vcontigs[i * 2 + 1] = vc[1];
930       }
931       visiblecontigs.clear();
932       return vcontigs;
933     }
934     else
935     {
936       return new int[]
937       { start, end - 1 };
938     }
939   }
940
941   /**
942    * delete any columns in alignmentAnnotation that are hidden (including
943    * sequence associated annotation).
944    * 
945    * @param alignmentAnnotation
946    */
947   public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation)
948   {
949     makeVisibleAnnotation(-1, -1, alignmentAnnotation);
950   }
951
952   /**
953    * delete any columns in alignmentAnnotation that are hidden (including
954    * sequence associated annotation).
955    * 
956    * @param start
957    *          remove any annotation to the right of this column
958    * @param end
959    *          remove any annotation to the left of this column
960    * @param alignmentAnnotation
961    *          the annotation to operate on
962    */
963   public void makeVisibleAnnotation(int start, int end,
964           AlignmentAnnotation alignmentAnnotation)
965   {
966     if (alignmentAnnotation.annotations == null)
967     {
968       return;
969     }
970     if (start == end && end == -1)
971     {
972       start = 0;
973       end = alignmentAnnotation.annotations.length;
974     }
975     if (hiddenColumns != null && hiddenColumns.size() > 0)
976     {
977       // then mangle the alignmentAnnotation annotation array
978       Vector<Annotation []> annels = new Vector<Annotation []>();
979       Annotation[] els = null;
980       List<int[]> regions = getHiddenColumns();
981       int blockStart = start, blockEnd = end;
982       int[] region;
983       int hideStart, hideEnd, w = 0;
984
985       for (int j = 0; j < regions.size(); j++)
986       {
987         region = regions.get(j);
988         hideStart = region[0];
989         hideEnd = region[1];
990
991         if (hideStart < start)
992         {
993           continue;
994         }
995
996         blockStart = Math.min(blockStart, hideEnd + 1);
997         blockEnd = Math.min(blockEnd, hideStart);
998
999         if (blockStart > blockEnd)
1000         {
1001           break;
1002         }
1003
1004         annels.addElement(els = new Annotation[blockEnd - blockStart]);
1005         System.arraycopy(alignmentAnnotation.annotations, blockStart, els,
1006                 0, els.length);
1007         w += els.length;
1008         blockStart = hideEnd + 1;
1009         blockEnd = end;
1010       }
1011
1012       if (end > blockStart)
1013       {
1014         annels.addElement(els = new Annotation[end - blockStart + 1]);
1015         if ((els.length + blockStart) <= alignmentAnnotation.annotations.length)
1016         {
1017           // copy just the visible segment of the annotation row
1018           System.arraycopy(alignmentAnnotation.annotations, blockStart,
1019                   els, 0, els.length);
1020         }
1021         else
1022         {
1023           // copy to the end of the annotation row
1024           System.arraycopy(alignmentAnnotation.annotations, blockStart,
1025                   els, 0,
1026                   (alignmentAnnotation.annotations.length - blockStart));
1027         }
1028         w += els.length;
1029       }
1030       if (w == 0)
1031       {
1032         return;
1033       }
1034
1035       alignmentAnnotation.annotations = new Annotation[w];
1036       w = 0;
1037
1038         for (Annotation [] chnk : annels)
1039       {
1040         System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w,
1041                 chnk.length);
1042         w += chnk.length;
1043       }
1044     }
1045     else
1046     {
1047       alignmentAnnotation.restrict(start, end);
1048     }
1049   }
1050
1051   /**
1052    * Invert the column selection from first to end-1. leaves hiddenColumns
1053    * untouched (and unselected)
1054    * 
1055    * @param first
1056    * @param end
1057    */
1058   public void invertColumnSelection(int first, int width)
1059   {
1060     boolean hasHidden = hiddenColumns != null && hiddenColumns.size() > 0;
1061     for (int i = first; i < width; i++)
1062     {
1063       if (contains(i))
1064       {
1065         removeElement(i);
1066       }
1067       else
1068       {
1069         if (!hasHidden || isVisible(i))
1070         {
1071           addElement(i);
1072         }
1073       }
1074     }
1075   }
1076
1077   /**
1078    * add in any unselected columns from the given column selection, excluding
1079    * any that are hidden.
1080    * 
1081    * @param colsel
1082    */
1083   public void addElementsFrom(ColumnSelection colsel)
1084   {
1085     if (colsel != null && colsel.size() > 0)
1086     {
1087       for (Integer col : colsel.getSelected())
1088       {
1089         if (hiddenColumns != null && isVisible(col.intValue()))
1090         {
1091           if (!selected.contains(col))
1092           {
1093             selected.addElement(col);
1094           }
1095         }
1096       }
1097     }
1098   }
1099
1100   /**
1101    * set the selected columns the given column selection, excluding any columns
1102    * that are hidden.
1103    * 
1104    * @param colsel
1105    */
1106   public void setElementsFrom(ColumnSelection colsel)
1107   {
1108     selected = new Vector<Integer>();
1109     if (colsel.selected != null && colsel.selected.size() > 0)
1110     {
1111       if (hiddenColumns != null && hiddenColumns.size() > 0)
1112       {
1113         // only select visible columns in this columns selection
1114         addElementsFrom(colsel);
1115       }
1116       else
1117       {
1118         // add everything regardless
1119         for (Integer col : colsel.getSelected())
1120         {
1121           addElement(col);
1122         }
1123       }
1124     }
1125   }
1126
1127   /**
1128    * Add gaps into the sequences aligned to profileseq under the given
1129    * AlignmentView
1130    * 
1131    * @param profileseq
1132    * @param al
1133    *          - alignment to have gaps inserted into it
1134    * @param input
1135    *          - alignment view where sequence corresponding to profileseq is
1136    *          first entry
1137    * @return new Column selection for new alignment view, with insertions into
1138    *         profileseq marked as hidden.
1139    */
1140   public static ColumnSelection propagateInsertions(SequenceI profileseq,
1141           AlignmentI al, AlignmentView input)
1142   {
1143     int profsqpos = 0;
1144
1145     // return propagateInsertions(profileseq, al, )
1146     char gc = al.getGapCharacter();
1147     Object[] alandcolsel = input.getAlignmentAndColumnSelection(gc);
1148     ColumnSelection nview = (ColumnSelection) alandcolsel[1];
1149     SequenceI origseq = ((SequenceI[]) alandcolsel[0])[profsqpos];
1150     nview.propagateInsertions(profileseq, al, origseq);
1151     return nview;
1152   }
1153
1154   /**
1155    * 
1156    * @param profileseq
1157    *          - sequence in al which corresponds to origseq
1158    * @param al
1159    *          - alignment which is to have gaps inserted into it
1160    * @param origseq
1161    *          - sequence corresponding to profileseq which defines gap map for
1162    *          modifying al
1163    */
1164   public void propagateInsertions(SequenceI profileseq, AlignmentI al,
1165           SequenceI origseq)
1166   {
1167     char gc = al.getGapCharacter();
1168     // recover mapping between sequence's non-gap positions and positions
1169     // mapping to view.
1170     pruneDeletions(ShiftList.parseMap(origseq.gapMap()));
1171     int[] viscontigs = getVisibleContigs(0, profileseq.getLength());
1172     int spos = 0;
1173     int offset = 0;
1174     // input.pruneDeletions(ShiftList.parseMap(((SequenceI[])
1175     // alandcolsel[0])[0].gapMap()))
1176     // add profile to visible contigs
1177     for (int v = 0; v < viscontigs.length; v += 2)
1178     {
1179       if (viscontigs[v] > spos)
1180       {
1181         StringBuffer sb = new StringBuffer();
1182         for (int s = 0, ns = viscontigs[v] - spos; s < ns; s++)
1183         {
1184           sb.append(gc);
1185         }
1186         for (int s = 0, ns = al.getHeight(); s < ns; s++)
1187         {
1188           SequenceI sqobj = al.getSequenceAt(s);
1189           if (sqobj != profileseq)
1190           {
1191             String sq = al.getSequenceAt(s).getSequenceAsString();
1192             if (sq.length() <= spos + offset)
1193             {
1194               // pad sequence
1195               int diff = spos + offset - sq.length() - 1;
1196               if (diff > 0)
1197               {
1198                 // pad gaps
1199                 sq = sq + sb;
1200                 while ((diff = spos + offset - sq.length() - 1) > 0)
1201                 {
1202                   // sq = sq
1203                   // + ((diff >= sb.length()) ? sb.toString() : sb
1204                   // .substring(0, diff));
1205                   if (diff >= sb.length())
1206                   {
1207                     sq += sb.toString();
1208                   }
1209                   else
1210                   {
1211                     char[] buf = new char[diff];
1212                     sb.getChars(0, diff, buf, 0);
1213                     sq += buf.toString();
1214                   }
1215                 }
1216               }
1217               sq += sb.toString();
1218             }
1219             else
1220             {
1221               al.getSequenceAt(s).setSequence(
1222                       sq.substring(0, spos + offset) + sb.toString()
1223                               + sq.substring(spos + offset));
1224             }
1225           }
1226         }
1227         // offset+=sb.length();
1228       }
1229       spos = viscontigs[v + 1] + 1;
1230     }
1231     if ((offset + spos) < profileseq.getLength())
1232     {
1233       // pad the final region with gaps.
1234       StringBuffer sb = new StringBuffer();
1235       for (int s = 0, ns = profileseq.getLength() - spos - offset; s < ns; s++)
1236       {
1237         sb.append(gc);
1238       }
1239       for (int s = 0, ns = al.getHeight(); s < ns; s++)
1240       {
1241         SequenceI sqobj = al.getSequenceAt(s);
1242         if (sqobj == profileseq)
1243         {
1244           continue;
1245         }
1246         String sq = sqobj.getSequenceAsString();
1247         // pad sequence
1248         int diff = origseq.getLength() - sq.length();
1249         while (diff > 0)
1250         {
1251           // sq = sq
1252           // + ((diff >= sb.length()) ? sb.toString() : sb
1253           // .substring(0, diff));
1254           if (diff >= sb.length())
1255           {
1256             sq += sb.toString();
1257           }
1258           else
1259           {
1260             char[] buf = new char[diff];
1261             sb.getChars(0, diff, buf, 0);
1262             sq += buf.toString();
1263           }
1264           diff = origseq.getLength() - sq.length();
1265         }
1266       }
1267     }
1268   }
1269
1270   /**
1271    * 
1272    * @return true if there are columns marked
1273    */
1274   public boolean hasSelectedColumns()
1275   {
1276     return (selected != null && selected.size() > 0);
1277   }
1278
1279   /**
1280    * 
1281    * @return true if there are columns hidden
1282    */
1283   public boolean hasHiddenColumns()
1284   {
1285     return hiddenColumns != null && hiddenColumns.size() > 0;
1286   }
1287   
1288   /**
1289    * 
1290    * @return true if there are more than one set of columns hidden
1291    */
1292   public boolean hasManyHiddenColumns()
1293   {
1294     return hiddenColumns != null && hiddenColumns.size() > 1;
1295   }
1296
1297   /**
1298    * mark the columns corresponding to gap characters as hidden in the column
1299    * selection
1300    * 
1301    * @param sr
1302    */
1303   public void hideInsertionsFor(SequenceI sr)
1304   {
1305     List<int[]> inserts = sr.getInsertions();
1306     for (int[] r : inserts)
1307     {
1308       hideColumns(r[0], r[1]);
1309     }
1310   }
1311   
1312   public boolean filterAnnotations(Annotation[] annotations,
1313           AnnotationFilterParameter filterParams)
1314   {
1315     this.revealAllHiddenColumns();
1316     this.clear();
1317     int count = 0;
1318     do
1319     {
1320       if (annotations[count] != null)
1321       {
1322
1323         boolean itemMatched = false;
1324
1325         if (filterParams.getThresholdType() == AnnotationFilterParameter.ThresholdType.ABOVE_THRESHOLD
1326                 && annotations[count].value >= filterParams
1327                         .getThresholdValue())
1328         {
1329           itemMatched = true;
1330         }
1331         if (filterParams.getThresholdType() == AnnotationFilterParameter.ThresholdType.BELOW_THRESHOLD
1332                 && annotations[count].value <= filterParams
1333                         .getThresholdValue())
1334         {
1335           itemMatched = true;
1336         }
1337
1338         if (filterParams.isFilterAlphaHelix()
1339                 && annotations[count].secondaryStructure == 'H')
1340         {
1341           itemMatched = true;
1342         }
1343
1344         if (filterParams.isFilterBetaSheet()
1345                 && annotations[count].secondaryStructure == 'E')
1346         {
1347           itemMatched = true;
1348         }
1349
1350         if (filterParams.isFilterTurn()
1351                 && annotations[count].secondaryStructure == 'S')
1352         {
1353           itemMatched = true;
1354         }
1355
1356         String regexSearchString = filterParams.getRegexString();
1357         if (regexSearchString != null
1358                 && !filterParams.getRegexSearchFields().isEmpty())
1359         {
1360           List<SearchableAnnotationField> fields = filterParams
1361                   .getRegexSearchFields();
1362           try
1363           {
1364             if (fields.contains(SearchableAnnotationField.DISPLAY_STRING)
1365                     && annotations[count].displayCharacter
1366                             .matches(regexSearchString))
1367             {
1368               itemMatched = true;
1369             }
1370           } catch (java.util.regex.PatternSyntaxException pse)
1371           {
1372             if (annotations[count].displayCharacter
1373                     .equals(regexSearchString))
1374             {
1375               itemMatched = true;
1376             }
1377           }
1378           if (fields.contains(SearchableAnnotationField.DESCRIPTION)
1379                   && annotations[count].description != null
1380                   && annotations[count].description
1381                           .matches(regexSearchString))
1382           {
1383             itemMatched = true;
1384           }
1385         }
1386
1387         if (itemMatched)
1388         {
1389           this.addElement(count);
1390         }
1391       }
1392       count++;
1393     } while (count < annotations.length);
1394     return false;
1395   }
1396 }