copy constructors and AlignmentAnnotation sequenceRef mechanisms for pasting sequence...

diff --git a/src/jalview/datamodel/Alignment.java b/src/jalview/datamodel/Alignment.java
index b2a647a..d26314e 100755 (executable)
--- a/src/jalview/datamodel/Alignment.java
+++ b/src/jalview/datamodel/Alignment.java
@@ -139,25 +139,26 @@ public class Alignment
   {
     if (dataset != null)
     {
+      // maintain dataset integrity
       if (snew.getDatasetSequence() != null)
       {
         getDataset().addSequence(snew.getDatasetSequence());
       }
       else
       {
-        Sequence ds = new Sequence(snew.getName(),
-                                   AlignSeq.extractGaps("-. ",
-            snew.getSequenceAsString()),
-                                   snew.getStart(),
-                                   snew.getEnd());
-
-        snew.setDatasetSequence(ds);
-        getDataset().addSequence(ds);
+        // derive new sequence
+        SequenceI adding = snew.deriveSequence();
+        getDataset().addSequence(adding.getDatasetSequence());
+        snew = adding;        
       }
     }
-    sequences.addElement(snew);
-
-    hiddenSequences.adjustHeightSequenceAdded();
+    if (sequences==null) {
+      initAlignment(new SequenceI[] { snew });
+    } else {
+      sequences.addElement(snew);
+    }
+    if (hiddenSequences!=null)
+      hiddenSequences.adjustHeightSequenceAdded();
   }
 
   /** Adds a sequence to the alignment.  Recalculates maxLength and size.

diff --git a/src/jalview/datamodel/AlignmentAnnotation.java b/src/jalview/datamodel/AlignmentAnnotation.java
index c675a75..8d8a118 100755 (executable)
--- a/src/jalview/datamodel/AlignmentAnnotation.java
+++ b/src/jalview/datamodel/AlignmentAnnotation.java
@@ -18,6 +18,10 @@
  */
 package jalview.datamodel;
 
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Vector;
+
 /**
  * DOCUMENT ME!
  *
@@ -170,7 +174,6 @@ public class AlignmentAnnotation
 
     annotationId = this.hashCode() + "";
   }
-
   /**
    * Creates a new AlignmentAnnotation object.
    *
@@ -190,9 +193,23 @@ public class AlignmentAnnotation
     this.description = description;
     this.annotations = annotations;
     graph = graphType;
-
+    graphMin = min;
+    graphMax = max;
+    validateRangeAndDisplay();
+  }
+  /**
+   * checks graphMin and graphMax,
+   * secondary structure symbols,
+   * sets graphType appropriately,
+   * sets null labels to the empty string
+   * if appropriate.
+   */
+  private void validateRangeAndDisplay() {
+    int graphType = graph;
+    float min = graphMin;
+    float max = graphMax;
     boolean drawValues = true;
-
+    
     if (min == max)
     {
       min = 999999999;
@@ -236,6 +253,57 @@ public class AlignmentAnnotation
       }
     }
   }
+  
+  /**
+   * Copy constructor
+   * creates a new independent annotation row with the same associated sequenceRef 
+   * @param annotation
+   */
+  public AlignmentAnnotation(AlignmentAnnotation annotation)
+  {
+    this.label = new String(annotation.label);
+    this.description = new String(annotation.description);
+    this.graphMin = annotation.graphMin;
+    this.graphMax = annotation.graphMax;
+    this.graph = annotation.graph;
+    this.graphHeight = annotation.graphHeight;
+    this.graphGroup = annotation.graphGroup;
+    this.editable = annotation.editable;
+    this.autoCalculated = annotation.autoCalculated;
+    this.hasIcons = annotation.hasIcons;
+    this.hasText = annotation.hasText;
+    this.height = annotation.height;
+    this.label = annotation.label;
+    if (threshold!=null) {
+      threshold = new GraphLine(annotation.threshold);
+    }
+    if (annotation.annotations!=null) {
+      Vector anvec = new Vector();
+      Annotation[] ann = annotation.annotations;
+      this.annotations = new Annotation[ann.length];
+      for (int i=0; i<ann.length; i++) {
+        annotations[i] = new Annotation(ann[i]);
+        anvec.add(ann[i]); // for lookup if sequenceMapping exists.
+      };
+      if (annotation.sequenceRef!=null) {
+        this.sequenceRef = annotation.sequenceRef;
+        if (annotation.sequenceMapping!=null)
+        {
+          sequenceMapping = new Hashtable();
+          Enumeration pos=annotation.sequenceMapping.keys();
+          while (pos.hasMoreElements()) {
+            Integer p = (Integer) pos.nextElement();
+            Annotation a = (Annotation) sequenceMapping.get(p);
+            sequenceMapping.put(p, annotations[anvec.indexOf(a)]); 
+          }
+          anvec.clear();
+        } else {
+          this.sequenceMapping = null;
+        }
+      }
+    }
+    validateRangeAndDisplay(); // construct hashcodes, etc.
+  }
 
   /**
    * DOCUMENT ME!
@@ -337,6 +405,9 @@ public class AlignmentAnnotation
 
   public void adjustForAlignment()
   {
+    if (sequenceRef==null)
+      return;
+    
     int a = 0, aSize = sequenceRef.getLength();
 
     if (aSize == 0)
@@ -362,4 +433,60 @@ public class AlignmentAnnotation
 
     annotations = temp;
   }
+  /**
+   * remove any null entries in annotation row and return the
+   * number of non-null annotation elements.
+   * @return
+   */
+  private int compactAnnotationArray() {
+    int j=0;
+    for (int i=0;i<annotations.length; i++) {
+      if (annotations[i]!=null && j!=i) {
+        annotations[j++] = annotations[i];
+      }
+    }
+    Annotation[] ann = annotations;
+    annotations = new Annotation[j];
+    System.arraycopy(ann, 0, annotations, 0, j);
+    ann = null;
+    return j;
+  }
+  
+  /**
+   * Associate this annotion with the aligned residues of a particular sequence.
+   * sequenceMapping will be updated in the following way:
+   *   null sequenceI - existing mapping will be discarded but annotations left in mapped positions.
+   *   valid sequenceI not equal to current sequenceRef: mapping is discarded and rebuilt assuming 1:1 correspondence
+   *   TODO: overload with parameter to specify correspondence between current and new sequenceRef
+   * @param sequenceI
+   */
+  public void setSequenceRef(SequenceI sequenceI)
+  {
+    if (sequenceI!=null) {
+      if (sequenceRef!=null) {
+        if (sequenceRef!=sequenceI && !sequenceRef.equals(sequenceI)) {
+          // throw away old mapping and reconstruct.
+          sequenceRef=null;
+          if (sequenceMapping!=null) 
+          {
+            sequenceMapping=null;
+            // compactAnnotationArray();
+          }
+          createSequenceMapping(sequenceI, 1,true);
+          adjustForAlignment();
+        } else {
+          // Mapping carried over
+          sequenceRef = sequenceI;
+        }
+      } else {
+        // No mapping exists
+        createSequenceMapping(sequenceI, 1, true);
+        adjustForAlignment();
+      }
+    } else {
+      // throw away the mapping without compacting.
+      sequenceMapping=null;
+      sequenceRef = null;
+    }
+  }
 }

