X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FColumnSelection.java;h=3421c410a96265382df8afd323a665935c3d75f5;hb=5c26e2d28ac9f6f0b2d95ecf271ed46fbb29fa4a;hp=ad6689488792191e953f429f752a7c1ca742912c;hpb=af8696684758d73680cb775f35b05c5eda879353;p=jalview.git diff --git a/src/jalview/datamodel/ColumnSelection.java b/src/jalview/datamodel/ColumnSelection.java index ad66894..3421c41 100644 --- a/src/jalview/datamodel/ColumnSelection.java +++ b/src/jalview/datamodel/ColumnSelection.java @@ -1,451 +1,464 @@ -/* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - */ -package jalview.datamodel; - -import java.util.*; - -/** - * NOTE: Columns are zero based. - */ -public class ColumnSelection -{ - Vector selected = new Vector(); - - //Vector of int [] {startCol, endCol} - Vector hiddenColumns; - - /** - * DOCUMENT ME! - * - * @param col DOCUMENT ME! - */ - public void addElement(int col) - { - if (!selected.contains(new Integer(col))) - { - selected.addElement(new Integer(col)); - } - } - - /** - * DOCUMENT ME! - */ - public void clear() - { - selected.removeAllElements(); - } - - /** - * DOCUMENT ME! - * - * @param col DOCUMENT ME! - */ - public void removeElement(int col) - { - Integer colInt = new Integer(col); - - if (selected.contains(colInt)) - { - selected.removeElement(colInt); - } - } - - public void removeElements(int start, int end) - { - Integer colInt; - for(int i=start; i max) - { - max = columnAt(i); - } - } - - return max; - } - - /** - * DOCUMENT ME! - * - * @return DOCUMENT ME! - */ - public int getMin() - { - int min = 1000000000; - - for (int i = 0; i < selected.size(); i++) - { - if (columnAt(i) < min) - { - min = columnAt(i); - } - } - - return min; - } - - - /** - * DOCUMENT ME! - * - * @param start DOCUMENT ME! - * @param change DOCUMENT ME! - */ - public void compensateForEdit(int start, int change) - { - for (int i = 0; i < size(); i++) - { - int temp = columnAt(i); - - if (temp >= start) - { - selected.setElementAt(new Integer(temp - change), i); - } - } - - if(hiddenColumns!=null) - { - for(int i=0; i start) - { - region[0] -= change; - region[1] -= change; - } - if(region[0]<0) - region[0] = 0; - if(region[1] <0) - region[1] = 0; - } - } - } - - /** - * This Method is used to return all the HiddenColumn regions - * less than the given index. - * @param end int - * @return Vector - */ - public Vector getHiddenColumns() - { - return hiddenColumns; - } - - public int adjustForHiddenColumns(int column) - { - int result = column; - if (hiddenColumns != null) - { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = (int[]) hiddenColumns.elementAt(i); - if (result >= region[0]) - { - result += region[1] - region[0] + 1; - } - } - } - return result; - } - - /** - * Use this method to find out where a visible column is in the alignment - * when hidden columns exist - * @param hiddenColumn int - * @return int - */ - public int findColumnPosition(int hiddenColumn) - { - int result = hiddenColumn; - if (hiddenColumns != null) - { - int index = 0; - int gaps = 0; - do - { - int[] region = (int[]) hiddenColumns.elementAt(index); - if (hiddenColumn > region[1]) - { - result -= region[1]+1-region[0]; - } - index++; - } - while (index < hiddenColumns.size()); - - result -= gaps; - } - - return result; - } - - /** - * Use this method to determine where the next hiddenRegion starts - */ - public int findHiddenRegionPosition(int hiddenRegion) - { - int result = 0; - if (hiddenColumns != null) - { - int index = 0; - int gaps = 0; - do - { - int[] region = (int[]) 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; - } - - return result; - } - - /** - * THis method returns the rightmost limit of a - * region of an alignment with hidden columns. - * In otherwords, the next hidden column. - * @param index int - */ - public int getHiddenBoundaryRight(int alPos) - { - if (hiddenColumns != null) - { - int index = 0; - do - { - int[] region = (int[]) hiddenColumns.elementAt(index); - if(alPos < region[0]) - return region[0]; - - index++; - } - while(index < hiddenColumns.size()); - } - - return alPos; - - } - /** - * THis method returns the rightmost limit of a - * region of an alignment with hidden columns. - * In otherwords, the next hidden column. - * @param index int - */ - public int getHiddenBoundaryLeft(int alPos) - { - if (hiddenColumns != null) - { - int index = hiddenColumns.size()-1; - do - { - int[] region = (int[]) hiddenColumns.elementAt(index); - if(alPos > region[1]) - return region[1]; - - index--; - } - while(index >-1); - } - - return alPos; - } - - public void hideSelectedColumns() - { - while (size() > 0) - { - int column = ( (Integer) getSelected().firstElement()).intValue(); - hideColumns(column); - } - - } - - public void hideColumns(int start, int end) - { - if(hiddenColumns==null) - hiddenColumns = new Vector(); - - boolean added = false; - boolean overlap = false; - - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = (int[]) hiddenColumns.elementAt(i); - if ( start<=region[1] && end>=region[0]) - { - hiddenColumns.removeElementAt(i); - overlap = true; - break; - } - else if (end < region[0] && start < region[0]) - { - hiddenColumns.insertElementAt(new int[] - {start, end}, i); - added = true; - break; - } - } - - 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 - */ - public void hideColumns(int col) - { - // 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--; - - hideColumns(min, max); - } - - public void revealAllHiddenColumns() - { - if(hiddenColumns!=null) - { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = (int[]) hiddenColumns.elementAt(i); - for (int j = region[0]; j < region[1]; j++) - { - addElement(j); - } - } - } - - hiddenColumns = null; - } - - public void revealHiddenColumns(int res) - { - for(int i=0; i= region[0] && column <= region[1]) - { - return false; - } - } - return true; - } - -} +/* + * Jalview - A Sequence Alignment Editor and Viewer + * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ +package jalview.datamodel; + +import java.util.*; + +/** + * NOTE: Columns are zero based. + */ +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 + */ + public void addElement(int col) + { + Integer column = new Integer(col); + if (!selected.contains(column)) + { + selected.addElement(column); + } + } + + /** + * clears column selection + */ + public void clear() + { + selected.removeAllElements(); + } + + /** + * removes col from selection + * + * @param col index of column to be removed + */ + public void removeElement(int col) + { + Integer colInt = new Integer(col); + + if (selected.contains(colInt)) + { + selected.removeElement(colInt); + } + } + + /** + * 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 max) + { + max = columnAt(i); + } + } + + return max; + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public int getMin() + { + int min = 1000000000; + + for (int i = 0; i < selected.size(); i++) + { + if (columnAt(i) < min) + { + min = columnAt(i); + } + } + + return min; + } + + + /** + * propagate shift in alignment columns to column selection + * + * @param start beginning of edit + * @param change shift in edit (-ve or +ve number of columns) + */ + public void compensateForEdit(int start, int change) + { + for (int i = 0; i < size(); i++) + { + int temp = columnAt(i); + + if (temp >= start) + { + selected.setElementAt(new Integer(temp - change), i); + } + } + + if(hiddenColumns!=null) + { + for(int i=0; i start) + { + region[0] -= change; + region[1] -= change; + } + if(region[0]<0) + region[0] = 0; + if(region[1] <0) + region[1] = 0; + } + } + } + + /** + * This Method is used to return all the HiddenColumn regions + * less than the given index. + * @param end int + * @return Vector + */ + public Vector getHiddenColumns() + { + return hiddenColumns; + } + /** + * 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) + { + for (int i = 0; i < hiddenColumns.size(); i++) + { + int[] region = (int[]) hiddenColumns.elementAt(i); + if (result >= region[0]) + { + result += region[1] - region[0] + 1; + } + } + } + return result; + } + + /** + * Use this method to find out where a visible column is in the alignment + * when hidden columns exist + * @param hiddenColumn int + * @return int + */ + public int findColumnPosition(int hiddenColumn) + { + int result = hiddenColumn; + if (hiddenColumns != null) + { + int index = 0; + int gaps = 0; + do + { + int[] region = (int[]) hiddenColumns.elementAt(index); + if (hiddenColumn > region[1]) + { + result -= region[1]+1-region[0]; + } + index++; + } + while (index < hiddenColumns.size()); + + result -= gaps; + } + + return result; + } + + /** + * Use this method to determine where the next hiddenRegion starts + */ + public int findHiddenRegionPosition(int hiddenRegion) + { + int result = 0; + if (hiddenColumns != null) + { + int index = 0; + int gaps = 0; + do + { + int[] region = (int[]) 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; + } + + return result; + } + + /** + * THis method returns the rightmost limit of a + * region of an alignment with hidden columns. + * In otherwords, the next hidden column. + * @param index int + */ + public int getHiddenBoundaryRight(int alPos) + { + if (hiddenColumns != null) + { + int index = 0; + do + { + int[] region = (int[]) hiddenColumns.elementAt(index); + if(alPos < region[0]) + return region[0]; + + index++; + } + while(index < hiddenColumns.size()); + } + + return alPos; + + } + /** + * THis method returns the rightmost limit of a + * region of an alignment with hidden columns. + * In otherwords, the next hidden column. + * @param index int + */ + public int getHiddenBoundaryLeft(int alPos) + { + if (hiddenColumns != null) + { + int index = hiddenColumns.size()-1; + do + { + int[] region = (int[]) hiddenColumns.elementAt(index); + if(alPos > region[1]) + return region[1]; + + index--; + } + while(index >-1); + } + + return alPos; + + } + + public void hideSelectedColumns() + { + while (size() > 0) + { + int column = ( (Integer) getSelected().firstElement()).intValue(); + hideColumns(column); + } + + } + + public void hideColumns(int start, int end) + { + if(hiddenColumns==null) + hiddenColumns = new Vector(); + + boolean added = false; + boolean overlap = false; + + for (int i = 0; i < hiddenColumns.size(); i++) + { + int[] region = (int[]) hiddenColumns.elementAt(i); + if ( start<=region[1] && end>=region[0]) + { + hiddenColumns.removeElementAt(i); + overlap = true; + break; + } + else if (end < region[0] && start < region[0]) + { + hiddenColumns.insertElementAt(new int[] + {start, end}, i); + added = true; + break; + } + } + + 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 + */ + public void hideColumns(int col) + { + // 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--; + + hideColumns(min, max); + } + + public void revealAllHiddenColumns() + { + if(hiddenColumns!=null) + { + for (int i = 0; i < hiddenColumns.size(); i++) + { + int[] region = (int[]) hiddenColumns.elementAt(i); + for (int j = region[0]; j < region[1]+1; j++) + { + addElement(j); + } + } + } + + hiddenColumns = null; + } + + public void revealHiddenColumns(int res) + { + for(int i=0; i= region[0] && column <= region[1]) + { + return false; + } + } + return true; + } + +}