src/jalview/datamodel/HiddenSequences.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.4)
   3  * Copyright (C) 2008 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   AlignmentI alignment;
  30
  31   public HiddenSequences(AlignmentI al)
  32   {
  33     alignment = al;
  34   }
  35
  36   public int getSize()
  37   {
  38     if (hiddenSequences == null)
  39     {
  40       return 0;
  41     }
  42     int count = 0;
  43     for (int i = 0; i < hiddenSequences.length; i++)
  44     {
  45       if (hiddenSequences[i] != null)
  46       {
  47         count++;
  48       }
  49     }
  50
  51     return count;
  52   }
  53
  54   public int getWidth()
  55   {
  56     int width = 0;
  57     for (int i = 0; i < hiddenSequences.length; i++)
  58     {
  59       if (hiddenSequences[i] != null && hiddenSequences[i].getLength() > width)
  60       {
  61         width = hiddenSequences[i].getLength();
  62       }
  63     }
  64
  65     return width;
  66   }
  67
  68   /**
  69    * Call this method if sequences are removed from the
  70    * main alignment
  71    */
  72   public void adjustHeightSequenceDeleted(int seqIndex)
  73   {
  74     if (hiddenSequences == null)
  75     {
  76       return;
  77     }
  78
  79     int alHeight = alignment.getHeight();
  80
  81     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
  82     int deletionIndex = adjustForHiddenSeqs(seqIndex);
  83
  84     for (int i = 0; i < hiddenSequences.length; i++)
  85     {
  86       if (hiddenSequences[i] == null)
  87       {
  88         continue;
  89       }
  90
  91       if (i > deletionIndex)
  92       {
  93         tmp[i - 1] = hiddenSequences[i];
  94       }
  95       else
  96       {
  97         tmp[i] = hiddenSequences[i];
  98       }
  99     }
 100
 101     hiddenSequences = tmp;
 102
 103   }
 104
 105   /**
 106    * Call this method if sequences are added to or removed from the
 107    * main alignment
 108    */
 109   public void adjustHeightSequenceAdded()
 110   {
 111     if (hiddenSequences == null)
 112     {
 113       return;
 114     }
 115
 116     int alHeight = alignment.getHeight();
 117
 118     SequenceI[] tmp = new SequenceI[alHeight + getSize()];
 119     System.arraycopy(hiddenSequences, 0, tmp, 0, hiddenSequences.length);
 120     hiddenSequences = tmp;
 121   }
 122
 123   public void hideSequence(SequenceI sequence)
 124   {
 125     if (hiddenSequences == null)
 126     {
 127       hiddenSequences = new SequenceI[alignment.getHeight()];
 128     }
 129
 130     int alignmentIndex = alignment.findIndex(sequence);
 131     alignmentIndex = adjustForHiddenSeqs(alignmentIndex);
 132
 133     if (hiddenSequences[alignmentIndex] != null)
 134     {
 135       System.out.println("ERROR!!!!!!!!!!!");
 136     }
 137
 138     hiddenSequences[alignmentIndex] = sequence;
 139
 140     alignment.deleteSequence(sequence);
 141   }
 142
 143   public Vector showAll(Hashtable hiddenReps)
 144   {
 145     Vector revealedSeqs = new Vector();
 146     for (int i = 0; i < hiddenSequences.length; i++)
 147     {
 148       if (hiddenSequences[i] != null)
 149       {
 150         Vector tmp = showSequence(i, hiddenReps);
 151         for (int t = 0; t < tmp.size(); t++)
 152         {
 153           revealedSeqs.addElement(tmp.elementAt(t));
 154         }
 155       }
 156     }
 157     return revealedSeqs;
 158   }
 159
 160   public Vector showSequence(int alignmentIndex, Hashtable hiddenReps)
 161   {
 162     Vector revealedSeqs = new Vector();
 163     SequenceI repSequence = alignment.getSequenceAt(alignmentIndex);
 164     if (repSequence != null &&
 165         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() + " has been deleted whilst hidden");
 194         }
 195       }
 196
 197     }
 198
 199     return revealedSeqs;
 200   }
 201
 202   public SequenceI getHiddenSequence(int alignmentIndex)
 203   {
 204     return hiddenSequences[alignmentIndex];
 205   }
 206
 207   public int findIndexWithoutHiddenSeqs(int alignmentIndex)
 208   {
 209     int index = 0;
 210     int hiddenSeqs = 0;
 211     if (hiddenSequences.length <= alignmentIndex)
 212     {
 213       alignmentIndex = hiddenSequences.length - 1;
 214     }
 215
 216     while (index <= alignmentIndex)
 217     {
 218       if (hiddenSequences[index] != null)
 219       {
 220         hiddenSeqs++;
 221       }
 222       index++;
 223     }
 224     ;
 225
 226     return (alignmentIndex - hiddenSeqs);
 227   }
 228
 229   public int adjustForHiddenSeqs(int alignmentIndex)
 230   {
 231     int index = 0;
 232     int hSize = hiddenSequences.length;
 233     while (index <= alignmentIndex && index < hSize)
 234     {
 235       if (hiddenSequences[index] != null)
 236       {
 237         alignmentIndex++;
 238       }
 239       index++;
 240     }
 241     ;
 242
 243     return alignmentIndex;
 244   }
 245
 246   public AlignmentI getFullAlignment()
 247   {
 248     int isize = hiddenSequences.length;
 249     SequenceI[] seq = new Sequence[isize];
 250
 251     int index = 0;
 252     for (int i = 0; i < hiddenSequences.length; i++)
 253     {
 254       if (hiddenSequences[i] != null)
 255       {
 256         seq[i] = hiddenSequences[i];
 257       }
 258       else
 259       {
 260         seq[i] = alignment.getSequenceAt(index);
 261         index++;
 262       }
 263     }
 264
 265     return new Alignment(seq);
 266   }
 267
 268   public boolean isHidden(SequenceI seq)
 269   {
 270     for (int i = 0; i < hiddenSequences.length; i++)
 271     {
 272       if (hiddenSequences[i] != null && hiddenSequences[i] == seq)
 273       {
 274         return true;
 275       }
 276     }
 277
 278     return false;
 279   }
 280 }