diff --git a/src/jalview/datamodel/AlignmentI.java b/src/jalview/datamodel/AlignmentI.java
index bfa0676..ab198c1 100755 (executable)
--- a/src/jalview/datamodel/AlignmentI.java
+++ b/src/jalview/datamodel/AlignmentI.java
@@ -167,53 +167,64 @@ public interface AlignmentI
    * Adds a new AlignmentAnnotation to this alignment
    */
   public void addAnnotation(AlignmentAnnotation aa);
-
+  /**
+   * moves annotation to a specified index in alignment annotation display stack
+   * @param aa the annotation object to be moved
+   * @param index the destination position
+   */
   public void setAnnotationIndex(AlignmentAnnotation aa, int index);
 
   /**
    * Deletes a specific AlignmentAnnotation from the alignment.
    *
-   * @param aa DOCUMENT ME!
+   * @param aa the annotation to delete
    */
   public void deleteAnnotation(AlignmentAnnotation aa);
 
   /**
-   * DOCUMENT ME!
+   * Get the annotation associated with this alignment
    *
-   * @return DOCUMENT ME!
+   * @return array of AlignmentAnnotation objects
    */
   public AlignmentAnnotation[] getAlignmentAnnotation();
 
   /**
-   * DOCUMENT ME!
+   * Change the gap character used in this alignment to 'gc'
    *
-   * @param gc DOCUMENT ME!
+   * @param gc the new gap character.
    */
   public void setGapCharacter(char gc);
 
   /**
-   * DOCUMENT ME!
+   * Get the gap character used in this alignment
    *
-   * @return DOCUMENT ME!
+   * @return gap character
    */
   public char getGapCharacter();
 
   /**
-   * Returns true if alignment is nucleotide sequence
+   * Test for all nucleotide alignment
    *
-   * @return DOCUMENT ME!
+   * @return true if alignment is nucleotide sequence
    */
   public boolean isNucleotide();
 
   /**
-   * Set true if the alignment is a nucleotide sequence
+   * Set alignment to be a nucleotide sequence
    *
-   * @return
    */
   public void setNucleotide(boolean b);
 
+  /**
+   * Get the associated dataset for the alignment.
+   * @return Alignment containing dataset sequences or null of this is a dataset.
+   */
   public Alignment getDataset();
 
+  /**
+   * Set the associated dataset for the alignment, or create one.
+   * @param dataset The dataset alignment or null to construct one. 
+   */
   public void setDataset(Alignment dataset);
 
   /**

diff --git a/src/jalview/datamodel/DBRefEntry.java b/src/jalview/datamodel/DBRefEntry.java
index b5a9ded..e5eecbb 100755 (executable)
--- a/src/jalview/datamodel/DBRefEntry.java
+++ b/src/jalview/datamodel/DBRefEntry.java
@@ -30,9 +30,17 @@ public class DBRefEntry
   }
   public DBRefEntry(String source, String version, String accessionId)
   {
+    this(source, version, accessionId, null);
+  }
+  public DBRefEntry(String source, String version, String accessionId, Mapping map) {
     this.source = source;
     this.version = version;
     this.accessionId = accessionId;
+    this.map = map;
+  }
+  public DBRefEntry(DBRefEntry entry)
+  {
+    this(new String(entry.source), new String(entry.version), new String(entry.accessionId), new Mapping(entry.map));
   }
   public boolean equals(DBRefEntry entry) {
       if (entry==this)

diff --git a/src/jalview/datamodel/GraphLine.java b/src/jalview/datamodel/GraphLine.java
index 33ad62c..77b7ef5 100755 (executable)
--- a/src/jalview/datamodel/GraphLine.java
+++ b/src/jalview/datamodel/GraphLine.java
@@ -1,41 +1,49 @@
-/*\r
- * Jalview - A Sequence Alignment Editor and Viewer\r
- * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
- *\r
- * This program is free software; you can redistribute it and/or\r
- * modify it under the terms of the GNU General Public License\r
- * as published by the Free Software Foundation; either version 2\r
- * of the License, or (at your option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
- * GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software\r
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
- */\r
-package jalview.datamodel;\r
-\r
-public class GraphLine\r
-{\r
-  public float value;\r
-  public String label = "";\r
-  public java.awt.Color colour = java.awt.Color.black;\r
-  public boolean displayed = true;\r
-\r
-  public GraphLine(float value, String label, java.awt.Color col)\r
-  {\r
-    this.value = value;\r
-    if (label != null)\r
-    {\r
-      this.label = label;\r
-    }\r
-\r
-    if (col != null)\r
-    {\r
-      this.colour = col;\r
-    }\r
-  }\r
-}\r
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2007 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;
+
+public class GraphLine
+{
+  public float value;
+  public String label = "";
+  public java.awt.Color colour = java.awt.Color.black;
+  public boolean displayed = true;
+
+  public GraphLine(float value, String label, java.awt.Color col)
+  {
+    this.value = value;
+    if (label != null)
+    {
+      this.label = label;
+    }
+
+    if (col != null)
+    {
+      this.colour = col;
+    }
+  }
+  public GraphLine(GraphLine from) {
+    if (from!=null) {
+      value = from.value;
+      label = new String(from.label);
+      colour = from.colour;
+      displayed = from.displayed;
+    }
+  }
+}

