+ if (!samegap)
+ {
+ addedsq.replace(oldc, gapCharacter);
+ }
+ toappendsq.add(addedsq);
+ }
+ }
+ for (SequenceI addedsq : toappendsq)
+ {
+ addSequence(addedsq);
+ }
+ }
+ AlignmentAnnotation[] alan = toappend.getAlignmentAnnotation();
+ for (int a = 0; alan != null && a < alan.length; a++)
+ {
+ addAnnotation(alan[a]);
+ }
+
+ // use add method
+ getCodonFrames().addAll(toappend.getCodonFrames());
+
+ List<SequenceGroup> sg = toappend.getGroups();
+ if (sg != null)
+ {
+ for (SequenceGroup _sg : sg)
+ {
+ addGroup(_sg);
+ }
+ }
+ if (toappend.getHiddenSequences() != null)
+ {
+ HiddenSequences hs = toappend.getHiddenSequences();
+ if (hiddenSequences == null)
+ {
+ hiddenSequences = new HiddenSequences(this);
+ }
+ if (hs.hiddenSequences != null)
+ {
+ for (int s = 0; s < hs.hiddenSequences.length; s++)
+ {
+ // hide the newly appended sequence in the alignment
+ if (hs.hiddenSequences[s] != null)
+ {
+ hiddenSequences.hideSequence(hs.hiddenSequences[s]);
+ }
+ }
+ }
+ }
+ if (toappend.getProperties() != null)
+ {
+ // we really can't do very much here - just try to concatenate strings
+ // where property collisions occur.
+ Enumeration key = toappend.getProperties().keys();
+ while (key.hasMoreElements())
+ {
+ Object k = key.nextElement();
+ Object ourval = this.getProperty(k);
+ Object toapprop = toappend.getProperty(k);
+ if (ourval != null)
+ {
+ if (ourval.getClass().equals(toapprop.getClass())
+ && !ourval.equals(toapprop))
+ {
+ if (ourval instanceof String)
+ {
+ // append strings
+ this.setProperty(k,
+ ((String) ourval) + "; " + ((String) toapprop));
+ }
+ else
+ {
+ if (ourval instanceof Vector)
+ {
+ // append vectors
+ Enumeration theirv = ((Vector) toapprop).elements();
+ while (theirv.hasMoreElements())
+ {
+ ((Vector) ourval).addElement(theirv);
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ // just add new property directly
+ setProperty(k, toapprop);
+ }
+
+ }
+ }
+ }
+
+ @Override
+ public AlignmentAnnotation findOrCreateAnnotation(String name,
+ String calcId, boolean autoCalc, SequenceI seqRef,
+ SequenceGroup groupRef)
+ {
+ AlignmentAnnotation annot = annotations == null ? null
+ : AlignmentAnnotation.findFirstAnnotation(
+ Arrays.asList(getAlignmentAnnotation()), name, calcId,
+ autoCalc, seqRef, groupRef);
+
+ if (annot == null)
+ {
+
+ annot = new AlignmentAnnotation(name, name, new Annotation[1], 0f, 0f,
+ AlignmentAnnotation.BAR_GRAPH);
+ annot.hasText = false;
+ if (calcId != null)
+ {
+ annot.setCalcId(calcId);
+ }
+ annot.autoCalculated = autoCalc;
+ if (seqRef != null)
+ {
+ annot.setSequenceRef(seqRef);
+ }
+ annot.groupRef = groupRef;
+ addAnnotation(annot);
+ }
+ return annot;
+ }
+
+
+ @Override
+ public AlignmentAnnotation updateFromOrCopyAnnotation(
+ AlignmentAnnotation ala)
+ {
+ AlignmentAnnotation annot = AlignmentAnnotation.findFirstAnnotation(
+ Arrays.asList(getAlignmentAnnotation()), ala.label, ala.calcId,
+ ala.autoCalculated, ala.sequenceRef, ala.groupRef);
+ if (annot == null)
+ {
+ annot = new AlignmentAnnotation(ala);
+ addAnnotation(annot);
+ }
+ else
+ {
+ annot.updateAlignmentAnnotationFrom(ala);
+ }
+ validateAnnotation(annot);
+ return annot;
+ }
+
+ @Override
+ public Iterable<AlignmentAnnotation> findAnnotation(String calcId)
+ {
+ AlignmentAnnotation[] alignmentAnnotation = getAlignmentAnnotation();
+ if (alignmentAnnotation != null)
+ {
+ return AlignmentAnnotation.findAnnotation(
+ Arrays.asList(getAlignmentAnnotation()), calcId);
+ }
+ return Arrays.asList(new AlignmentAnnotation[] {});
+ }
+
+ @Override
+ public Iterable<AlignmentAnnotation> findAnnotations(SequenceI seq,
+ String calcId, String label)
+ {
+ return AlignmentAnnotation.findAnnotations(
+ Arrays.asList(getAlignmentAnnotation()), seq, calcId, label);
+ }
+
+ @Override
+ public void moveSelectedSequencesByOne(SequenceGroup sg,
+ Map<SequenceI, SequenceCollectionI> map, boolean up)
+ {
+ synchronized (sequences)
+ {
+ if (up)
+ {
+
+ for (int i = 1, iSize = sequences.size(); i < iSize; i++)
+ {
+ SequenceI seq = sequences.get(i);
+ if (!sg.getSequences(map).contains(seq))
+ {
+ continue;
+ }
+
+ SequenceI temp = sequences.get(i - 1);
+ if (sg.getSequences(null).contains(temp))
+ {
+ continue;
+ }
+
+ sequences.set(i, temp);
+ sequences.set(i - 1, seq);