src/jalview/datamodel/HiddenSequences.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)
   3  * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.datamodel;
  20
  21 import java.util.*;
  22
  23 public class HiddenSequences
  24 {
  25   /**
  26    * holds a list of hidden sequences associated with an alignment.
  27    */
  28   public SequenceI[] hiddenSequences;
  29
  30   AlignmentI alignment;
  31
  32   public HiddenSequences(AlignmentI al)
  33   {
  34     alignment = al;
  35   }
  36
  37   public int getSize()
  38   {
  39     if (hiddenSequences == null)
  40     {
  41       return 0;
  42     }
  43     int count = 0;
  44     for (int i = 0; i < hiddenSequences.length; i++)
  45     {
  46       if (hiddenSequences[i] != null)
  47       {
  48         count++;
  49       }
  50     }
  51
  52     return count;
  53   }
  54
  55   public int getWidth()
  56   {
  57     int width = 0;
  58     for (int i = 0; i < hiddenSequences.length; i++)
  59     {
  60       if (hiddenSequences[i] != null
  61               && hiddenSequences[i].getLength() > width)
  62       {
  63         width = hiddenSequences[i].getLength();
  64       }
  65     }
  66
  67     return width;
  68   }
  69
  70   /**
  71    * Call this method if sequences are removed from the main alignment
  72    */
  73   public void adjustHeightSequenceDeleted(int seqIndex)
  74   {
  75     if (hiddenSequences == null)
  76     {
  77       return;
  78     }
  79
  80     int alHeight = alignment.getHeight();
  81
  82     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
  83     int deletionIndex = adjustForHiddenSeqs(seqIndex);
  84
  85     for (int i = 0; i < hiddenSequences.length; i++)
  86     {
  87       if (hiddenSequences[i] == null)
  88       {
  89         continue;
  90       }
  91
  92       if (i > deletionIndex)
  93       {
  94         tmp[i - 1] = hiddenSequences[i];
  95       }
  96       else
  97       {
  98         tmp[i] = hiddenSequences[i];
  99       }
 100     }
 101
 102     hiddenSequences = tmp;
 103
 104   }
 105
 106   /**
 107    * Call this method if sequences are added to or removed from the main
 108    * alignment
 109    */
 110   public void adjustHeightSequenceAdded()
 111   {
 112     if (hiddenSequences == null)
 113     {
 114       return;
 115     }
 116
 117     int alHeight = alignment.getHeight();
 118
 119     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
 120     System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
 121     hiddenSequences = tmp;
 122   }
 123
 124   public void hideSequence(SequenceI sequence)
 125   {
 126     if (hiddenSequences == null)
 127     {
 128       hiddenSequences = new SequenceI[alignment.getHeight()];
 129     }
 130
 131     int alignmentIndex = alignment.findIndex(sequence);
 132     alignmentIndex = adjustForHiddenSeqs(alignmentIndex);
 133
 134     if (hiddenSequences[alignmentIndex] != null)
 135     {
 136       System.out.println("ERROR!!!!!!!!!!!");
 137     }
 138
 139     hiddenSequences[alignmentIndex] = sequence;
 140
 141     alignment.deleteSequence(sequence);
 142   }
 143
 144   public Vector showAll(Hashtable hiddenReps)
 145   {
 146     Vector revealedSeqs = new Vector();
 147     for (int i = 0; i < hiddenSequences.length; i++)
 148     {
 149       if (hiddenSequences[i] != null)
 150       {
 151         Vector tmp = showSequence(i, hiddenReps);
 152         for (int t = 0; t < tmp.size(); t++)
 153         {
 154           revealedSeqs.addElement(tmp.elementAt(t));
 155         }
 156       }
 157     }
 158     return revealedSeqs;
 159   }
 160
 161   public Vector showSequence(int alignmentIndex, Hashtable hiddenReps)
 162   {
 163     Vector revealedSeqs = new Vector();
 164     SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
 165     if (repSequence != null && hiddenReps != null
 166             && hiddenReps.containsKey(repSequence))
 167     {
 168       hiddenReps.remove(repSequence);
 169       revealedSeqs.addElement(repSequence);
 170     }
 171
 172     int start = adjustForHiddenSeqs(alignmentIndex - 1);
 173     int end = adjustForHiddenSeqs(alignmentIndex);
 174     if (end >= hiddenSequences.length)
 175     {
 176       end = hiddenSequences.length - 1;
 177     }
 178
 179     for (int index = end; index > start; index--)
 180     {
 181       SequenceI seq = hiddenSequences[index];
 182       hiddenSequences[index] = null;
 183
 184       if (seq != null)
 185       {
 186         if (seq.getLength() > 0)
 187         {
 188           revealedSeqs.addElement(seq);
 189           alignment.getSequences().insertElementAt(seq, alignmentIndex);
 190         }
 191         else
 192         {
 193           System.out.println(seq.getName()
 194                   + " has been deleted whilst hidden");
 195         }
 196       }
 197
 198     }
 199
 200     return revealedSeqs;
 201   }
 202
 203   public SequenceI getHiddenSequence(int alignmentIndex)
 204   {
 205     return hiddenSequences[alignmentIndex];
 206   }
 207
 208   public int findIndexWithoutHiddenSeqs(int alignmentIndex)
 209   {
 210     int index = 0;
 211     int hiddenSeqs = 0;
 212     if (hiddenSequences.length <= alignmentIndex)
 213     {
 214       alignmentIndex = hiddenSequences.length - 1;
 215     }
 216
 217     while (index <= alignmentIndex)
 218     {
 219       if (hiddenSequences[index] != null)
 220       {
 221         hiddenSeqs++;
 222       }
 223       index++;
 224     }
 225     ;
 226
 227     return (alignmentIndex - hiddenSeqs);
 228   }
 229
 230   public int adjustForHiddenSeqs(int alignmentIndex)
 231   {
 232     int index = 0;
 233     int hSize = hiddenSequences.length;
 234     while (index <= alignmentIndex && index < hSize)
 235     {
 236       if (hiddenSequences[index] != null)
 237       {
 238         alignmentIndex++;
 239       }
 240       index++;
 241     }
 242     ;
 243
 244     return alignmentIndex;
 245   }
 246
 247   public AlignmentI getFullAlignment()
 248   {
 249     int isize = hiddenSequences.length;
 250     SequenceI[] seq = new Sequence[isize];
 251
 252     int index = 0;
 253     for (int i = 0; i < hiddenSequences.length; i++)
 254     {
 255       if (hiddenSequences[i] != null)
 256       {
 257         seq[i] = hiddenSequences[i];
 258       }
 259       else
 260       {
 261         seq[i] = alignment.getSequenceAt(index);
 262         index++;
 263       }
 264     }
 265
 266     return new Alignment(seq);
 267   }
 268
 269   public boolean isHidden(SequenceI seq)
 270   {
 271     for (int i = 0; i < hiddenSequences.length; i++)
 272     {
 273       if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
 274       {
 275         return true;
 276       }
 277     }
 278
 279     return false;
 280   }
 281 }