src/jalview/gui/ColumnSelection.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer\r
   3  * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  *\r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Software\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 package jalview.gui;\r
  20 \r
  21 import java.util.*;\r
  22 \r
  23 /**\r
  24  * NOTE: Columns are zero based.\r
  25  */\r
  26 public class ColumnSelection\r
  27 {\r
  28     Vector selected = new Vector();\r
  29 \r
  30     //Vector of int [] {startCol, endCol}\r
  31     Vector hiddenColumns;\r
  32 \r
  33     /**\r
  34      * DOCUMENT ME!\r
  35      *\r
  36      * @param col DOCUMENT ME!\r
  37      */\r
  38     public void addElement(int col)\r
  39     {\r
  40         if (!selected.contains(new Integer(col)))\r
  41         {\r
  42             selected.addElement(new Integer(col));\r
  43         }\r
  44     }\r
  45 \r
  46     /**\r
  47      * DOCUMENT ME!\r
  48      */\r
  49     public void clear()\r
  50     {\r
  51         selected.removeAllElements();\r
  52     }\r
  53 \r
  54     /**\r
  55      * DOCUMENT ME!\r
  56      *\r
  57      * @param col DOCUMENT ME!\r
  58      */\r
  59     public void removeElement(int col)\r
  60     {\r
  61         Integer colInt = new Integer(col);\r
  62 \r
  63         if (selected.contains(colInt))\r
  64         {\r
  65             selected.removeElement(colInt);\r
  66         }\r
  67     }\r
  68 \r
  69     public void removeElements(int start, int end)\r
  70     {\r
  71       Integer colInt;\r
  72       for(int i=start; i<end; i++)\r
  73       {\r
  74         colInt = new Integer(i);\r
  75         if (selected.contains(colInt))\r
  76         {\r
  77             selected.removeElement(colInt);\r
  78         }\r
  79       }\r
  80     }\r
  81 \r
  82     /**\r
  83      * DOCUMENT ME!\r
  84      *\r
  85      * @param col DOCUMENT ME!\r
  86      *\r
  87      * @return DOCUMENT ME!\r
  88      */\r
  89     public boolean contains(int col)\r
  90     {\r
  91         return selected.contains(new Integer(col));\r
  92     }\r
  93 \r
  94     /**\r
  95      * DOCUMENT ME!\r
  96      *\r
  97      * @param i DOCUMENT ME!\r
  98      *\r
  99      * @return DOCUMENT ME!\r
 100      */\r
 101     public int columnAt(int i)\r
 102     {\r
 103         return ((Integer) selected.elementAt(i)).intValue();\r
 104     }\r
 105 \r
 106     /**\r
 107      * DOCUMENT ME!\r
 108      *\r
 109      * @return DOCUMENT ME!\r
 110      */\r
 111     public int size()\r
 112     {\r
 113         return selected.size();\r
 114     }\r
 115 \r
 116     /**\r
 117      * DOCUMENT ME!\r
 118      *\r
 119      * @return DOCUMENT ME!\r
 120      */\r
 121     public int getMax()\r
 122     {\r
 123         int max = -1;\r
 124 \r
 125         for (int i = 0; i < selected.size(); i++)\r
 126         {\r
 127             if (columnAt(i) > max)\r
 128             {\r
 129                 max = columnAt(i);\r
 130             }\r
 131         }\r
 132 \r
 133         return max;\r
 134     }\r
 135 \r
 136     /**\r
 137      * DOCUMENT ME!\r
 138      *\r
 139      * @return DOCUMENT ME!\r
 140      */\r
 141     public int getMin()\r
 142     {\r
 143         int min = 1000000000;\r
 144 \r
 145         for (int i = 0; i < selected.size(); i++)\r
 146         {\r
 147             if (columnAt(i) < min)\r
 148             {\r
 149                 min = columnAt(i);\r
 150             }\r
 151         }\r
 152 \r
 153         return min;\r
 154     }\r
 155 \r
 156 \r
 157     /**\r
 158      * DOCUMENT ME!\r
 159      *\r
 160      * @param start DOCUMENT ME!\r
 161      * @param change DOCUMENT ME!\r
 162      */\r
 163     public void compensateForEdit(int start, int change)\r
 164     {\r
 165         for (int i = 0; i < size(); i++)\r
 166         {\r
 167             int temp = columnAt(i);\r
 168 \r
 169             if (temp >= start)\r
 170             {\r
 171                 selected.setElementAt(new Integer(temp - change), i);\r
 172             }\r
 173         }\r
 174 \r
 175         if(hiddenColumns!=null)\r
 176         {\r
 177           for(int i=0; i<hiddenColumns.size(); i++)\r
 178           {\r
 179             int[] region = (int[]) hiddenColumns.elementAt(i);\r
 180             if(region[0] > start)\r
 181             {\r
 182               region[0] -= change;\r
 183               region[1] -= change;\r
 184             }\r
 185             if(region[0]<0)\r
 186               region[0] = 0;\r
 187             if(region[1] <0)\r
 188              region[1] = 0;\r
 189           }\r
 190         }\r
 191     }\r
 192 \r
 193     /**\r
 194      * This Method is used to return all the HiddenColumn regions\r
 195      * less than the given index.\r
 196      * @param end int\r
 197      * @return Vector\r
 198      */\r
 199     public Vector getHiddenColumns()\r
 200     {\r
 201       return hiddenColumns;\r
 202     }\r
 203 \r
 204     public int adjustForHiddenColumns(int column)\r
 205     {\r
 206       int result = column;\r
 207       if (hiddenColumns != null)\r
 208       {\r
 209         for (int i = 0; i < hiddenColumns.size(); i++)\r
 210         {\r
 211           int[] region = (int[]) hiddenColumns.elementAt(i);\r
 212           if (result >= region[0])\r
 213           {\r
 214             result += region[1] - region[0] + 1;\r
 215           }\r
 216         }\r
 217       }\r
 218       return result;\r
 219     }\r
 220 \r
 221     /**\r
 222      * Use this method to find out where a visible column is in the alignment\r
 223      * when hidden columns exist\r
 224      * @param hiddenColumn int\r
 225      * @return int\r
 226      */\r
 227     public int findColumnPosition(int hiddenColumn)\r
 228     {\r
 229       int result = hiddenColumn;\r
 230       if (hiddenColumns != null)\r
 231       {\r
 232         int index = 0;\r
 233         int gaps = 0;\r
 234         do\r
 235         {\r
 236           int[] region = (int[]) hiddenColumns.elementAt(index);\r
 237           if (hiddenColumn > region[1])\r
 238           {\r
 239             result -= region[1]+1-region[0];\r
 240           }\r
 241           index++;\r
 242         }\r
 243         while (index < hiddenColumns.size());\r
 244 \r
 245         result -= gaps;\r
 246       }\r
 247 \r
 248       return result;\r
 249     }\r
 250 \r
 251     /**\r
 252      * Use this method to determine where the next hiddenRegion starts\r
 253     */\r
 254     public int findHiddenRegionPosition(int hiddenRegion)\r
 255     {\r
 256       int result = 0;\r
 257       if (hiddenColumns != null)\r
 258       {\r
 259         int index = 0;\r
 260         int gaps = 0;\r
 261         do\r
 262         {\r
 263           int[] region = (int[]) hiddenColumns.elementAt(index);\r
 264           if(hiddenRegion==0)\r
 265           {\r
 266             return region[0];\r
 267           }\r
 268 \r
 269             gaps +=  region[1] +1 - region[0];\r
 270             result = region[1] +1;\r
 271             index++;\r
 272         }\r
 273         while(index < hiddenRegion+1);\r
 274 \r
 275         result -= gaps;\r
 276       }\r
 277 \r
 278       return result;\r
 279     }\r
 280 \r
 281     /**\r
 282      * THis method returns the rightmost limit of a\r
 283      * region of an alignment with hidden columns.\r
 284      * In otherwords, the next hidden column.\r
 285      * @param index int\r
 286      */\r
 287     public int getHiddenBoundaryRight(int alPos)\r
 288     {\r
 289       if (hiddenColumns != null)\r
 290       {\r
 291         int index = 0;\r
 292         do\r
 293         {\r
 294           int[] region = (int[]) hiddenColumns.elementAt(index);\r
 295           if(alPos < region[0])\r
 296             return region[0];\r
 297 \r
 298           index++;\r
 299         }\r
 300         while(index < hiddenColumns.size());\r
 301       }\r
 302 \r
 303       return alPos;\r
 304 \r
 305     }\r
 306     /**\r
 307      * THis method returns the rightmost limit of a\r
 308      * region of an alignment with hidden columns.\r
 309      * In otherwords, the next hidden column.\r
 310      * @param index int\r
 311      */\r
 312     public int getHiddenBoundaryLeft(int alPos)\r
 313     {\r
 314       if (hiddenColumns != null)\r
 315       {\r
 316         int index = hiddenColumns.size()-1;\r
 317         do\r
 318         {\r
 319           int[] region = (int[]) hiddenColumns.elementAt(index);\r
 320           if(alPos > region[1])\r
 321             return region[1];\r
 322 \r
 323           index--;\r
 324         }\r
 325         while(index >-1);\r
 326       }\r
 327 \r
 328       return alPos;\r
 329 \r
 330     }\r
 331 \r
 332 \r
 333 \r
 334     public void hideColumns(int res)\r
 335     {\r
 336       if(hiddenColumns==null)\r
 337         hiddenColumns = new Vector();\r
 338 \r
 339       // First find out range of columns to hide\r
 340       int min = res, max = res+1;\r
 341       while( contains(min) )\r
 342       {  removeElement(min); min --;  }\r
 343 \r
 344       while( contains(max) )\r
 345       { removeElement(max);  max ++;  }\r
 346 \r
 347       min++; max--;\r
 348 \r
 349       boolean added = false;\r
 350       for(int i=0; i<hiddenColumns.size(); i++)\r
 351       {\r
 352         int [] region = (int[])hiddenColumns.elementAt(i);\r
 353         if( max < region[0])\r
 354         {\r
 355           hiddenColumns.insertElementAt(new int[]{min, max}, i);\r
 356           added = true;\r
 357           break;\r
 358         }\r
 359       }\r
 360 \r
 361       if(!added)\r
 362         hiddenColumns.addElement(new int[]{min, max});\r
 363 \r
 364     }\r
 365 \r
 366     public void revealAllHiddenColumns(AlignViewport av)\r
 367     {\r
 368       if(hiddenColumns!=null)\r
 369       {\r
 370         for (int i = 0; i < hiddenColumns.size(); i++)\r
 371         {\r
 372           int[] region = (int[]) hiddenColumns.elementAt(i);\r
 373           for (int j = region[0]; j < region[1]; j++)\r
 374           {\r
 375             addElement(j);\r
 376           }\r
 377         }\r
 378       }\r
 379       av.hasHiddenColumns = false;\r
 380       hiddenColumns = null;\r
 381     }\r
 382 \r
 383     public void revealHiddenColumns(int res, AlignViewport av)\r
 384     {\r
 385       for(int i=0; i<hiddenColumns.size(); i++)\r
 386       {\r
 387         int [] region = (int[])hiddenColumns.elementAt(i);\r
 388         if( res == region[0])\r
 389         {\r
 390           for (int j = region[0]; j < region[1]; j++)\r
 391           {\r
 392             addElement(j);\r
 393           }\r
 394 \r
 395           hiddenColumns.remove(region);\r
 396           break;\r
 397         }\r
 398       }\r
 399 \r
 400 \r
 401       if(hiddenColumns.size()<1)\r
 402         av.hasHiddenColumns = false;\r
 403     }\r
 404 \r
 405     public boolean isVisible(int column)\r
 406     {\r
 407       for(int i=0; i<hiddenColumns.size(); i++)\r
 408       {\r
 409         int [] region = (int[])hiddenColumns.elementAt(i);\r
 410         if( column >= region[0] && column <= region[1])\r
 411         {\r
 412           return false;\r
 413         }\r
 414       }\r
 415       return true;\r
 416     }\r
 417 \r
 418 }\r