diff --git a/src/jalview/datamodel/PDBEntry.java b/src/jalview/datamodel/PDBEntry.java
index 16f8864..7cd6a80 100755 (executable)
--- a/src/jalview/datamodel/PDBEntry.java
+++ b/src/jalview/datamodel/PDBEntry.java
@@ -1,73 +1,81 @@
-/*\r
- * Jalview - A Sequence Alignment Editor and Viewer\r
- * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
- *\r
- * This program is free software; you can redistribute it and/or\r
- * modify it under the terms of the GNU General Public License\r
- * as published by the Free Software Foundation; either version 2\r
- * of the License, or (at your option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
- * GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software\r
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
- */\r
-package jalview.datamodel;\r
-\r
-import java.util.*;\r
-\r
-public class PDBEntry\r
-{\r
-  String file;\r
-  String type;\r
-  String id;\r
-  Hashtable properties;\r
-\r
-  public PDBEntry()\r
-  {}\r
-\r
-  public void setFile(String file)\r
-  {\r
-    this.file = file;\r
-  }\r
-\r
-  public String getFile()\r
-  {\r
-    return file;\r
-  }\r
-\r
-  public void setType(String type)\r
-  {\r
-    this.type = type;\r
-  }\r
-\r
-  public String getType()\r
-  {\r
-    return type;\r
-  }\r
-\r
-  public void setId(String id)\r
-  {\r
-    this.id = id;\r
-  }\r
-\r
-  public String getId()\r
-  {\r
-    return id;\r
-  }\r
-\r
-  public void setProperty(Hashtable property)\r
-  {\r
-    this.properties = property;\r
-  }\r
-\r
-  public Hashtable getProperty()\r
-  {\r
-    return properties;\r
-  }\r
-\r
-}\r
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2007 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.*;
+
+public class PDBEntry
+{
+  String file;
+  String type;
+  String id;
+  Hashtable properties;
+
+  public PDBEntry()
+  {}
+  public PDBEntry(PDBEntry entry) {
+    file = entry.file;
+    type = entry.type;
+    id = entry.id;
+    if (entry.properties!=null)
+    {
+      properties = (Hashtable) entry.properties.clone();
+    }
+  }
+  public void setFile(String file)
+  {
+    this.file = file;
+  }
+
+  public String getFile()
+  {
+    return file;
+  }
+
+  public void setType(String type)
+  {
+    this.type = type;
+  }
+
+  public String getType()
+  {
+    return type;
+  }
+
+  public void setId(String id)
+  {
+    this.id = id;
+  }
+
+  public String getId()
+  {
+    return id;
+  }
+
+  public void setProperty(Hashtable property)
+  {
+    this.properties = property;
+  }
+
+  public Hashtable getProperty()
+  {
+    return properties;
+  }
+
+}

diff --git a/src/jalview/datamodel/Sequence.java b/src/jalview/datamodel/Sequence.java
index 92c8dff..098fdff 100755 (executable)
--- a/src/jalview/datamodel/Sequence.java
+++ b/src/jalview/datamodel/Sequence.java
@@ -130,8 +130,8 @@ public class Sequence
   }
 
   /**
-   * Creates a new Sequence object.
-   *
+   * Creates a new Sequence object with new features, DBRefEntries, AlignmentAnnotations, and PDBIds
+   * but inherits any existing dataset sequence reference.
    * @param seq DOCUMENT ME!
    */
   public Sequence(SequenceI seq)
@@ -141,6 +141,34 @@ public class Sequence
          seq.getStart(),
          seq.getEnd());
     description = seq.getDescription();
+    if (seq.getSequenceFeatures()!=null) {
+      SequenceFeature[] sf = seq.getSequenceFeatures();
+      for (int i=0; i<sf.length; i++) {
+        addSequenceFeature(new SequenceFeature(sf[i]));
+      }
+    }
+    if (seq.getDBRef()!=null) {
+      DBRefEntry[] dbr = seq.getDBRef();
+      for (int i=0; i<dbr.length; i++) {
+        addDBRef(new DBRefEntry(dbr[i]));
+      }
+    }
+    setDatasetSequence(seq.getDatasetSequence());
+    if (seq.getAnnotation()!=null) {
+      AlignmentAnnotation[] sqann = seq.getAnnotation();
+      for (int i=0;i<sqann.length; i++)
+      {
+        AlignmentAnnotation newann = new AlignmentAnnotation(sqann[i]);
+        addAlignmentAnnotation(newann);
+      }
+    }
+    if (seq.getPDBId()!=null) {
+      Vector ids = seq.getPDBId();
+      Enumeration e = ids.elements();
+      while (e.hasMoreElements()) {
+        this.addPDBId(new PDBEntry((PDBEntry) e.nextElement()));
+      }
+    }
   }
 
 
