if (viewport.hasHiddenColumns() && viewport.getSelectionGroup() != null)
{
- copiedHiddenColumns = viewport.getAlignment().getHiddenColumns()
- .getHiddenColumnsCopy();
+ copiedHiddenColumns = new Vector<>(viewport.getAlignment()
+ .getHiddenColumns().getHiddenColumnsCopy());
int hiddenOffset = viewport.getSelectionGroup().getStartRes();
for (int[] region : copiedHiddenColumns)
{
.getOldHiddenColumns();
if (oldHidden != null)
{
- ArrayList<int[]> regions = oldHidden.getHiddenColumnsCopyAsList();
+ ArrayList<int[]> regions = oldHidden.getHiddenColumnsCopy();
for (int[] positions : regions)
{
av.hideColumns(positions[0], positions[1]);
import java.awt.event.MouseMotionListener;
import java.util.Arrays;
import java.util.Collections;
+import java.util.Vector;
public class AnnotationLabels extends Panel implements ActionListener,
MouseListener, MouseMotionListener
+ sq.getSequenceAsString() + "\n");
if (av.hasHiddenColumns())
{
- jalview.appletgui.AlignFrame.copiedHiddenColumns = av.getAlignment()
- .getHiddenColumns().getHiddenColumnsCopy();
+ jalview.appletgui.AlignFrame.copiedHiddenColumns = new Vector<>(
+ av.getAlignment().getHiddenColumns()
+ .getHiddenColumnsCopy());
}
}
if (av.hasHiddenColumns())
{
HiddenColumns hidden = av.getAlignment().getHiddenColumns();
- for (int[] region : hidden.getHiddenColumnsCopyAsList())
+ for (int[] region : hidden.getHiddenColumnsCopy())
{
int hideStart = region[0];
int hideEnd = region[1];
{
this(constructSeqCigarArray(alignment, selectionGroup));
constructFromAlignment(alignment,
- hidden != null ? hidden.getHiddenColumnsCopyAsList()
+ hidden != null ? hidden.getHiddenColumnsCopy()
: null, selectionGroup);
}
* list of hidden column [start, end] ranges; the list is maintained in
* ascending start column order
*/
- private Vector<int[]> hiddenColumns;
+ private ArrayList<int[]> hiddenColumns;
/**
- * This Method is used to return all the HiddenColumn regions
+ * Constructor
+ */
+ public HiddenColumns()
+ {
+ }
+
+ /**
+ * Copy constructor
+ *
+ * @param copy
+ */
+ public HiddenColumns(HiddenColumns copy)
+ {
+ try
+ {
+
+ LOCK.readLock().lock();
+ if (copy != null)
+ {
+ if (copy.hiddenColumns != null)
+ {
+ hiddenColumns = copy.copyHiddenRegionsToArrayList();
+ }
+ }
+ } finally
+ {
+ LOCK.readLock().unlock();
+ }
+ }
+
+ /**
+ * This method is used to return all the HiddenColumn regions and is intended
+ * to remain private. External callers which need a copy of the regions can
+ * call getHiddenColumnsCopyAsList.
*
* @return empty list or List of hidden column intervals
*/
{
for (int i = 0; i < hiddenColumns.size(); i++)
{
- int[] region = hiddenColumns.elementAt(i);
+ int[] region = hiddenColumns.get(i);
if (result >= region[0])
{
result += region[1] - region[0] + 1;
int[] region;
do
{
- region = hiddenColumns.elementAt(index++);
+ region = hiddenColumns.get(index++);
if (hiddenColumn > region[1])
{
result -= region[1] + 1 - region[0];
{
positions = new ArrayList<>(hiddenColumns.size());
- positions.add(hiddenColumns.elementAt(0)[0]);
+ positions.add(hiddenColumns.get(0)[0]);
for (int i = 1; i < hiddenColumns.size(); ++i)
{
int gaps = 0;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
gaps += region[1] + 1 - region[0];
result = region[1] + 1;
index++;
int index = 0;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
if (alPos < region[0])
{
return region[0];
int index = hiddenColumns.size() - 1;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
if (alPos > region[1])
{
return region[1];
int index = hiddenColumns.size() - 1;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
if (pos > region[1])
{
return index;
if (hiddenColumns == null)
{
- hiddenColumns = new Vector<>();
+ hiddenColumns = new ArrayList<>();
}
/*
*/
for (int i = 0; i < hiddenColumns.size(); i++)
{
- int[] region = hiddenColumns.elementAt(i);
+ int[] region = hiddenColumns.get(i);
if (end < region[0] - 1)
{
/*
* insert discontiguous preceding range
*/
- hiddenColumns.insertElementAt(new int[] { start, end }, i);
+ hiddenColumns.add(i, new int[] { start, end });
return;
}
/*
* remaining case is that the new range follows everything else
*/
- hiddenColumns.addElement(new int[] { start, end });
+ hiddenColumns.add(new int[] { start, end });
} finally
{
if (!alreadyLocked)
}
}
- /**
- * ColumnSelection
- */
- public HiddenColumns()
- {
- }
-
- /**
- * Copy constructor
- *
- * @param copy
- */
- public HiddenColumns(HiddenColumns copy)
- {
- try
- {
-
- LOCK.readLock().lock();
- if (copy != null)
- {
- if (copy.hiddenColumns != null)
- {
- hiddenColumns = copy.copyHiddenRegions();
- }
- }
- }
- finally
- {
- LOCK.readLock().unlock();
- }
- }
-
- private Vector<int[]> copyHiddenRegions()
- {
- Vector<int[]> copy = new Vector<>(hiddenColumns.size());
- for (int i = 0, j = hiddenColumns.size(); i < j; i++)
- {
- int[] rh;
- int[] cp;
- rh = hiddenColumns.elementAt(i);
- if (rh != null)
- {
- cp = new int[rh.length];
- System.arraycopy(rh, 0, cp, 0, rh.length);
- copy.addElement(cp);
- }
- }
- return copy;
- }
-
private ArrayList<int[]> copyHiddenRegionsToArrayList()
{
int size = 0;
{
int[] rh;
int[] cp;
- rh = hiddenColumns.elementAt(i);
+ rh = hiddenColumns.get(i);
if (rh != null)
{
cp = new int[rh.length];
return copy;
}
-
- /**
- * Returns a copy of the vector of hidden regions, as a vector. Before using
- * this method please consider if you really need access to the hidden regions
- * - a new (or existing!) method on HiddenColumns might be more appropriate.
- *
- * @return hidden regions as vector of [start,end] pairs
- */
- public Vector<int[]> getHiddenColumnsCopy()
- {
- try
- {
- LOCK.readLock().lock();
- return copyHiddenRegions();
- } finally
- {
- LOCK.readLock().unlock();
- }
- }
-
+
/**
* Returns a copy of the vector of hidden regions, as an ArrayList. Before
* using this method please consider if you really need access to the hidden
*
* @return hidden regions as an ArrayList of [start,end] pairs
*/
- public ArrayList<int[]> getHiddenColumnsCopyAsList()
+ public ArrayList<int[]> getHiddenColumnsCopy()
{
try
{
int hSize = hiddenColumns.size();
for (int i = 0; i < hSize; i++)
{
- int[] region = hiddenColumns.elementAt(i);
+ int[] region = hiddenColumns.get(i);
if (region[0] > start && start + change > region[1])
{
deletedHiddenColumns.add(region);
- hiddenColumns.removeElementAt(i);
+ hiddenColumns.remove(i);
i--;
hSize--;
continue;
{
for (int i = 0; i < hiddenColumns.size(); i++)
{
- int[] region = hiddenColumns.elementAt(i);
+ int[] region = hiddenColumns.get(i);
if (region[0] >= start)
{
region[0] -= change;
}
if (region[1] < region[0])
{
- hiddenColumns.removeElementAt(i--);
+ hiddenColumns.remove(i--);
}
if (region[0] < 0)
{
LOCK.readLock().lock();
int iSize = seqs.length;
- String selections[] = new String[iSize];
+ String[] selections = new String[iSize];
if (hiddenColumns != null && hiddenColumns.size() > 0)
{
for (int i = 0; i < iSize; i++)
{
for (int i = 0; i < hiddenColumns.size(); i++)
{
- int[] region = hiddenColumns.elementAt(i);
+ int[] region = hiddenColumns.get(i);
for (int j = region[0]; j < region[1] + 1; j++)
{
sel.addElement(j);
LOCK.writeLock().lock();
for (int i = 0; i < hiddenColumns.size(); i++)
{
- int[] region = hiddenColumns.elementAt(i);
+ int[] region = hiddenColumns.get(i);
if (start == region[0])
{
for (int j = region[0]; j < region[1] + 1; j++)
sel.addElement(j);
}
- hiddenColumns.removeElement(region);
+ hiddenColumns.remove(region);
break;
}
}
* @param intervals
* @return
*/
- private boolean pruneIntervalVector(final List<int[]> shifts,
- Vector<int[]> intervals)
+ private boolean pruneIntervalList(final List<int[]> shifts,
+ ArrayList<int[]> intervals)
{
boolean pruned = false;
int i = 0;
int j = intervals.size() - 1;
int s = 0;
int t = shifts.size() - 1;
- int hr[] = intervals.elementAt(i);
- int sr[] = shifts.get(s);
+ int[] hr = intervals.get(i);
+ int[] sr = shifts.get(s);
while (i <= j && s <= t)
{
boolean trailinghn = hr[1] >= sr[0];
{
if (i < j)
{
- hr = intervals.elementAt(++i);
+ hr = intervals.get(++i);
}
else
{
{
if (trailinghc)
{ // deleted hidden region.
- intervals.removeElementAt(i);
+ intervals.remove(i);
pruned = true;
j--;
if (i <= j)
{
- hr = intervals.elementAt(i);
+ hr = intervals.get(i);
}
continue;
}
// delete any intervals intersecting.
if (hiddenColumns != null)
{
- pruneIntervalVector(shifts, hiddenColumns);
+ pruneIntervalList(shifts, hiddenColumns);
if (hiddenColumns != null && hiddenColumns.size() == 0)
{
hiddenColumns = null;
last = lastcol;
current = firstcol;
next = firstcol;
- hidden = hiddenCols.getHiddenColumnsCopyAsList();
+ hidden = hiddenCols.getHiddenColumnsCopy();
lasthiddenregion = -1;
if (hidden != null)
int hiddenOffset = viewport.getSelectionGroup().getStartRes();
int hiddenCutoff = viewport.getSelectionGroup().getEndRes();
ArrayList<int[]> hiddenRegions = viewport.getAlignment()
- .getHiddenColumns().getHiddenColumnsCopyAsList();
+ .getHiddenColumns().getHiddenColumnsCopy();
for (int[] region : hiddenRegions)
{
if (region[0] >= hiddenOffset && region[1] <= hiddenCutoff)
.getOldHiddenColumns();
if (oldHidden != null)
{
- ArrayList<int[]> regions = oldHidden.getHiddenColumnsCopyAsList();
+ ArrayList<int[]> regions = oldHidden.getHiddenColumnsCopy();
for (int[] positions : regions)
{
av.hideColumns(positions[0], positions[1]);
if (av.hasHiddenColumns())
{
hiddenColumns = av.getAlignment().getHiddenColumns()
- .getHiddenColumnsCopyAsList();
+ .getHiddenColumnsCopy();
}
Desktop.jalviewClipboard = new Object[] { seqs, ds, // what is the dataset
else
{
ArrayList<int[]> hiddenRegions = hidden
- .getHiddenColumnsCopyAsList();
+ .getHiddenColumnsCopy();
for (int[] region : hiddenRegions)
{
HiddenColumns hc = new HiddenColumns();
int blockEnd = endRes;
for (int[] region : av.getAlignment().getHiddenColumns()
- .getHiddenColumnsCopyAsList())
+ .getHiddenColumnsCopy())
{
int hideStart = region[0];
int hideEnd = region[1];
toSequences, fromGapChar);
}
- for (int[] hidden : hiddencols.getHiddenColumnsCopyAsList())
+ for (int[] hidden : hiddencols.getHiddenColumnsCopy())
{
mapHiddenColumns(hidden, codonFrames, newHidden, fromSequences,
toSequences, fromGapChar);
// hide column 5 (and adjacent):
cs.hideSelectedColumns(5, al.getHiddenColumns());
// 4,5,6 now hidden:
- List<int[]> hidden = al.getHiddenColumns().getHiddenColumnsCopyAsList();
+ List<int[]> hidden = al.getHiddenColumns().getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
// none now selected:
cs.addElement(5);
cs.addElement(6);
cs.hideSelectedColumns(4, al.getHiddenColumns());
- hidden = al.getHiddenColumns().getHiddenColumnsCopyAsList();
+ hidden = al.getHiddenColumns().getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
assertTrue(cs.getSelected().isEmpty());
cs.addElement(5);
cs.addElement(6);
cs.hideSelectedColumns(6, al.getHiddenColumns());
- hidden = al.getHiddenColumns().getHiddenColumnsCopyAsList();
+ hidden = al.getHiddenColumns().getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
assertTrue(cs.getSelected().isEmpty());
cs.addElement(4);
cs.addElement(6);
cs.hideSelectedColumns(5, al.getHiddenColumns());
- hidden = al.getHiddenColumns().getHiddenColumnsCopyAsList();
+ hidden = al.getHiddenColumns().getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
assertTrue(cs.getSelected().isEmpty());
cs.hideSelectedColumns(al);
assertTrue(cs.getSelected().isEmpty());
- List<int[]> hidden = cols.getHiddenColumnsCopyAsList();
+ List<int[]> hidden = cols.getHiddenColumnsCopy();
assertEquals(4, hidden.size());
assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
assertEquals("[7, 9]", Arrays.toString(hidden.get(1)));
cs.hideColumns(10, 11);
cs.hideColumns(5, 7);
assertEquals("[5, 7]",
- Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
+ Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
HiddenColumns cs2 = new HiddenColumns(cs);
assertTrue(cs2.hasHiddenColumns());
- assertEquals(2, cs2.getHiddenColumnsCopyAsList().size());
+ assertEquals(2, cs2.getHiddenColumnsCopy().size());
// hidden columns are held in column order
assertEquals("[5, 7]",
- Arrays.toString(cs2.getHiddenColumnsCopyAsList().get(0)));
+ Arrays.toString(cs2.getHiddenColumnsCopy().get(0)));
assertEquals("[10, 11]",
- Arrays.toString(cs2.getHiddenColumnsCopyAsList().get(1)));
+ Arrays.toString(cs2.getHiddenColumnsCopy().get(1)));
}
/**
ColumnSelection colsel = new ColumnSelection();
HiddenColumns cs = al.getHiddenColumns();
colsel.hideSelectedColumns(5, al.getHiddenColumns());
- List<int[]> hidden = cs.getHiddenColumnsCopyAsList();
+ List<int[]> hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
colsel.hideSelectedColumns(3, al.getHiddenColumns());
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(2, hidden.size());
// two hidden ranges, in order:
- assertEquals(hidden.size(), cs.getHiddenColumnsCopyAsList().size());
+ assertEquals(hidden.size(), cs.getHiddenColumnsCopy().size());
assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
// hiding column 4 expands [3, 3] to [3, 4]
// and merges to [5, 5] to make [3, 5]
colsel.hideSelectedColumns(4, al.getHiddenColumns());
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
// clear hidden columns (note they are added to selected)
cs.revealAllHiddenColumns(colsel);
// it is now actually null but getter returns an empty list
- assertTrue(cs.getHiddenColumnsCopyAsList().isEmpty());
+ assertTrue(cs.getHiddenColumnsCopy().isEmpty());
cs.hideColumns(3, 6);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
int[] firstHiddenRange = hidden.get(0);
assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
// adding a subrange of already hidden should do nothing
cs.hideColumns(4, 5);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[3, 6]",
- Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
+ Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
cs.hideColumns(3, 5);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[3, 6]",
- Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
+ Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
cs.hideColumns(4, 6);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[3, 6]",
- Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
+ Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
cs.hideColumns(3, 6);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[3, 6]",
- Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
+ Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
cs.revealAllHiddenColumns(colsel);
cs.hideColumns(2, 4);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
// extend contiguous with 2 positions overlap
cs.hideColumns(3, 5);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
// extend contiguous with 1 position overlap
cs.hideColumns(5, 6);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
// extend contiguous with overlap both ends:
cs.hideColumns(1, 7);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
}
colsel.addElement(10);
cs.revealHiddenColumns(5, colsel);
// hidden columns list now null but getter returns empty list:
- assertTrue(cs.getHiddenColumnsCopyAsList().isEmpty());
+ assertTrue(cs.getHiddenColumnsCopy().isEmpty());
// revealed columns are marked as selected (added to selection):
assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
colsel = new ColumnSelection();
cs = new HiddenColumns();
cs.hideColumns(5, 8);
- List<int[]> hidden = cs.getHiddenColumnsCopyAsList();
+ List<int[]> hidden = cs.getHiddenColumnsCopy();
cs.revealHiddenColumns(6, colsel);
- assertEquals(hidden.size(), cs.getHiddenColumnsCopyAsList().size());
+ assertEquals(hidden.size(), cs.getHiddenColumnsCopy().size());
assertTrue(colsel.getSelected().isEmpty());
}
* revealing hidden columns adds them (in order) to the (unordered)
* selection list
*/
- assertTrue(cs.getHiddenColumnsCopyAsList().isEmpty());
+ assertTrue(cs.getHiddenColumnsCopy().isEmpty());
assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", colsel.getSelected()
.toString());
}
HiddenColumns cs = new HiddenColumns();
cs.hideColumns(49, 59);
cs.hideColumns(69, 79);
- List<int[]> hidden = cs.getHiddenColumnsCopyAsList();
+ List<int[]> hidden = cs.getHiddenColumnsCopy();
assertEquals(2, hidden.size());
assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
cs.hideColumns(48, 80);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
cs.hideColumns(50, 60);
// hiding 21-49 should merge to one range
cs.hideColumns(21, 49);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
cs.hideColumns(60, 70);
cs.hideColumns(15, 45);
- hidden = cs.getHiddenColumnsCopyAsList();
+ hidden = cs.getHiddenColumnsCopy();
assertEquals(2, hidden.size());
assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));
one.set(1);
cs = new HiddenColumns();
cs.hideMarkedBits(one);
- assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
+ assertEquals(1, cs.getHiddenColumnsCopy().size());
one.set(2);
cs = new HiddenColumns();
cs.hideMarkedBits(one);
- assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
+ assertEquals(1, cs.getHiddenColumnsCopy().size());
one.set(3);
cs = new HiddenColumns();
cs.hideMarkedBits(one);
- assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
+ assertEquals(1, cs.getHiddenColumnsCopy().size());
// split
one.clear(2);
cs = new HiddenColumns();
cs.hideMarkedBits(one);
- assertEquals(2, cs.getHiddenColumnsCopyAsList().size());
+ assertEquals(2, cs.getHiddenColumnsCopy().size());
assertEquals(0, cs.adjustForHiddenColumns(0));
assertEquals(2, cs.adjustForHiddenColumns(1));
cs = new HiddenColumns();
cs.hideMarkedBits(one);
- assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
+ assertEquals(1, cs.getHiddenColumnsCopy().size());
assertEquals(0, cs.adjustForHiddenColumns(0));
assertEquals(1, cs.adjustForHiddenColumns(1));
assertFalse(alignFrame.hideFeatureColumns("exon", true));
assertTrue(alignFrame.getViewport().getColumnSelection().isEmpty());
assertTrue(alignFrame.getViewport().getAlignment().getHiddenColumns()
- .getHiddenColumnsCopyAsList()
+ .getHiddenColumnsCopy()
.isEmpty());
assertFalse(alignFrame.hideFeatureColumns("exon", false));
assertTrue(alignFrame.getViewport().getColumnSelection().isEmpty());
assertTrue(alignFrame.getViewport().getAlignment().getHiddenColumns()
- .getHiddenColumnsCopyAsList()
+ .getHiddenColumnsCopy()
.isEmpty());
/*
assertTrue(alignFrame.getViewport().getColumnSelection().isEmpty());
List<int[]> hidden = alignFrame.getViewport().getAlignment()
.getHiddenColumns()
- .getHiddenColumnsCopyAsList();
+ .getHiddenColumnsCopy();
assertTrue(hidden.isEmpty());
/*
*/
assertTrue(alignFrame.hideFeatureColumns("Turn", true));
hidden = alignFrame.getViewport().getAlignment().getHiddenColumns()
- .getHiddenColumnsCopyAsList();
+ .getHiddenColumnsCopy();
assertEquals(hidden.size(), 2);
assertEquals(hidden.get(0)[0], 1);
assertEquals(hidden.get(0)[1], 3);
TEST_SEQ_HEIGHT = expectedSeqs.size();
TEST_GRP_HEIGHT = expectedGrps.size();
TEST_ANOT_HEIGHT = expectedAnnots.size();
- TEST_CS_HEIGHT = expectedColSel.getHiddenColumnsCopyAsList().size();
+ TEST_CS_HEIGHT = expectedColSel.getHiddenColumnsCopy().size();
exportSettings = new AlignExportSettingI()
{
{
HiddenColumns cs = testJsonFile.getHiddenColumns();
Assert.assertNotNull(cs);
- Assert.assertNotNull(cs.getHiddenColumnsCopyAsList());
- List<int[]> hiddenCols = cs.getHiddenColumnsCopyAsList();
+ Assert.assertNotNull(cs.getHiddenColumnsCopy());
+ List<int[]> hiddenCols = cs.getHiddenColumnsCopy();
Assert.assertEquals(hiddenCols.size(), TEST_CS_HEIGHT);
Assert.assertEquals(hiddenCols.get(0), expectedColSel
- .getHiddenColumnsCopyAsList().get(0),
+ .getHiddenColumnsCopy().get(0),
"Mismatched hidden columns!");
}
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols,
proteinView, dnaView, dnaSelection, dnaHidden);
assertEquals("[]", dnaSelection.getSelected().toString());
- List<int[]> hidden = dnaHidden.getHiddenColumnsCopyAsList();
+ List<int[]> hidden = dnaHidden.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[0, 4]", Arrays.toString(hidden.get(0)));
proteinSelection.hideSelectedColumns(1, hiddenCols);
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols,
proteinView, dnaView, dnaSelection, dnaHidden);
- hidden = dnaHidden.getHiddenColumnsCopyAsList();
+ hidden = dnaHidden.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[0, 3]", Arrays.toString(hidden.get(0)));
proteinSelection.hideSelectedColumns(2, hiddenCols);
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols,
proteinView, dnaView, dnaSelection, dnaHidden);
- assertTrue(dnaHidden.getHiddenColumnsCopyAsList().isEmpty());
+ assertTrue(dnaHidden.getHiddenColumnsCopy().isEmpty());
/*
* Column 3 in protein picks up Seq1/P, Seq2/Q, Seq3/S which map to columns
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols,
proteinView, dnaView, dnaSelection, dnaHidden);
assertEquals("[0, 1, 2, 3]", dnaSelection.getSelected().toString());
- hidden = dnaHidden.getHiddenColumnsCopyAsList();
+ hidden = dnaHidden.getHiddenColumnsCopy();
assertEquals(1, hidden.size());
assertEquals("[5, 10]", Arrays.toString(hidden.get(0)));
proteinSelection.hideSelectedColumns(3, hiddenCols);
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols,
proteinView, dnaView, dnaSelection, dnaHidden);
- hidden = dnaHidden.getHiddenColumnsCopyAsList();
+ hidden = dnaHidden.getHiddenColumnsCopy();
assertEquals(2, hidden.size());
assertEquals("[0, 3]", Arrays.toString(hidden.get(0)));
assertEquals("[5, 10]", Arrays.toString(hidden.get(1)));
git://source.jalview.org / jalview.git / commitdiff