JAL-3949 fixed failing commandlinetests due to more output and line count limit
[jalview.git] / src / jalview / datamodel / HiddenColumnsCursor.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
26 public class HiddenColumnsCursor
27 {
28   // absolute position of first hidden column
29   private int firstColumn;
30
31   private List<int[]> hiddenColumns = new ArrayList<>();
32
33   private HiddenCursorPosition cursorPos = new HiddenCursorPosition(0, 0);
34
35   protected HiddenColumnsCursor()
36   {
37
38   }
39
40   protected HiddenColumnsCursor(List<int[]> hiddenCols)
41   {
42     resetCursor(hiddenCols, 0, 0);
43   }
44
45   protected HiddenColumnsCursor(List<int[]> hiddenCols, int index,
46           int hiddencount)
47   {
48     resetCursor(hiddenCols, index, hiddencount);
49   }
50
51   /**
52    * Reset the cursor with a new hidden columns collection, where we know in
53    * advance the index and hidden columns count of a particular location.
54    * 
55    * @param hiddenCols
56    *          new hidden columns collection
57    * @param index
58    *          cursor index to reset to
59    * @param hiddencount
60    *          hidden columns count to reset to
61    */
62   private void resetCursor(List<int[]> hiddenCols, int index,
63           int hiddencount)
64   {
65     hiddenColumns = hiddenCols;
66     if (!hiddenCols.isEmpty())
67     {
68       firstColumn = hiddenColumns.get(0)[0];
69       cursorPos = new HiddenCursorPosition(index,
70               hiddencount);
71     }
72   }
73
74   /**
75    * Get the cursor pointing to the hidden region that column is within (if
76    * column is hidden) or which is to the right of column (if column is
77    * visible). If no hidden columns are to the right, returns a cursor pointing
78    * to an imaginary hidden region beyond the end of the hidden columns
79    * collection (this ensures the count of previous hidden columns is correct).
80    * If hidden columns is empty returns null.
81    * 
82    * @param column
83    *          index of column in visible or absolute coordinates
84    * @param useVisible
85    *          true if column is in visible coordinates, false if absolute
86    * @return cursor pointing to hidden region containing the column (if hidden)
87    *         or to the right of the column (if visible)
88    */
89   protected HiddenCursorPosition findRegionForColumn(int column,
90           boolean useVisible)
91   {
92     if (hiddenColumns.isEmpty())
93     {
94       return null;
95     }
96
97     // used to add in hiddenColumns offset when working with visible columns
98     int offset = (useVisible ? 1 : 0);
99
100     HiddenCursorPosition pos = cursorPos;
101     int index = pos.getRegionIndex();
102     int hiddenCount = pos.getHiddenSoFar();
103
104     if (column < firstColumn)
105     {
106       pos = new HiddenCursorPosition(0, 0);
107     }
108
109     // column is after current region
110     else if ((index < hiddenColumns.size())
111             && (hiddenColumns.get(index)[0] <= column
112                     + offset * hiddenCount))
113     {
114       // iterate from where we are now, if we're lucky we'll be close by
115       // (but still better than iterating from 0)
116       // stop when we find the region *before* column
117       // i.e. the next region starts after column or if not, ends after column
118       pos = searchForward(pos, column, useVisible);
119     }
120
121     // column is before current region
122     else
123     {
124       pos = searchBackward(pos, column, useVisible);
125     }
126     cursorPos = pos;
127     return pos;
128   }
129
130   /**
131    * Search forwards through the hidden columns collection to find the hidden
132    * region immediately before a column
133    * 
134    * @param pos
135    *          current position
136    * @param column
137    *          column to locate
138    * @param useVisible
139    *          whether using visible or absolute coordinates
140    * @return position of region before column
141    */
142   private HiddenCursorPosition searchForward(HiddenCursorPosition pos,
143           int column, boolean useVisible)
144   {
145     HiddenCursorPosition p = pos;
146     if (useVisible)
147     {
148       while ((p.getRegionIndex() < hiddenColumns.size())
149               && hiddenColumns.get(p.getRegionIndex())[0] <= column
150                       + p.getHiddenSoFar())
151       {
152         p = stepForward(p);
153       }
154     }
155     else
156     {
157       while ((p.getRegionIndex() < hiddenColumns.size())
158               && hiddenColumns.get(p.getRegionIndex())[1] < column)
159       {
160         p = stepForward(p);
161       }
162     }
163     return p;
164   }
165
166   /**
167    * Move to the next (rightwards) hidden region after a given cursor position
168    * 
169    * @param p
170    *          current position of cursor
171    * @return new position of cursor at next region
172    */
173   private HiddenCursorPosition stepForward(HiddenCursorPosition p)
174   {
175     int[] region = hiddenColumns.get(p.getRegionIndex());
176
177     // increment the index, and add this region's hidden columns to the hidden
178     // column count
179     return new HiddenCursorPosition(p.getRegionIndex() + 1,
180             p.getHiddenSoFar() + region[1] - region[0] + 1);
181   }
182
183   /**
184    * Search backwards through the hidden columns collection to find the hidden
185    * region immediately before (left of) a given column
186    * 
187    * @param pos
188    *          current position
189    * @param column
190    *          column to locate
191    * @param useVisible
192    *          whether using visible or absolute coordinates
193    * @return position of region immediately to left of column
194    */
195   private HiddenCursorPosition searchBackward(HiddenCursorPosition p,
196           int column, boolean useVisible)
197   {
198     int i = p.getRegionIndex();
199     int h = p.getHiddenSoFar();
200
201     // used to add in hiddenColumns offset when working with visible columns
202     int offset = (useVisible ? 1 : 0);
203
204     while ((i > 0) && (hiddenColumns.get(i - 1)[1] >= column + offset * h))
205     {
206       i--;
207       int[] region = hiddenColumns.get(i);
208       h -= region[1] - region[0] + 1;
209     }
210     return new HiddenCursorPosition(i, h);
211   }
212
213 }