@@ -476,11 +504,11 @@ public class Sequence
   }
 
   /**
-   * DOCUMENT ME!
+   * Return the alignment position for a sequence position
    *
-   * @param pos DOCUMENT ME!
+   * @param pos lying from start to end
    *
-   * @return DOCUMENT ME!
+   * @return aligned position of residue pos
    */
   public int findIndex(int pos)
   {
@@ -731,6 +759,7 @@ public class Sequence
     }
 
     this.annotation.addElement(annotation);
+    annotation.setSequenceRef(this);
   }
 
 
@@ -759,20 +788,43 @@ public class Sequence
    */
   public SequenceI deriveSequence()
   {
-      SequenceI seq = new Sequence(name, sequence, start, end);
-      seq.setDescription(description);
+    SequenceI seq=new Sequence(this);
     if (datasetSequence != null)
     {
-          seq.setDatasetSequence(datasetSequence);
+      // duplicate current sequence with same dataset
+      seq.setDatasetSequence(datasetSequence);
     }
     else
     {
-          if (isValidDatasetSequence())
+      if (isValidDatasetSequence())
+      {
+        // Use this as dataset sequence
+        seq.setDatasetSequence(this);
+      } else {
+        // Create a new, valid dataset sequence
+        SequenceI ds = seq;
+        ds.setSequence(AlignSeq.extractGaps(jalview.util.Comparison.GapChars, new String(sequence)));
+        setDatasetSequence(ds);
+        seq = this; // and return this sequence as the derived sequence.
+      }
+    }
+    return seq;
+  }
+  /* (non-Javadoc)
+   * @see jalview.datamodel.SequenceI#setAlignmentAnnotation(AlignmmentAnnotation[] annotations)
+   */
+  public void setAlignmentAnnotation(AlignmentAnnotation[] annotations)
+  {
+    if (annotation!=null) {
+      annotation.clear();
+    }
+    if (annotations!=null) {
+      for (int i=0; i<annotations.length; i++)
       {
-              seq.setDatasetSequence(this);
+        if (annotations[i]!=null)
+          addAlignmentAnnotation(annotations[i]);
       }
     }
-      return seq;
   }
 
 }

