X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FColumnSelection.java;h=7ef2a68d3a2aa8c1d0a59f0524b08b4a00291094;hb=5665f47f06e60c4a3c2715fde7adc02ab4c0186f;hp=6fd76b23ebf02a9366c38fecce0ee565d629edc1;hpb=6e2c975d1b0b32b54da3e2854a75dae607a4bfd3;p=jalview.git diff --git a/src/jalview/datamodel/ColumnSelection.java b/src/jalview/datamodel/ColumnSelection.java index 6fd76b2..7ef2a68 100644 --- a/src/jalview/datamodel/ColumnSelection.java +++ b/src/jalview/datamodel/ColumnSelection.java @@ -32,10 +32,14 @@ import java.util.List; import java.util.Vector; /** - * NOTE: Columns are zero based. + * Data class holding the selected columns and hidden column ranges for a view. + * Ranges are base 1. */ public class ColumnSelection { + /** + * A class to hold an efficient representation of selected columns + */ private class IntList { /* @@ -205,9 +209,26 @@ public class ColumnSelection } return rlist; } + + @Override + public int hashCode() + { + // TODO Auto-generated method stub + return selected.hashCode(); + } + + @Override + public boolean equals(Object obj) + { + if (obj instanceof IntList) + { + return ((IntList) obj).selected.equals(selected); + } + return false; + } } - IntList selected = new IntList(); + IntList selection = new IntList(); /* * list of hidden column [start, end] ranges; the list is maintained in @@ -223,7 +244,7 @@ public class ColumnSelection */ public void addElement(int col) { - selected.add(col); + selection.add(col); } /** @@ -231,7 +252,7 @@ public class ColumnSelection */ public void clear() { - selected.clear(); + selection.clear(); } /** @@ -242,7 +263,7 @@ public class ColumnSelection */ public void removeElement(int col) { - selected.remove(col); + selection.remove(col); } /** @@ -259,9 +280,9 @@ public class ColumnSelection for (int i = start; i < end; i++) { colInt = new Integer(i); - if (selected.contains(colInt)) + if (selection.contains(colInt)) { - selected.remove(colInt); + selection.remove(colInt); } } } @@ -269,11 +290,12 @@ public class ColumnSelection /** * Returns a list of selected columns. The list contains no duplicates but is * not necessarily ordered. It also may include columns hidden from the - * current view + * current view. This returns a copy of the actual list, and changes to the + * copy will not affect the selection. */ public List getSelected() { - return selected.getList(); + return new ArrayList(selection.getList()); } /** @@ -282,7 +304,7 @@ public class ColumnSelection */ public List getSelectedRanges() { - return selected.getRanges(); + return selection.getRanges(); } /** @@ -294,7 +316,7 @@ public class ColumnSelection */ public boolean contains(int col) { - return (col > -1) ? selected.isSelected(col) : false; + return (col > -1) ? selection.isSelected(col) : false; } /** @@ -302,7 +324,7 @@ public class ColumnSelection */ public boolean isEmpty() { - return selected == null || selected.isEmpty(); + return selection == null || selection.isEmpty(); } /** @@ -312,11 +334,11 @@ public class ColumnSelection */ public int getMax() { - if (selected.isEmpty()) + if (selection.isEmpty()) { return -1; } - return selected.getMaxColumn(); + return selection.getMaxColumn(); } /** @@ -326,11 +348,11 @@ public class ColumnSelection */ public int getMin() { - if (selected.isEmpty()) + if (selection.isEmpty()) { return 1000000000; } - return selected.getMinColumn(); + return selection.getMinColumn(); } /** @@ -344,7 +366,7 @@ public class ColumnSelection public List compensateForEdit(int start, int change) { List deletedHiddenColumns = null; - selected.compensateForEdits(start, change); + selection.compensateForEdits(start, change); if (hiddenColumns != null) { @@ -394,7 +416,7 @@ public class ColumnSelection private void compensateForDelEdits(int start, int change) { - selected.compensateForEdits(start, change); + selection.compensateForEdits(start, change); if (hiddenColumns != null) { @@ -571,12 +593,12 @@ public class ColumnSelection hiddenColumns = null; } } - if (selected != null && selected.size() > 0) + if (selection != null && selection.size() > 0) { - selected.pruneColumnList(shifts); - if (selected != null && selected.size() == 0) + selection.pruneColumnList(shifts); + if (selection != null && selection.size() == 0) { - selected = null; + selection = null; } } // and shift the rest. @@ -743,13 +765,13 @@ public class ColumnSelection public void hideSelectedColumns() { - synchronized (selected) + synchronized (selection) { - for (int[] selregions : selected.getRanges()) + for (int[] selregions : selection.getRanges()) { hideColumns(selregions[0], selregions[1]); } - selected.clear(); + selection.clear(); } } @@ -927,12 +949,12 @@ public class ColumnSelection { if (copy != null) { - if (copy.selected != null) + if (copy.selection != null) { - selected = new IntList(); - for (int i = 0, j = copy.selected.size(); i < j; i++) + selection = new IntList(); + for (int i = 0, j = copy.selection.size(); i < j; i++) { - selected.add(copy.selected.elementAt(i)); + selection.add(copy.selection.elementAt(i)); } } if (copy.hiddenColumns != null) @@ -964,7 +986,7 @@ public class ColumnSelection SequenceI[] seqs) { int i, iSize = seqs.length; - String selection[] = new String[iSize]; + String selections[] = new String[iSize]; if (hiddenColumns != null && hiddenColumns.size() > 0) { for (i = 0; i < iSize; i++) @@ -1006,18 +1028,18 @@ public class ColumnSelection visibleSeq.append(seqs[i].getSequence(blockStart, end)); } - selection[i] = visibleSeq.toString(); + selections[i] = visibleSeq.toString(); } } else { for (i = 0; i < iSize; i++) { - selection[i] = seqs[i].getSequenceAsString(start, end); + selections[i] = seqs[i].getSequenceAsString(start, end); } } - return selection; + return selections; } /** @@ -1307,7 +1329,7 @@ public class ColumnSelection { if (hiddenColumns != null && isVisible(col.intValue())) { - selected.add(col); + selection.add(col); } } } @@ -1321,8 +1343,8 @@ public class ColumnSelection */ public void setElementsFrom(ColumnSelection colsel) { - selected = new IntList(); - if (colsel.selected != null && colsel.selected.size() > 0) + selection = new IntList(); + if (colsel.selection != null && colsel.selection.size() > 0) { if (hiddenColumns != null && hiddenColumns.size() > 0) { @@ -1489,7 +1511,7 @@ public class ColumnSelection */ public boolean hasSelectedColumns() { - return (selected != null && selected.size() > 0); + return (selection != null && selection.size() > 0); } /** @@ -1612,4 +1634,148 @@ public class ColumnSelection return false; } + /** + * Returns a hashCode built from selected columns and hidden column ranges + */ + @Override + public int hashCode() + { + int hashCode = selection.hashCode(); + if (hiddenColumns != null) + { + for (int[] hidden : hiddenColumns) + { + hashCode = 31 * hashCode + hidden[0]; + hashCode = 31 * hashCode + hidden[1]; + } + } + return hashCode; + } + + /** + * Answers true if comparing to a ColumnSelection with the same selected + * columns and hidden columns, else false + */ + @Override + public boolean equals(Object obj) + { + if (!(obj instanceof ColumnSelection)) + { + return false; + } + ColumnSelection that = (ColumnSelection) obj; + + /* + * check columns selected are either both null, or match + */ + if (this.selection == null) + { + if (that.selection != null) + { + return false; + } + } + if (!this.selection.equals(that.selection)) + { + return false; + } + + /* + * check hidden columns are either both null, or match + */ + if (this.hiddenColumns == null) + { + return (that.hiddenColumns == null); + } + if (that.hiddenColumns == null + || that.hiddenColumns.size() != this.hiddenColumns.size()) + { + return false; + } + int i = 0; + for (int[] thisRange : hiddenColumns) + { + int[] thatRange = that.hiddenColumns.get(i++); + if (thisRange[0] != thatRange[0] || thisRange[1] != thatRange[1]) + { + return false; + } + } + return true; + } + + /** + * Updates the column selection depending on the parameters, and returns true + * if any change was made to the selection + * + * @param markedColumns + * a set identifying marked columns (base 0) + * @param startCol + * the first column of the range to operate over (base 0) + * @param endCol + * the last column of the range to operate over (base 0) + * @param invert + * if true, deselect marked columns and select unmarked + * @param extendCurrent + * if true, extend rather than replacing the current column selection + * @param toggle + * if true, toggle the selection state of marked columns + * + * @return + */ + public boolean markColumns(BitSet markedColumns, int startCol, + int endCol, boolean invert, boolean extendCurrent, boolean toggle) + { + boolean changed = false; + if (!extendCurrent && !toggle) + { + changed = !this.isEmpty(); + clear(); + } + if (invert) + { + // invert only in the currently selected sequence region + int i = markedColumns.nextClearBit(startCol); + int ibs = markedColumns.nextSetBit(startCol); + while (i >= startCol && i <= endCol) + { + if (ibs < 0 || i < ibs) + { + changed = true; + if (toggle && contains(i)) + { + removeElement(i++); + } + else + { + addElement(i++); + } + } + else + { + i = markedColumns.nextClearBit(ibs); + ibs = markedColumns.nextSetBit(i); + } + } + } + else + { + int i = markedColumns.nextSetBit(startCol); + while (i >= startCol && i <= endCol) + { + changed = true; + if (toggle && contains(i)) + { + removeElement(i); + } + else + { + addElement(i); + } + i = markedColumns.nextSetBit(i + 1); + } + } + return changed; + } + }