X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FColumnSelection.java;h=eb2d1749ee6ea399f494174c91848eb9748dd783;hb=136c0793b90b72b928c4d77dc109dd5c644e00d3;hp=3916b7da1d63eae433861631937690eec9fba4c8;hpb=6dd554fdbf34db6b79595d5027159d20225f4894;p=jalview.git diff --git a/src/jalview/datamodel/ColumnSelection.java b/src/jalview/datamodel/ColumnSelection.java index 3916b7d..eb2d174 100644 --- a/src/jalview/datamodel/ColumnSelection.java +++ b/src/jalview/datamodel/ColumnSelection.java @@ -20,1033 +20,458 @@ */ package jalview.datamodel; -import jalview.util.ShiftList; import jalview.viewmodel.annotationfilter.AnnotationFilterParameter; import jalview.viewmodel.annotationfilter.AnnotationFilterParameter.SearchableAnnotationField; import java.util.ArrayList; +import java.util.BitSet; import java.util.Collections; 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 { - Vector selected = new Vector(); - - // Vector of int [] {startCol, endCol} - Vector hiddenColumns; - /** - * Add a column to the selection - * - * @param col - * index of column + * A class to hold an efficient representation of selected columns */ - public void addElement(int col) + private class IntList { - Integer column = new Integer(col); - if (!selected.contains(column)) - { - selected.addElement(column); - } - } + /* + * list of selected columns (ordered by selection order, not column order) + */ + private List order; - /** - * clears column selection - */ - public void clear() - { - selected.removeAllElements(); - } + /* + * an unmodifiable view of the selected columns list + */ + private List _uorder; - /** - * Removes value 'col' from the selection (not the col'th item) - * - * @param col - * index of column to be removed - */ - public void removeElement(int col) - { - Integer colInt = new Integer(col); + /** + * bitfield for column selection - allows quick lookup + */ + private BitSet selected; - if (selected.contains(colInt)) + /** + * Constructor + */ + IntList() { - // if this ever changes to List.remove(), ensure Integer not int argument - // as List.remove(int i) removes the i'th item which is wrong - selected.removeElement(colInt); + order = new ArrayList(); + _uorder = Collections.unmodifiableList(order); + selected = new BitSet(); } - } - /** - * removes a range of columns from the selection - * - * @param start - * int - first column in range to be removed - * @param end - * int - last col - */ - public void removeElements(int start, int end) - { - Integer colInt; - for (int i = start; i < end; i++) + /** + * Copy constructor + * + * @param other + */ + IntList(IntList other) { - colInt = new Integer(i); - if (selected.contains(colInt)) + this(); + if (other != null) { - selected.removeElement(colInt); + int j = other.size(); + for (int i = 0; i < j; i++) + { + add(other.elementAt(i)); + } } } - } - - /** - * - * @return Vector containing selected columns as Integers - */ - public Vector getSelected() - { - return selected; - } - /** - * - * @param col - * index to search for in column selection - * - * @return true if Integer(col) is in selection. - */ - public boolean contains(int col) - { - return selected.contains(new Integer(col)); - } - - /** - * Column number at position i in selection - * - * @param i - * index into selected columns - * - * @return column number in alignment - */ - public int columnAt(int i) - { - return selected.elementAt(i).intValue(); - } - - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public int size() - { - return selected.size(); - } - - /** - * rightmost selected column - * - * @return rightmost column in alignment that is selected - */ - public int getMax() - { - int max = -1; - - for (int i = 0; i < selected.size(); i++) + /** + * adds a new column i to the selection - only if i is not already selected + * + * @param i + */ + void add(int i) { - if (columnAt(i) > max) + if (!selected.get(i)) { - max = columnAt(i); + order.add(Integer.valueOf(i)); + selected.set(i); } } - return max; - } - - /** - * Leftmost column in selection - * - * @return column index of leftmost column in selection - */ - public int getMin() - { - int min = 1000000000; - - for (int i = 0; i < selected.size(); i++) + void clear() { - if (columnAt(i) < min) - { - min = columnAt(i); - } + order.clear(); + selected.clear(); } - return min; - } - - /** - * propagate shift in alignment columns to column selection - * - * @param start - * beginning of edit - * @param left - * shift in edit (+ve for removal, or -ve for inserts) - */ - public List compensateForEdit(int start, int change) - { - List deletedHiddenColumns = null; - for (int i = 0; i < size(); i++) + void remove(int col) { - int temp = columnAt(i); - if (temp >= start) + Integer colInt = new Integer(col); + + if (selected.get(col)) { - // if this ever changes to List.set(), swap parameter order!! - selected.setElementAt(new Integer(temp - change), i); + // if this ever changes to List.remove(), ensure Integer not int + // argument + // as List.remove(int i) removes the i'th item which is wrong + order.remove(colInt); + selected.clear(col); } } - if (hiddenColumns != null) + boolean contains(Integer colInt) { - deletedHiddenColumns = new ArrayList(); - int hSize = hiddenColumns.size(); - for (int i = 0; i < hSize; i++) - { - int[] region = hiddenColumns.elementAt(i); - if (region[0] > start && start + change > region[1]) - { - deletedHiddenColumns.add(region); - - hiddenColumns.removeElementAt(i); - i--; - hSize--; - continue; - } - - if (region[0] > start) - { - region[0] -= change; - region[1] -= change; - } - - if (region[0] < 0) - { - region[0] = 0; - } - - } - - this.revealHiddenColumns(0); + return selected.get(colInt); } - return deletedHiddenColumns; - } - - /** - * propagate shift in alignment columns to column selection special version of - * compensateForEdit - allowing for edits within hidden regions - * - * @param start - * beginning of edit - * @param left - * shift in edit (+ve for removal, or -ve for inserts) - */ - private void compensateForDelEdits(int start, int change) - { - for (int i = 0; i < size(); i++) + boolean isEmpty() { - int temp = columnAt(i); - - if (temp >= start) - { - // if this ever changes to List.set(), swap parameter order!! - selected.setElementAt(new Integer(temp - change), i); - } + return order.isEmpty(); } - if (hiddenColumns != null) + /** + * Returns a read-only view of the selected columns list + * + * @return + */ + List getList() { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.elementAt(i); - if (region[0] >= start) - { - region[0] -= change; - } - if (region[1] >= start) - { - region[1] -= change; - } - if (region[1] < region[0]) - { - hiddenColumns.removeElementAt(i--); - } + return _uorder; + } - if (region[0] < 0) - { - region[0] = 0; - } - if (region[1] < 0) - { - region[1] = 0; - } - } + int size() + { + return order.size(); } - } - /** - * Adjust hidden column boundaries based on a series of column additions or - * deletions in visible regions. - * - * @param shiftrecord - * @return - */ - public ShiftList compensateForEdits(ShiftList shiftrecord) - { - if (shiftrecord != null) + /** + * gets the column that was selected first, second or i'th + * + * @param i + * @return + */ + int elementAt(int i) { - final List shifts = shiftrecord.getShifts(); - if (shifts != null && shifts.size() > 0) - { - int shifted = 0; - for (int i = 0, j = shifts.size(); i < j; i++) - { - int[] sh = shifts.get(i); - // compensateForEdit(shifted+sh[0], sh[1]); - compensateForDelEdits(shifted + sh[0], sh[1]); - shifted -= sh[1]; - } - } - return shiftrecord.getInverse(); + return order.get(i); } - return null; - } - /** - * removes intersection of position,length ranges in deletions from the - * start,end regions marked in intervals. - * - * @param shifts - * @param intervals - * @return - */ - private boolean pruneIntervalVector(final List shifts, - Vector intervals) - { - boolean pruned = false; - int i = 0, j = intervals.size() - 1, s = 0, t = shifts.size() - 1; - int hr[] = intervals.elementAt(i); - int sr[] = shifts.get(s); - while (i <= j && s <= t) + protected boolean pruneColumnList(final List shifts) { - boolean trailinghn = hr[1] >= sr[0]; - if (!trailinghn) + int s = 0, t = shifts.size(); + int[] sr = shifts.get(s++); + boolean pruned = false; + int i = 0, j = order.size(); + while (i < j && s <= t) { - if (i < j) - { - hr = intervals.elementAt(++i); - } - else - { - i++; - } - continue; - } - int endshift = sr[0] + sr[1]; // deletion ranges - -ve means an insert - if (endshift < hr[0] || endshift < sr[0]) - { // leadinghc disjoint or not a deletion - if (s < t) - { - sr = shifts.get(++s); - } - else + int c = order.get(i++).intValue(); + if (sr[0] <= c) { - s++; - } - continue; - } - boolean leadinghn = hr[0] >= sr[0]; - boolean leadinghc = hr[0] < endshift; - boolean trailinghc = hr[1] < endshift; - if (leadinghn) - { - if (trailinghc) - { // deleted hidden region. - intervals.removeElementAt(i); - pruned = true; - j--; - if (i <= j) - { - hr = intervals.elementAt(i); - } - continue; - } - if (leadinghc) - { - hr[0] = endshift; // clip c terminal region - leadinghn = !leadinghn; - pruned = true; - } - } - if (!leadinghn) - { - if (trailinghc) - { - if (trailinghn) - { - hr[1] = sr[0] - 1; - pruned = true; - } - } - else - { - // sr contained in hr - if (s < t) - { - sr = shifts.get(++s); + if (sr[1] + sr[0] >= c) + { // sr[1] -ve means inseriton. + order.remove(--i); + selected.clear(c); + j--; } else { + if (s < t) + { + sr = shifts.get(s); + } s++; } - continue; } } + return pruned; } - return pruned; // true if any interval was removed or modified by - // operations. - } - private boolean pruneColumnList(final List shifts, - Vector list) - { - int s = 0, t = shifts.size(); - int[] sr = shifts.get(s++); - boolean pruned = false; - int i = 0, j = list.size(); - while (i < j && s <= t) + /** + * shift every selected column at or above start by change + * + * @param start + * - leftmost column to be shifted + * @param change + * - delta for shift + */ + void compensateForEdits(int start, int change) { - int c = list.elementAt(i++).intValue(); - if (sr[0] <= c) + BitSet mask = new BitSet(); + for (int i = 0; i < order.size(); i++) { - if (sr[1] + sr[0] >= c) - { // sr[1] -ve means inseriton. - list.removeElementAt(--i); - j--; - } - else + int temp = order.get(i); + + if (temp >= start) { - if (s < t) - { - sr = shifts.get(s); - } - s++; + // clear shifted bits and update List of selected columns + selected.clear(temp); + mask.set(temp - change); + order.set(i, new Integer(temp - change)); } } + // lastly update the bitfield all at once + selected.or(mask); } - return pruned; - } - /** - * remove any hiddenColumns or selected columns and shift remaining based on a - * series of position, range deletions. - * - * @param deletions - */ - public void pruneDeletions(ShiftList deletions) - { - if (deletions != null) + boolean isSelected(int column) { - final List shifts = deletions.getShifts(); - if (shifts != null && shifts.size() > 0) - { - // delete any intervals intersecting. - if (hiddenColumns != null) - { - pruneIntervalVector(shifts, hiddenColumns); - if (hiddenColumns != null && hiddenColumns.size() == 0) - { - hiddenColumns = null; - } - } - if (selected != null && selected.size() > 0) - { - pruneColumnList(shifts, selected); - if (selected != null && selected.size() == 0) - { - selected = null; - } - } - // and shift the rest. - this.compensateForEdits(deletions); - } + return selected.get(column); } - } - /** - * This Method is used to return all the HiddenColumn regions - * @return empty list or List of hidden column intervals - */ - public List getHiddenColumns() - { - return hiddenColumns == null ? Collections. emptyList() - : hiddenColumns; - } + int getMaxColumn() + { + return selected.length() - 1; + } - /** - * Return absolute column index for a visible column index - * - * @param column - * int column index in alignment view - * @return alignment column index for column - */ - public int adjustForHiddenColumns(int column) - { - int result = column; - if (hiddenColumns != null) + int getMinColumn() { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.elementAt(i); - if (result >= region[0]) - { - result += region[1] - region[0] + 1; - } - } + return selected.get(0) ? 0 : selected.nextSetBit(0); } - return result; - } - /** - * Use this method to find out where a column will appear in the visible - * alignment when hidden columns exist. If the column is not visible, then the - * left-most visible column will always be returned. - * - * @param hiddenColumn - * int - * @return int - */ - public int findColumnPosition(int hiddenColumn) - { - int result = hiddenColumn; - if (hiddenColumns != null) + /** + * @return a series of selection intervals along the range + */ + List getRanges() { - int index = 0; - int[] region; - do + List rlist = new ArrayList(); + if (selected.isEmpty()) { - region = hiddenColumns.elementAt(index++); - if (hiddenColumn > region[1]) - { - result -= region[1] + 1 - region[0]; - } - } while ((hiddenColumn > region[1]) && (index < hiddenColumns.size())); - if (hiddenColumn > region[0] && hiddenColumn < region[1]) + return rlist; + } + int next = selected.nextSetBit(0), clear = -1; + while (next != -1) { - return region[0] + hiddenColumn - result; + clear = selected.nextClearBit(next); + rlist.add(new int[] { next, clear - 1 }); + next = selected.nextSetBit(clear); } + return rlist; } - return result; // return the shifted position after removing hidden columns. - } - /** - * Use this method to determine where the next hiddenRegion starts - */ - public int findHiddenRegionPosition(int hiddenRegion) - { - int result = 0; - if (hiddenColumns != null) + @Override + public int hashCode() { - int index = 0; - int gaps = 0; - do - { - int[] region = hiddenColumns.elementAt(index); - if (hiddenRegion == 0) - { - return region[0]; - } - - gaps += region[1] + 1 - region[0]; - result = region[1] + 1; - index++; - } while (index < hiddenRegion + 1); - - result -= gaps; + // TODO Auto-generated method stub + return selected.hashCode(); } - return result; + @Override + public boolean equals(Object obj) + { + if (obj instanceof IntList) + { + return ((IntList) obj).selected.equals(selected); + } + return false; + } } + IntList selection = new IntList(); + /** - * THis method returns the rightmost limit of a region of an alignment with - * hidden columns. In otherwords, the next hidden column. + * Add a column to the selection * - * @param index - * int + * @param col + * index of column */ - public int getHiddenBoundaryRight(int alPos) + public void addElement(int col) { - if (hiddenColumns != null) - { - int index = 0; - do - { - int[] region = hiddenColumns.elementAt(index); - if (alPos < region[0]) - { - return region[0]; - } - - index++; - } while (index < hiddenColumns.size()); - } - - return alPos; - + selection.add(col); } /** - * This method returns the leftmost limit of a region of an alignment with - * hidden columns. In otherwords, the previous hidden column. - * - * @param index - * int + * clears column selection */ - public int getHiddenBoundaryLeft(int alPos) + public void clear() { - if (hiddenColumns != null) - { - int index = hiddenColumns.size() - 1; - do - { - int[] region = hiddenColumns.elementAt(index); - if (alPos > region[1]) - { - return region[1]; - } - - index--; - } while (index > -1); - } - - return alPos; - + selection.clear(); } - public void hideSelectedColumns() + /** + * Removes value 'col' from the selection (not the col'th item) + * + * @param col + * index of column to be removed + */ + public void removeElement(int col) { - while (size() > 0) - { - int column = getSelected().firstElement().intValue(); - hideColumns(column); - } - + selection.remove(col); } - public void hideColumns(int start, int end) + /** + * removes a range of columns from the selection + * + * @param start + * int - first column in range to be removed + * @param end + * int - last col + */ + public void removeElements(int start, int end) { - if (hiddenColumns == null) - { - hiddenColumns = new Vector(); - } - - boolean added = false; - boolean overlap = false; - - for (int i = 0; i < hiddenColumns.size(); i++) + Integer colInt; + for (int i = start; i < end; i++) { - int[] region = hiddenColumns.elementAt(i); - if (start <= region[1] && end >= region[0]) - { - hiddenColumns.removeElementAt(i); - overlap = true; - break; - } - else if (end < region[0] && start < region[0]) + colInt = new Integer(i); + if (selection.contains(colInt)) { - hiddenColumns.insertElementAt(new int[] - { start, end }, i); - added = true; - break; + selection.remove(colInt); } } - - if (overlap) - { - hideColumns(start, end); - } - else if (!added) - { - hiddenColumns.addElement(new int[] - { start, end }); - } - } /** - * This method will find a range of selected columns around the column - * specified - * - * @param res - * int + * Returns a read-only view of the (possibly empty) list of selected columns + *

+ * The list contains no duplicates but is not necessarily ordered. It also may + * include columns hidden from the current view. To modify (for example sort) + * the list, you should first make a copy. + *

+ * The list is not thread-safe: iterating over it could result in + * ConcurrentModificationException if it is modified by another thread. */ - public void hideColumns(int col) + public List getSelected() { - // First find out range of columns to hide - int min = col, max = col + 1; - while (contains(min)) - { - removeElement(min); - min--; - } - - while (contains(max)) - { - removeElement(max); - max++; - } - - min++; - max--; - if (min > max) - { - min = max; - } - - hideColumns(min, max); + return selection.getList(); } - public void revealAllHiddenColumns() + /** + * @return list of int arrays containing start and end column position for + * runs of selected columns ordered from right to left. + */ + public List getSelectedRanges() { - if (hiddenColumns != null) - { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.elementAt(i); - for (int j = region[0]; j < region[1] + 1; j++) - { - addElement(j); - } - } - } - - hiddenColumns = null; + return selection.getRanges(); } - public void revealHiddenColumns(int res) + /** + * + * @param col + * index to search for in column selection + * + * @return true if col is selected + */ + public boolean contains(int col) { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.elementAt(i); - if (res == region[0]) - { - for (int j = region[0]; j < region[1] + 1; j++) - { - addElement(j); - } - - hiddenColumns.removeElement(region); - break; - } - } - if (hiddenColumns.size() == 0) - { - hiddenColumns = null; - } + return (col > -1) ? selection.isSelected(col) : false; } - public boolean isVisible(int column) + /** + * Answers true if no columns are selected, else false + */ + public boolean isEmpty() { - if (hiddenColumns != null) - { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.elementAt(i); - if (column >= region[0] && column <= region[1]) - { - return false; - } - } - } - - return true; + return selection == null || selection.isEmpty(); } /** - * Copy constructor + * rightmost selected column * - * @param copy + * @return rightmost column in alignment that is selected */ - public ColumnSelection(ColumnSelection copy) + public int getMax() { - if (copy != null) + if (selection.isEmpty()) { - if (copy.selected != null) - { - selected = new Vector(); - for (int i = 0, j = copy.selected.size(); i < j; i++) - { - selected.addElement(copy.selected.elementAt(i)); - } - } - if (copy.hiddenColumns != null) - { - hiddenColumns = new Vector(copy.hiddenColumns.size()); - for (int i = 0, j = copy.hiddenColumns.size(); i < j; i++) - { - int[] rh, cp; - rh = copy.hiddenColumns.elementAt(i); - if (rh != null) - { - cp = new int[rh.length]; - System.arraycopy(rh, 0, cp, 0, rh.length); - hiddenColumns.addElement(cp); - } - } - } + return -1; } + return selection.getMaxColumn(); } /** - * ColumnSelection + * Leftmost column in selection + * + * @return column index of leftmost column in selection */ - public ColumnSelection() + public int getMin() { + if (selection.isEmpty()) + { + return 1000000000; + } + return selection.getMinColumn(); } - public String[] getVisibleSequenceStrings(int start, int end, - SequenceI[] seqs) + public void hideSelectedColumns(AlignmentI al) { - int i, iSize = seqs.length; - String selection[] = new String[iSize]; - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - for (i = 0; i < iSize; i++) - { - StringBuffer visibleSeq = new StringBuffer(); - List regions = getHiddenColumns(); - - int blockStart = start, blockEnd = end; - int[] region; - int hideStart, hideEnd; - - for (int j = 0; j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; - - if (hideStart < start) - { - continue; - } - - blockStart = Math.min(blockStart, hideEnd + 1); - blockEnd = Math.min(blockEnd, hideStart); - - if (blockStart > blockEnd) - { - break; - } - - visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd)); - - blockStart = hideEnd + 1; - blockEnd = end; - } - - if (end > blockStart) - { - visibleSeq.append(seqs[i].getSequence(blockStart, end)); - } - - selection[i] = visibleSeq.toString(); - } - } - else + synchronized (selection) { - for (i = 0; i < iSize; i++) + for (int[] selregions : selection.getRanges()) { - selection[i] = seqs[i].getSequenceAsString(start, end); + al.getHiddenColumns().hideColumns(selregions[0], selregions[1]); } + selection.clear(); } - return selection; } + /** - * return all visible segments between the given start and end boundaries + * Hides the specified column and any adjacent selected columns * - * @param start - * (first column inclusive from 0) - * @param end - * (last column - not inclusive) - * @return int[] {i_start, i_end, ..} where intervals lie in - * start<=i_start<=i_end 0) - { - List visiblecontigs = new ArrayList(); - List regions = getHiddenColumns(); - - int vstart = start; - int[] region; - int hideStart, hideEnd; - - for (int j = 0; vstart < end && j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; + /* + * deselect column (whether selected or not!) + */ + removeElement(col); - if (hideEnd < vstart) - { - continue; - } - if (hideStart > vstart) - { - visiblecontigs.add(new int[] - { vstart, hideStart - 1 }); - } - vstart = hideEnd + 1; - } + /* + * find adjacent selected columns + */ + int min = col - 1, max = col + 1; + while (contains(min)) + { + removeElement(min); + min--; + } - if (vstart < end) - { - visiblecontigs.add(new int[] - { vstart, end - 1 }); - } - int[] vcontigs = new int[visiblecontigs.size() * 2]; - for (int i = 0, j = visiblecontigs.size(); i < j; i++) - { - int[] vc = visiblecontigs.get(i); - visiblecontigs.set(i, null); - vcontigs[i * 2] = vc[0]; - vcontigs[i * 2 + 1] = vc[1]; - } - visiblecontigs.clear(); - return vcontigs; + while (contains(max)) + { + removeElement(max); + max++; } - else + + /* + * min, max are now the closest unselected columns + */ + min++; + max--; + if (min > max) { - return new int[] - { start, end - 1 }; + min = max; } + + hidden.hideColumns(min, max); } + + + + /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). + * Copy constructor * - * @param alignmentAnnotation + * @param copy */ - public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation) + public ColumnSelection(ColumnSelection copy) { - makeVisibleAnnotation(-1, -1, alignmentAnnotation); + if (copy != null) + { + selection = new IntList(copy.selection); + } } /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). - * - * @param start - * remove any annotation to the right of this column - * @param end - * remove any annotation to the left of this column - * @param alignmentAnnotation - * the annotation to operate on + * ColumnSelection */ - public void makeVisibleAnnotation(int start, int end, - AlignmentAnnotation alignmentAnnotation) + public ColumnSelection() { - if (alignmentAnnotation.annotations == null) - { - return; - } - if (start == end && end == -1) - { - start = 0; - end = alignmentAnnotation.annotations.length; - } - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - // then mangle the alignmentAnnotation annotation array - Vector annels = new Vector(); - Annotation[] els = null; - List regions = getHiddenColumns(); - int blockStart = start, blockEnd = end; - int[] region; - int hideStart, hideEnd, w = 0; - - for (int j = 0; j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; - - if (hideStart < start) - { - continue; - } - - blockStart = Math.min(blockStart, hideEnd + 1); - blockEnd = Math.min(blockEnd, hideStart); + } - if (blockStart > blockEnd) - { - break; - } - annels.addElement(els = new Annotation[blockEnd - blockStart]); - System.arraycopy(alignmentAnnotation.annotations, blockStart, els, - 0, els.length); - w += els.length; - blockStart = hideEnd + 1; - blockEnd = end; - } - if (end > blockStart) - { - annels.addElement(els = new Annotation[end - blockStart + 1]); - if ((els.length + blockStart) <= alignmentAnnotation.annotations.length) - { - // copy just the visible segment of the annotation row - System.arraycopy(alignmentAnnotation.annotations, blockStart, - els, 0, els.length); - } - else - { - // copy to the end of the annotation row - System.arraycopy(alignmentAnnotation.annotations, blockStart, - els, 0, - (alignmentAnnotation.annotations.length - blockStart)); - } - w += els.length; - } - if (w == 0) - { - return; - } - alignmentAnnotation.annotations = new Annotation[w]; - w = 0; - for (Annotation [] chnk : annels) - { - System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w, - chnk.length); - w += chnk.length; - } - } - else - { - alignmentAnnotation.restrict(start, end); - } - } /** * Invert the column selection from first to end-1. leaves hiddenColumns @@ -1055,9 +480,9 @@ public class ColumnSelection * @param first * @param end */ - public void invertColumnSelection(int first, int width) + public void invertColumnSelection(int first, int width, AlignmentI al) { - boolean hasHidden = hiddenColumns != null && hiddenColumns.size() > 0; + boolean hasHidden = al.getHiddenColumns().hasHidden(); for (int i = first; i < width; i++) { if (contains(i)) @@ -1066,7 +491,7 @@ public class ColumnSelection } else { - if (!hasHidden || isVisible(i)) + if (!hasHidden || al.getHiddenColumns().isVisible(i)) { addElement(i); } @@ -1075,44 +500,29 @@ public class ColumnSelection } /** - * add in any unselected columns from the given column selection, excluding - * any that are hidden. + * set the selected columns to the given column selection, excluding any + * columns that are hidden. * * @param colsel */ - public void addElementsFrom(ColumnSelection colsel) + public void setElementsFrom(ColumnSelection colsel, + HiddenColumns hiddenColumns) { - if (colsel != null && colsel.size() > 0) + selection = new IntList(); + if (colsel.selection != null && colsel.selection.size() > 0) { - for (Integer col : colsel.getSelected()) + if (hiddenColumns.hasHidden()) { - if (hiddenColumns != null && isVisible(col.intValue())) + // only select visible columns in this columns selection + for (Integer col : colsel.getSelected()) { - if (!selected.contains(col)) + if (hiddenColumns != null + && hiddenColumns.isVisible(col.intValue())) { - selected.addElement(col); + selection.add(col); } } } - } - } - - /** - * set the selected columns the given column selection, excluding any columns - * that are hidden. - * - * @param colsel - */ - public void setElementsFrom(ColumnSelection colsel) - { - selected = new Vector(); - if (colsel.selected != null && colsel.selected.size() > 0) - { - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - // only select visible columns in this columns selection - addElementsFrom(colsel); - } else { // add everything regardless @@ -1124,148 +534,6 @@ public class ColumnSelection } } - /** - * Add gaps into the sequences aligned to profileseq under the given - * AlignmentView - * - * @param profileseq - * @param al - * - alignment to have gaps inserted into it - * @param input - * - alignment view where sequence corresponding to profileseq is - * first entry - * @return new Column selection for new alignment view, with insertions into - * profileseq marked as hidden. - */ - public static ColumnSelection propagateInsertions(SequenceI profileseq, - AlignmentI al, AlignmentView input) - { - int profsqpos = 0; - - // return propagateInsertions(profileseq, al, ) - char gc = al.getGapCharacter(); - Object[] alandcolsel = input.getAlignmentAndColumnSelection(gc); - ColumnSelection nview = (ColumnSelection) alandcolsel[1]; - SequenceI origseq = ((SequenceI[]) alandcolsel[0])[profsqpos]; - nview.propagateInsertions(profileseq, al, origseq); - return nview; - } - - /** - * - * @param profileseq - * - sequence in al which corresponds to origseq - * @param al - * - alignment which is to have gaps inserted into it - * @param origseq - * - sequence corresponding to profileseq which defines gap map for - * modifying al - */ - public void propagateInsertions(SequenceI profileseq, AlignmentI al, - SequenceI origseq) - { - char gc = al.getGapCharacter(); - // recover mapping between sequence's non-gap positions and positions - // mapping to view. - pruneDeletions(ShiftList.parseMap(origseq.gapMap())); - int[] viscontigs = getVisibleContigs(0, profileseq.getLength()); - int spos = 0; - int offset = 0; - // input.pruneDeletions(ShiftList.parseMap(((SequenceI[]) - // alandcolsel[0])[0].gapMap())) - // add profile to visible contigs - for (int v = 0; v < viscontigs.length; v += 2) - { - if (viscontigs[v] > spos) - { - StringBuffer sb = new StringBuffer(); - for (int s = 0, ns = viscontigs[v] - spos; s < ns; s++) - { - sb.append(gc); - } - for (int s = 0, ns = al.getHeight(); s < ns; s++) - { - SequenceI sqobj = al.getSequenceAt(s); - if (sqobj != profileseq) - { - String sq = al.getSequenceAt(s).getSequenceAsString(); - if (sq.length() <= spos + offset) - { - // pad sequence - int diff = spos + offset - sq.length() - 1; - if (diff > 0) - { - // pad gaps - sq = sq + sb; - while ((diff = spos + offset - sq.length() - 1) > 0) - { - // sq = sq - // + ((diff >= sb.length()) ? sb.toString() : sb - // .substring(0, diff)); - if (diff >= sb.length()) - { - sq += sb.toString(); - } - else - { - char[] buf = new char[diff]; - sb.getChars(0, diff, buf, 0); - sq += buf.toString(); - } - } - } - sq += sb.toString(); - } - else - { - al.getSequenceAt(s).setSequence( - sq.substring(0, spos + offset) + sb.toString() - + sq.substring(spos + offset)); - } - } - } - // offset+=sb.length(); - } - spos = viscontigs[v + 1] + 1; - } - if ((offset + spos) < profileseq.getLength()) - { - // pad the final region with gaps. - StringBuffer sb = new StringBuffer(); - for (int s = 0, ns = profileseq.getLength() - spos - offset; s < ns; s++) - { - sb.append(gc); - } - for (int s = 0, ns = al.getHeight(); s < ns; s++) - { - SequenceI sqobj = al.getSequenceAt(s); - if (sqobj == profileseq) - { - continue; - } - String sq = sqobj.getSequenceAsString(); - // pad sequence - int diff = origseq.getLength() - sq.length(); - while (diff > 0) - { - // sq = sq - // + ((diff >= sb.length()) ? sb.toString() : sb - // .substring(0, diff)); - if (diff >= sb.length()) - { - sq += sb.toString(); - } - else - { - char[] buf = new char[diff]; - sb.getChars(0, diff, buf, 0); - sq += buf.toString(); - } - diff = origseq.getLength() - sq.length(); - } - } - } - } /** * @@ -1273,46 +541,16 @@ public class ColumnSelection */ public boolean hasSelectedColumns() { - return (selected != null && selected.size() > 0); + return (selection != null && selection.size() > 0); } - /** - * - * @return true if there are columns hidden - */ - public boolean hasHiddenColumns() - { - return hiddenColumns != null && hiddenColumns.size() > 0; - } - - /** - * - * @return true if there are more than one set of columns hidden - */ - public boolean hasManyHiddenColumns() - { - return hiddenColumns != null && hiddenColumns.size() > 1; - } - /** - * mark the columns corresponding to gap characters as hidden in the column - * selection - * - * @param sr - */ - public void hideInsertionsFor(SequenceI sr) - { - List inserts = sr.getInsertions(); - for (int[] r : inserts) - { - hideColumns(r[0], r[1]); - } - } - + public boolean filterAnnotations(Annotation[] annotations, AnnotationFilterParameter filterParams) { - this.revealAllHiddenColumns(); + // JBPNote - this method needs to be refactored to become independent of + // viewmodel package this.clear(); int count = 0; do @@ -1393,4 +631,170 @@ public class ColumnSelection } while (count < annotations.length); return false; } + + /** + * Returns a hashCode built from selected columns ranges + */ + @Override + public int hashCode() + { + return selection.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; + } + + 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; + } + + /** + * Adjusts column selections, and the given selection group, to match the + * range of a stretch (e.g. mouse drag) operation + *

+ * Method refactored from ScalePanel.mouseDragged + * + * @param res + * current column position, adjusted for hidden columns + * @param sg + * current selection group + * @param min + * start position of the stretch group + * @param max + * end position of the stretch group + */ + public void stretchGroup(int res, SequenceGroup sg, int min, int max) + { + if (!contains(res)) + { + addElement(res); + } + + if (res > sg.getStartRes()) + { + // expand selection group to the right + sg.setEndRes(res); + } + if (res < sg.getStartRes()) + { + // expand selection group to the left + sg.setStartRes(res); + } + + /* + * expand or shrink column selection to match the + * range of the drag operation + */ + for (int col = min; col <= max; col++) + { + if (col < sg.getStartRes() || col > sg.getEndRes()) + { + // shrinking drag - remove from selection + removeElement(col); + } + else + { + // expanding drag - add to selection + addElement(col); + } + } + } }