diff --git a/src/jalview/datamodel/SequenceGroup.java b/src/jalview/datamodel/SequenceGroup.java
index e22042c..bae5863 100755 (executable)
--- a/src/jalview/datamodel/SequenceGroup.java
+++ b/src/jalview/datamodel/SequenceGroup.java
@@ -1,600 +1,600 @@
-/*\r
- * Jalview - A Sequence Alignment Editor and Viewer\r
- * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
- *\r
- * This program is free software; you can redistribute it and/or\r
- * modify it under the terms of the GNU General Public License\r
- * as published by the Free Software Foundation; either version 2\r
- * of the License, or (at your option) any later version.\r
- *\r
- * This program is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
- * GNU General Public License for more details.\r
- *\r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software\r
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
- */\r
-package jalview.datamodel;\r
-\r
-import java.util.*;\r
-\r
-import java.awt.*;\r
-\r
-import jalview.analysis.*;\r
-import jalview.schemes.*;\r
-\r
-/**\r
- * DOCUMENT ME!\r
- *\r
- * @author $author$\r
- * @version $Revision$\r
- */\r
-public class SequenceGroup\r
-{\r
-  String groupName;\r
-  String description;\r
-  Conservation conserve;\r
-  Vector aaFrequency;\r
-  boolean displayBoxes = true;\r
-  boolean displayText = true;\r
-  boolean colourText = true;\r
-  private Vector sequences = new Vector();\r
-  int width = -1;\r
-\r
-  /** DOCUMENT ME!! */\r
-  public ColourSchemeI cs;\r
-  int startRes = 0;\r
-  int endRes = 0;\r
-  Color outlineColour = Color.black;\r
-  public int thresholdTextColour = 0;\r
-  public Color textColour = Color.black;\r
-  public Color textColour2 = Color.white;\r
-\r
-  /**\r
-   * Creates a new SequenceGroup object.\r
-   */\r
-  public SequenceGroup()\r
-  {\r
-    groupName = "JGroup:" + this.hashCode();\r
-  }\r
-\r
-  /**\r
-   * Creates a new SequenceGroup object.\r
-   *\r
-   * @param sequences DOCUMENT ME!\r
-   * @param groupName DOCUMENT ME!\r
-   * @param scheme DOCUMENT ME!\r
-   * @param displayBoxes DOCUMENT ME!\r
-   * @param displayText DOCUMENT ME!\r
-   * @param colourText DOCUMENT ME!\r
-   * @param start DOCUMENT ME!\r
-   * @param end DOCUMENT ME!\r
-   */\r
-  public SequenceGroup(Vector sequences, String groupName,\r
-                       ColourSchemeI scheme, boolean displayBoxes,\r
-                       boolean displayText,\r
-                       boolean colourText, int start, int end)\r
-  {\r
-    this.sequences = sequences;\r
-    this.groupName = groupName;\r
-    this.displayBoxes = displayBoxes;\r
-    this.displayText = displayText;\r
-    this.colourText = colourText;\r
-    this.cs = scheme;\r
-    startRes = start;\r
-    endRes = end;\r
-    recalcConservation();\r
-  }\r
-\r
-  public SequenceI[] getSelectionAsNewSequences(AlignmentI align)\r
-  {\r
-    int iSize = sequences.size();\r
-    SequenceI[] seqs = new SequenceI[iSize];\r
-    SequenceI[] inorder = getSequencesInOrder(align);\r
-\r
-    for (int i = 0; i < iSize; i++)\r
-    {\r
-      SequenceI seq = inorder[i];\r
-\r
-      seqs[i] = new Sequence(seq.getName(),\r
-                             seq.getSequence(startRes, endRes + 1),\r
-                             seq.findPosition(startRes),\r
-                             findEndRes(seq));\r
-\r
-      seqs[i].setDescription(seq.getDescription());\r
-      seqs[i].setDBRef(seq.getDBRef());\r
-      seqs[i].setSequenceFeatures(seq.getSequenceFeatures());\r
-      if (seq.getDatasetSequence() != null)\r
-      {\r
-        seqs[i].setDatasetSequence(seq.getDatasetSequence());\r
-      }\r
-\r
-      if (seq.getAnnotation() != null)\r
-      {\r
-        for (int a = 0; a < seq.getAnnotation().length; a++)\r
-        {\r
-          seqs[i].addAlignmentAnnotation(seq.getAnnotation()[a]);\r
-        }\r
-      }\r
-    }\r
-\r
-    return seqs;\r
-\r
-  }\r
-\r
-  /**\r
-   * If sequence ends in gaps, the end residue can\r
-   * be correctly calculated here\r
-   * @param seq SequenceI\r
-   * @return int\r
-   */\r
-  public int findEndRes(SequenceI seq)\r
-  {\r
-    int eres = 0;\r
-    char ch;\r
-\r
-    for (int j = 0; j < endRes + 1 && j < seq.getLength(); j++)\r
-    {\r
-      ch = seq.getCharAt(j);\r
-      if (!jalview.util.Comparison.isGap( (ch)))\r
-      {\r
-        eres++;\r
-      }\r
-    }\r
-\r
-    if (eres > 0)\r
-    {\r
-      eres += seq.getStart() - 1;\r
-    }\r
-\r
-    return eres;\r
-  }\r
-\r
-  public Vector getSequences(Hashtable hiddenReps)\r
-  {\r
-    if (hiddenReps == null)\r
-    {\r
-      return sequences;\r
-    }\r
-    else\r
-    {\r
-      Vector allSequences = new Vector();\r
-      SequenceI seq, seq2;\r
-      for (int i = 0; i < sequences.size(); i++)\r
-      {\r
-        seq = (SequenceI) sequences.elementAt(i);\r
-        allSequences.addElement(seq);\r
-        if (hiddenReps.containsKey(seq))\r
-        {\r
-          SequenceGroup hsg = (SequenceGroup) hiddenReps.get(seq);\r
-          for (int h = 0; h < hsg.getSize(); h++)\r
-          {\r
-            seq2 = hsg.getSequenceAt(h);\r
-            if (seq2 != seq\r
-                && !allSequences.contains(seq2))\r
-            {\r
-              allSequences.addElement(seq2);\r
-            }\r
-          }\r
-        }\r
-      }\r
-\r
-      return allSequences;\r
-    }\r
-  }\r
-\r
-  public SequenceI[] getSequencesAsArray(Hashtable hiddenReps)\r
-  {\r
-    Vector tmp = getSequences(hiddenReps);\r
-    if (tmp == null)\r
-    {\r
-      return null;\r
-    }\r
-    SequenceI[] result = new SequenceI[tmp.size()];\r
-    for (int i = 0; i < result.length; i++)\r
-    {\r
-      result[i] = (SequenceI) tmp.elementAt(i);\r
-    }\r
-\r
-    return result;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param col DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public boolean adjustForRemoveLeft(int col)\r
-  {\r
-    // return value is true if the group still exists\r
-    if (startRes >= col)\r
-    {\r
-      startRes = startRes - col;\r
-    }\r
-\r
-    if (endRes >= col)\r
-    {\r
-      endRes = endRes - col;\r
-\r
-      if (startRes > endRes)\r
-      {\r
-        startRes = 0;\r
-      }\r
-    }\r
-    else\r
-    {\r
-      // must delete this group!!\r
-      return false;\r
-    }\r
-\r
-    return true;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param col DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public boolean adjustForRemoveRight(int col)\r
-  {\r
-    if (startRes > col)\r
-    {\r
-      // delete this group\r
-      return false;\r
-    }\r
-\r
-    if (endRes >= col)\r
-    {\r
-      endRes = col;\r
-    }\r
-\r
-    return true;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public String getName()\r
-  {\r
-    return groupName;\r
-  }\r
-\r
-  public String getDescription()\r
-  {\r
-    return description;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param name DOCUMENT ME!\r
-   */\r
-  public void setName(String name)\r
-  {\r
-    groupName = name;\r
-  }\r
-\r
-  public void setDescription(String desc)\r
-  {\r
-    description = desc;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public Conservation getConservation()\r
-  {\r
-    return conserve;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param c DOCUMENT ME!\r
-   */\r
-  public void setConservation(Conservation c)\r
-  {\r
-    conserve = c;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param s DOCUMENT ME!\r
-   * @param recalc DOCUMENT ME!\r
-   */\r
-  public void addSequence(SequenceI s, boolean recalc)\r
-  {\r
-    if (s != null && !sequences.contains(s))\r
-    {\r
-      sequences.addElement(s);\r
-    }\r
-\r
-    if (recalc)\r
-    {\r
-      recalcConservation();\r
-    }\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   */\r
-  public void recalcConservation()\r
-  {\r
-    if (cs == null)\r
-    {\r
-      return;\r
-    }\r
-\r
-    try\r
-    {\r
-      cs.setConsensus(AAFrequency.calculate(sequences, startRes, endRes + 1));\r
-\r
-      if (cs instanceof ClustalxColourScheme)\r
-      {\r
-        ( (ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());\r
-      }\r
-\r
-      if (cs.conservationApplied())\r
-      {\r
-        Conservation c = new Conservation(groupName,\r
-                                          ResidueProperties.propHash, 3,\r
-                                          sequences,\r
-                                          startRes, endRes + 1);\r
-        c.calculate();\r
-        c.verdict(false, 25);\r
-\r
-        cs.setConservation(c);\r
-\r
-        if (cs instanceof ClustalxColourScheme)\r
-        {\r
-          ( (ClustalxColourScheme) cs).resetClustalX(sequences,\r
-              getWidth());\r
-        }\r
-      }\r
-    }\r
-    catch (java.lang.OutOfMemoryError err)\r
-    {\r
-      System.out.println("Out of memory loading groups: " + err);\r
-    }\r
-\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param s DOCUMENT ME!\r
-   * @param recalc DOCUMENT ME!\r
-   */\r
-  public void addOrRemove(SequenceI s, boolean recalc)\r
-  {\r
-    if (sequences.contains(s))\r
-    {\r
-      deleteSequence(s, recalc);\r
-    }\r
-    else\r
-    {\r
-      addSequence(s, recalc);\r
-    }\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param s DOCUMENT ME!\r
-   * @param recalc DOCUMENT ME!\r
-   */\r
-  public void deleteSequence(SequenceI s, boolean recalc)\r
-  {\r
-    sequences.removeElement(s);\r
-\r
-    if (recalc)\r
-    {\r
-      recalcConservation();\r
-    }\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public int getStartRes()\r
-  {\r
-    return startRes;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public int getEndRes()\r
-  {\r
-    return endRes;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param i DOCUMENT ME!\r
-   */\r
-  public void setStartRes(int i)\r
-  {\r
-    startRes = i;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param i DOCUMENT ME!\r
-   */\r
-  public void setEndRes(int i)\r
-  {\r
-    endRes = i;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public int getSize()\r
-  {\r
-    return sequences.size();\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param i DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public SequenceI getSequenceAt(int i)\r
-  {\r
-    return (SequenceI) sequences.elementAt(i);\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param state DOCUMENT ME!\r
-   */\r
-  public void setColourText(boolean state)\r
-  {\r
-    colourText = state;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public boolean getColourText()\r
-  {\r
-    return colourText;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param state DOCUMENT ME!\r
-   */\r
-  public void setDisplayText(boolean state)\r
-  {\r
-    displayText = state;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public boolean getDisplayText()\r
-  {\r
-    return displayText;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param state DOCUMENT ME!\r
-   */\r
-  public void setDisplayBoxes(boolean state)\r
-  {\r
-    displayBoxes = state;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public boolean getDisplayBoxes()\r
-  {\r
-    return displayBoxes;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public int getWidth()\r
-  {\r
-    // MC This needs to get reset when characters are inserted and deleted\r
-    if (sequences.size() > 0)\r
-    {\r
-      width = ( (SequenceI) sequences.elementAt(0)).getLength();\r
-    }\r
-\r
-    for (int i = 1; i < sequences.size(); i++)\r
-    {\r
-      SequenceI seq = (SequenceI) sequences.elementAt(i);\r
-\r
-      if (seq.getLength() > width)\r
-      {\r
-        width = seq.getLength();\r
-      }\r
-    }\r
-\r
-    return width;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @param c DOCUMENT ME!\r
-   */\r
-  public void setOutlineColour(Color c)\r
-  {\r
-    outlineColour = c;\r
-  }\r
-\r
-  /**\r
-   * DOCUMENT ME!\r
-   *\r
-   * @return DOCUMENT ME!\r
-   */\r
-  public Color getOutlineColour()\r
-  {\r
-    return outlineColour;\r
-  }\r
-\r
-  /**\r
-   *\r
-   * returns the sequences in the group ordered by the ordering given by al\r
-   *\r
-   * @param al Alignment\r
-   * @return SequenceI[]\r
-   */\r
-  public SequenceI[] getSequencesInOrder(AlignmentI al)\r
-  {\r
-    int sSize = sequences.size();\r
-    int alHeight = al.getHeight();\r
-\r
-    SequenceI[] seqs = new SequenceI[sSize];\r
-\r
-    int index = 0;\r
-    for (int i = 0; i < alHeight && index < sSize; i++)\r
-    {\r
-      if (sequences.contains(al.getSequenceAt(i)))\r
-      {\r
-        seqs[index++] = al.getSequenceAt(i);\r
-      }\r
-    }\r
-\r
-    return seqs;\r
-  }\r
-}\r
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2007 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.*;
+
+import java.awt.*;
+
+import jalview.analysis.*;
+import jalview.schemes.*;
+
+/**
+ * DOCUMENT ME!
+ *
+ * @author $author$
+ * @version $Revision$
+ */
+public class SequenceGroup
+{
+  String groupName;
+  String description;
+  Conservation conserve;
+  Vector aaFrequency;
+  boolean displayBoxes = true;
+  boolean displayText = true;
+  boolean colourText = true;
+  private Vector sequences = new Vector();
+  int width = -1;
+
+  /** DOCUMENT ME!! */
+  public ColourSchemeI cs;
+  int startRes = 0;
+  int endRes = 0;
+  Color outlineColour = Color.black;
+  public int thresholdTextColour = 0;
+  public Color textColour = Color.black;
+  public Color textColour2 = Color.white;
+
+  /**
+   * Creates a new SequenceGroup object.
+   */
+  public SequenceGroup()
+  {
+    groupName = "JGroup:" + this.hashCode();
+  }
+
+  /**
+   * Creates a new SequenceGroup object.
+   *
+   * @param sequences DOCUMENT ME!
+   * @param groupName DOCUMENT ME!
+   * @param scheme DOCUMENT ME!
+   * @param displayBoxes DOCUMENT ME!
+   * @param displayText DOCUMENT ME!
+   * @param colourText DOCUMENT ME!
+   * @param start DOCUMENT ME!
+   * @param end DOCUMENT ME!
+   */
+  public SequenceGroup(Vector sequences, String groupName,
+                       ColourSchemeI scheme, boolean displayBoxes,
+                       boolean displayText,
+                       boolean colourText, int start, int end)
+  {
+    this.sequences = sequences;
+    this.groupName = groupName;
+    this.displayBoxes = displayBoxes;
+    this.displayText = displayText;
+    this.colourText = colourText;
+    this.cs = scheme;
+    startRes = start;
+    endRes = end;
+    recalcConservation();
+  }
+
+  public SequenceI[] getSelectionAsNewSequences(AlignmentI align)
+  {
+    int iSize = sequences.size();
+    SequenceI[] seqs = new SequenceI[iSize];
+    SequenceI[] inorder = getSequencesInOrder(align);
+
+    for (int i = 0; i < iSize; i++)
+    {
+      SequenceI seq = inorder[i];
+
+      seqs[i] = new Sequence(seq.getName(),
+                             seq.getSequence(startRes, endRes + 1),
+                             seq.findPosition(startRes),
+                             findEndRes(seq));
+
+      seqs[i].setDescription(seq.getDescription());
+      seqs[i].setDBRef(seq.getDBRef());
+      seqs[i].setSequenceFeatures(seq.getSequenceFeatures());
+      if (seq.getDatasetSequence() != null)
+      {
+        seqs[i].setDatasetSequence(seq.getDatasetSequence());
+      }
+
+      if (seq.getAnnotation() != null)
+      {
+        for (int a = 0; a < seq.getAnnotation().length; a++)
+        {
+          seqs[i].addAlignmentAnnotation(new AlignmentAnnotation(seq.getAnnotation()[a]));
+        }
+      }
+    }
+
+    return seqs;
+
+  }
+
+  /**
+   * If sequence ends in gaps, the end residue can
+   * be correctly calculated here
+   * @param seq SequenceI
+   * @return int
+   */
+  public int findEndRes(SequenceI seq)
+  {
+    int eres = 0;
+    char ch;
+
+    for (int j = 0; j < endRes + 1 && j < seq.getLength(); j++)
+    {
+      ch = seq.getCharAt(j);
+      if (!jalview.util.Comparison.isGap( (ch)))
+      {
+        eres++;
+      }
+    }
+
+    if (eres > 0)
+    {
+      eres += seq.getStart() - 1;
+    }
+
+    return eres;
+  }
+
+  public Vector getSequences(Hashtable hiddenReps)
+  {
+    if (hiddenReps == null)
+    {
+      return sequences;
+    }
+    else
+    {
+      Vector allSequences = new Vector();
+      SequenceI seq, seq2;
+      for (int i = 0; i < sequences.size(); i++)
+      {
+        seq = (SequenceI) sequences.elementAt(i);
+        allSequences.addElement(seq);
+        if (hiddenReps.containsKey(seq))
+        {
+          SequenceGroup hsg = (SequenceGroup) hiddenReps.get(seq);
+          for (int h = 0; h < hsg.getSize(); h++)
+          {
+            seq2 = hsg.getSequenceAt(h);
+            if (seq2 != seq
+                && !allSequences.contains(seq2))
+            {
+              allSequences.addElement(seq2);
+            }
+          }
+        }
+      }
+
+      return allSequences;
+    }
+  }
+
+  public SequenceI[] getSequencesAsArray(Hashtable hiddenReps)
+  {
+    Vector tmp = getSequences(hiddenReps);
+    if (tmp == null)
+    {
+      return null;
+    }
+    SequenceI[] result = new SequenceI[tmp.size()];
+    for (int i = 0; i < result.length; i++)
+    {
+      result[i] = (SequenceI) tmp.elementAt(i);
+    }
+
+    return result;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param col DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public boolean adjustForRemoveLeft(int col)
+  {
+    // return value is true if the group still exists
+    if (startRes >= col)
+    {
+      startRes = startRes - col;
+    }
+
+    if (endRes >= col)
+    {
+      endRes = endRes - col;
+
+      if (startRes > endRes)
+      {
+        startRes = 0;
+      }
+    }
+    else
+    {
+      // must delete this group!!
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param col DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public boolean adjustForRemoveRight(int col)
+  {
+    if (startRes > col)
+    {
+      // delete this group
+      return false;
+    }
+
+    if (endRes >= col)
+    {
+      endRes = col;
+    }
+
+    return true;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public String getName()
+  {
+    return groupName;
+  }
+
+  public String getDescription()
+  {
+    return description;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param name DOCUMENT ME!
+   */
+  public void setName(String name)
+  {
+    groupName = name;
+  }
+
+  public void setDescription(String desc)
+  {
+    description = desc;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public Conservation getConservation()
+  {
+    return conserve;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param c DOCUMENT ME!
+   */
+  public void setConservation(Conservation c)
+  {
+    conserve = c;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param s DOCUMENT ME!
+   * @param recalc DOCUMENT ME!
+   */
+  public void addSequence(SequenceI s, boolean recalc)
+  {
+    if (s != null && !sequences.contains(s))
+    {
+      sequences.addElement(s);
+    }
+
+    if (recalc)
+    {
+      recalcConservation();
+    }
+  }
+
+  /**
+   * DOCUMENT ME!
+   */
+  public void recalcConservation()
+  {
+    if (cs == null)
+    {
+      return;
+    }
+
+    try
+    {
+      cs.setConsensus(AAFrequency.calculate(sequences, startRes, endRes + 1));
+
+      if (cs instanceof ClustalxColourScheme)
+      {
+        ( (ClustalxColourScheme) cs).resetClustalX(sequences, getWidth());
+      }
+
+      if (cs.conservationApplied())
+      {
+        Conservation c = new Conservation(groupName,
+                                          ResidueProperties.propHash, 3,
+                                          sequences,
+                                          startRes, endRes + 1);
+        c.calculate();
+        c.verdict(false, 25);
+
+        cs.setConservation(c);
+
+        if (cs instanceof ClustalxColourScheme)
+        {
+          ( (ClustalxColourScheme) cs).resetClustalX(sequences,
+              getWidth());
+        }
+      }
+    }
+    catch (java.lang.OutOfMemoryError err)
+    {
+      System.out.println("Out of memory loading groups: " + err);
+    }
+
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param s DOCUMENT ME!
+   * @param recalc DOCUMENT ME!
+   */
+  public void addOrRemove(SequenceI s, boolean recalc)
+  {
+    if (sequences.contains(s))
+    {
+      deleteSequence(s, recalc);
+    }
+    else
+    {
+      addSequence(s, recalc);
+    }
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param s DOCUMENT ME!
+   * @param recalc DOCUMENT ME!
+   */
+  public void deleteSequence(SequenceI s, boolean recalc)
+  {
+    sequences.removeElement(s);
+
+    if (recalc)
+    {
+      recalcConservation();
+    }
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public int getStartRes()
+  {
+    return startRes;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public int getEndRes()
+  {
+    return endRes;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param i DOCUMENT ME!
+   */
+  public void setStartRes(int i)
+  {
+    startRes = i;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param i DOCUMENT ME!
+   */
+  public void setEndRes(int i)
+  {
+    endRes = i;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public int getSize()
+  {
+    return sequences.size();
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param i DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public SequenceI getSequenceAt(int i)
+  {
+    return (SequenceI) sequences.elementAt(i);
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param state DOCUMENT ME!
+   */
+  public void setColourText(boolean state)
+  {
+    colourText = state;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public boolean getColourText()
+  {
+    return colourText;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param state DOCUMENT ME!
+   */
+  public void setDisplayText(boolean state)
+  {
+    displayText = state;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public boolean getDisplayText()
+  {
+    return displayText;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param state DOCUMENT ME!
+   */
+  public void setDisplayBoxes(boolean state)
+  {
+    displayBoxes = state;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public boolean getDisplayBoxes()
+  {
+    return displayBoxes;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public int getWidth()
+  {
+    // MC This needs to get reset when characters are inserted and deleted
+    if (sequences.size() > 0)
+    {
+      width = ( (SequenceI) sequences.elementAt(0)).getLength();
+    }
+
+    for (int i = 1; i < sequences.size(); i++)
+    {
+      SequenceI seq = (SequenceI) sequences.elementAt(i);
+
+      if (seq.getLength() > width)
+      {
+        width = seq.getLength();
+      }
+    }
+
+    return width;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @param c DOCUMENT ME!
+   */
+  public void setOutlineColour(Color c)
+  {
+    outlineColour = c;
+  }
+
+  /**
+   * DOCUMENT ME!
+   *
+   * @return DOCUMENT ME!
+   */
+  public Color getOutlineColour()
+  {
+    return outlineColour;
+  }
+
+  /**
+   *
+   * returns the sequences in the group ordered by the ordering given by al
+   *
+   * @param al Alignment
+   * @return SequenceI[]
+   */
+  public SequenceI[] getSequencesInOrder(AlignmentI al)
+  {
+    int sSize = sequences.size();
+    int alHeight = al.getHeight();
+
+    SequenceI[] seqs = new SequenceI[sSize];
+
+    int index = 0;
+    for (int i = 0; i < alHeight && index < sSize; i++)
+    {
+      if (sequences.contains(al.getSequenceAt(i)))
+      {
+        seqs[index++] = al.getSequenceAt(i);
+      }
+    }
+
+    return seqs;
+  }
+}

diff --git a/src/jalview/datamodel/SequenceI.java b/src/jalview/datamodel/SequenceI.java
index 6694aff..44e74e2 100755 (executable)
--- a/src/jalview/datamodel/SequenceI.java
+++ b/src/jalview/datamodel/SequenceI.java
@@ -262,5 +262,10 @@ public interface SequenceI
    * @return duplicate sequence with valid dataset sequence
    */
   public SequenceI deriveSequence();
+  /**
+   * set the array of associated AlignmentAnnotation for this sequenceI
+   * @param revealed
+   */
+  public void setAlignmentAnnotation(AlignmentAnnotation[] annotation);
 
 }