src/jalview/commands/EditCommand.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.commands;
  22
  23 import jalview.analysis.AlignSeq;
  24 import jalview.datamodel.AlignmentAnnotation;
  25 import jalview.datamodel.AlignmentI;
  26 import jalview.datamodel.Annotation;
  27 import jalview.datamodel.Range;
  28 import jalview.datamodel.Sequence;
  29 import jalview.datamodel.SequenceFeature;
  30 import jalview.datamodel.SequenceI;
  31 import jalview.datamodel.features.SequenceFeaturesI;
  32 import jalview.util.Comparison;
  33 import jalview.util.ReverseListIterator;
  34 import jalview.util.StringUtils;
  35
  36 import java.util.ArrayList;
  37 import java.util.HashMap;
  38 import java.util.Hashtable;
  39 import java.util.Iterator;
  40 import java.util.List;
  41 import java.util.ListIterator;
  42 import java.util.Map;
  43
  44 /**
  45  *
  46  * <p>
  47  * Title: EditCommmand
  48  * </p>
  49  *
  50  * <p>
  51  * Description: Essential information for performing undo and redo for cut/paste
  52  * insert/delete gap which can be stored in the HistoryList
  53  * </p>
  54  *
  55  * <p>
  56  * Copyright: Copyright (c) 2006
  57  * </p>
  58  *
  59  * <p>
  60  * Company: Dundee University
  61  * </p>
  62  *
  63  * @author not attributable
  64  * @version 1.0
  65  */
  66 public class EditCommand implements CommandI
  67 {
  68   public enum Action
  69   {
  70     INSERT_GAP
  71     {
  72       @Override
  73       public Action getUndoAction()
  74       {
  75         return DELETE_GAP;
  76       }
  77     },
  78     DELETE_GAP
  79     {
  80       @Override
  81       public Action getUndoAction()
  82       {
  83         return INSERT_GAP;
  84       }
  85     },
  86     CUT
  87     {
  88       @Override
  89       public Action getUndoAction()
  90       {
  91         return PASTE;
  92       }
  93     },
  94     PASTE
  95     {
  96       @Override
  97       public Action getUndoAction()
  98       {
  99         return CUT;
 100       }
 101     },
 102     REPLACE
 103     {
 104       @Override
 105       public Action getUndoAction()
 106       {
 107         return REPLACE;
 108       }
 109     },
 110     INSERT_NUC
 111     {
 112       @Override
 113       public Action getUndoAction()
 114       {
 115         return null;
 116       }
 117     };
 118     public abstract Action getUndoAction();
 119   };
 120
 121   private List<Edit> edits = new ArrayList<Edit>();
 122
 123   String description;
 124
 125   public EditCommand()
 126   {
 127   }
 128
 129   public EditCommand(String desc)
 130   {
 131     this.description = desc;
 132   }
 133
 134   public EditCommand(String desc, Action command, SequenceI[] seqs,
 135           int position, int number, AlignmentI al)
 136   {
 137     this.description = desc;
 138     if (command == Action.CUT || command == Action.PASTE)
 139     {
 140       setEdit(new Edit(command, seqs, position, number, al));
 141     }
 142
 143     performEdit(0, null);
 144   }
 145
 146   public EditCommand(String desc, Action command, String replace,
 147           SequenceI[] seqs, int position, int number, AlignmentI al)
 148   {
 149     this.description = desc;
 150     if (command == Action.REPLACE)
 151     {
 152       setEdit(new Edit(command, seqs, position, number, al, replace));
 153     }
 154
 155     performEdit(0, null);
 156   }
 157
 158   /**
 159    * Set the list of edits to the specified item (only).
 160    *
 161    * @param e
 162    */
 163   protected void setEdit(Edit e)
 164   {
 165     edits.clear();
 166     edits.add(e);
 167   }
 168
 169   /**
 170    * Add the given edit command to the stored list of commands. If simply
 171    * expanding the range of the last command added, then modify it instead of
 172    * adding a new command.
 173    *
 174    * @param e
 175    */
 176   public void addEdit(Edit e)
 177   {
 178     if (!expandEdit(edits, e))
 179     {
 180       edits.add(e);
 181     }
 182   }
 183
 184   /**
 185    * Returns true if the new edit is incorporated by updating (expanding the
 186    * range of) the last edit on the list, else false. We can 'expand' the last
 187    * edit if the new one is the same action, on the same sequences, and acts on
 188    * a contiguous range. This is the case where a mouse drag generates a series
 189    * of contiguous gap insertions or deletions.
 190    *
 191    * @param edits
 192    * @param e
 193    * @return
 194    */
 195   protected static boolean expandEdit(List<Edit> edits, Edit e)
 196   {
 197     if (edits == null || edits.isEmpty())
 198     {
 199       return false;
 200     }
 201     Edit lastEdit = edits.get(edits.size() - 1);
 202     Action action = e.command;
 203     if (lastEdit.command != action)
 204     {
 205       return false;
 206     }
 207
 208     /*
 209      * Both commands must act on the same sequences - compare the underlying
 210      * dataset sequences, rather than the aligned sequences, which change as
 211      * they are edited.
 212      */
 213     if (lastEdit.seqs.length != e.seqs.length)
 214     {
 215       return false;
 216     }
 217     for (int i = 0; i < e.seqs.length; i++)
 218     {
 219       if (lastEdit.seqs[i].getDatasetSequence() != e.seqs[i]
 220               .getDatasetSequence())
 221       {
 222         return false;
 223       }
 224     }
 225
 226     /**
 227      * Check a contiguous edit; either
 228      * <ul>
 229      * <li>a new Insert <n> positions to the right of the last <insert n>,
 230      * or</li>
 231      * <li>a new Delete <n> gaps which is <n> positions to the left of the last
 232      * delete.</li>
 233      * </ul>
 234      */
 235     boolean contiguous = (action == Action.INSERT_GAP
 236             && e.position == lastEdit.position + lastEdit.number)
 237             || (action == Action.DELETE_GAP
 238                     && e.position + e.number == lastEdit.position);
 239     if (contiguous)
 240     {
 241       /*
 242        * We are just expanding the range of the last edit. For delete gap, also
 243        * moving the start position left.
 244        */
 245       lastEdit.number += e.number;
 246       lastEdit.seqs = e.seqs;
 247       if (action == Action.DELETE_GAP)
 248       {
 249         lastEdit.position--;
 250       }
 251       return true;
 252     }
 253     return false;
 254   }
 255
 256   /**
 257    * Clear the list of stored edit commands.
 258    *
 259    */
 260   protected void clearEdits()
 261   {
 262     edits.clear();
 263   }
 264
 265   /**
 266    * Returns the i'th stored Edit command.
 267    *
 268    * @param i
 269    * @return
 270    */
 271   protected Edit getEdit(int i)
 272   {
 273     if (i >= 0 && i < edits.size())
 274     {
 275       return edits.get(i);
 276     }
 277     return null;
 278   }
 279
 280   @Override
 281   final public String getDescription()
 282   {
 283     return description;
 284   }
 285
 286   @Override
 287   public int getSize()
 288   {
 289     return edits.size();
 290   }
 291
 292   /**
 293    * Return the alignment for the first edit (or null if no edit).
 294    *
 295    * @return
 296    */
 297   final public AlignmentI getAlignment()
 298   {
 299     return (edits.isEmpty() ? null : edits.get(0).al);
 300   }
 301
 302   /**
 303    * append a new editCommand Note. this shouldn't be called if the edit is an
 304    * operation affects more alignment objects than the one referenced in al (for
 305    * example, cut or pasting whole sequences). Use the form with an additional
 306    * AlignmentI[] views parameter.
 307    *
 308    * @param command
 309    * @param seqs
 310    * @param position
 311    * @param number
 312    * @param al
 313    * @param performEdit
 314    */
 315   final public void appendEdit(Action command, SequenceI[] seqs,
 316           int position, int number, AlignmentI al, boolean performEdit)
 317   {
 318     appendEdit(command, seqs, position, number, al, performEdit, null);
 319   }
 320
 321   /**
 322    * append a new edit command with a set of alignment views that may be
 323    * operated on
 324    *
 325    * @param command
 326    * @param seqs
 327    * @param position
 328    * @param number
 329    * @param al
 330    * @param performEdit
 331    * @param views
 332    */
 333   final public void appendEdit(Action command, SequenceI[] seqs,
 334           int position, int number, AlignmentI al, boolean performEdit,
 335           AlignmentI[] views)
 336   {
 337     Edit edit = new Edit(command, seqs, position, number, al);
 338     appendEdit(edit, al, performEdit, views);
 339   }
 340
 341   /**
 342    * Overloaded method that accepts an Edit object with additional parameters.
 343    *
 344    * @param edit
 345    * @param al
 346    * @param performEdit
 347    * @param views
 348    */
 349   final public void appendEdit(Edit edit, AlignmentI al,
 350           boolean performEdit, AlignmentI[] views)
 351   {
 352     if (al.getHeight() == edit.seqs.length)
 353     {
 354       edit.al = al;
 355       edit.fullAlignmentHeight = true;
 356     }
 357
 358     addEdit(edit);
 359
 360     if (performEdit)
 361     {
 362       performEdit(edit, views);
 363     }
 364   }
 365
 366   /**
 367    * Execute all the edit commands, starting at the given commandIndex
 368    *
 369    * @param commandIndex
 370    * @param views
 371    */
 372   public final void performEdit(int commandIndex, AlignmentI[] views)
 373   {
 374     ListIterator<Edit> iterator = edits.listIterator(commandIndex);
 375     while (iterator.hasNext())
 376     {
 377       Edit edit = iterator.next();
 378       performEdit(edit, views);
 379     }
 380   }
 381
 382   /**
 383    * Execute one edit command in all the specified alignment views
 384    *
 385    * @param edit
 386    * @param views
 387    */
 388   protected static void performEdit(Edit edit, AlignmentI[] views)
 389   {
 390     switch (edit.command)
 391     {
 392     case INSERT_GAP:
 393       insertGap(edit);
 394       break;
 395     case DELETE_GAP:
 396       deleteGap(edit);
 397       break;
 398     case CUT:
 399       cut(edit, views);
 400       break;
 401     case PASTE:
 402       paste(edit, views);
 403       break;
 404     case REPLACE:
 405       replace(edit);
 406       break;
 407     case INSERT_NUC:
 408       // TODO:add deleteNuc for UNDO
 409       // case INSERT_NUC:
 410       // insertNuc(edits[e]);
 411       break;
 412     default:
 413       break;
 414     }
 415   }
 416
 417   @Override
 418   final public void doCommand(AlignmentI[] views)
 419   {
 420     performEdit(0, views);
 421   }
 422
 423   /**
 424    * Undo the stored list of commands, in reverse order.
 425    */
 426   @Override
 427   final public void undoCommand(AlignmentI[] views)
 428   {
 429     ListIterator<Edit> iterator = edits.listIterator(edits.size());
 430     while (iterator.hasPrevious())
 431     {
 432       Edit e = iterator.previous();
 433       switch (e.command)
 434       {
 435       case INSERT_GAP:
 436         deleteGap(e);
 437         break;
 438       case DELETE_GAP:
 439         insertGap(e);
 440         break;
 441       case CUT:
 442         paste(e, views);
 443         break;
 444       case PASTE:
 445         cut(e, views);
 446         break;
 447       case REPLACE:
 448         replace(e);
 449         break;
 450       case INSERT_NUC:
 451         // not implemented
 452         break;
 453       default:
 454         break;
 455       }
 456     }
 457   }
 458
 459   /**
 460    * Insert gap(s) in sequences as specified by the command, and adjust
 461    * annotations.
 462    *
 463    * @param command
 464    */
 465   final private static void insertGap(Edit command)
 466   {
 467
 468     for (int s = 0; s < command.seqs.length; s++)
 469     {
 470       command.seqs[s].insertCharAt(command.position, command.number,
 471               command.gapChar);
 472       // System.out.println("pos: "+command.position+" number:
 473       // "+command.number);
 474     }
 475
 476     adjustAnnotations(command, true, false, null);
 477   }
 478
 479   //
 480   // final void insertNuc(Edit command)
 481   // {
 482   //
 483   // for (int s = 0; s < command.seqs.length; s++)
 484   // {
 485   // System.out.println("pos: "+command.position+" number: "+command.number);
 486   // command.seqs[s].insertCharAt(command.position, command.number,'A');
 487   // }
 488   //
 489   // adjustAnnotations(command, true, false, null);
 490   // }
 491
 492   /**
 493    * Delete gap(s) in sequences as specified by the command, and adjust
 494    * annotations.
 495    *
 496    * @param command
 497    */
 498   final static private void deleteGap(Edit command)
 499   {
 500     for (int s = 0; s < command.seqs.length; s++)
 501     {
 502       command.seqs[s].deleteChars(command.position,
 503               command.position + command.number);
 504     }
 505
 506     adjustAnnotations(command, false, false, null);
 507   }
 508
 509   /**
 510    * Carry out a Cut action. The cut characters are saved in case Undo is
 511    * requested.
 512    *
 513    * @param command
 514    * @param views
 515    */
 516   static void cut(Edit command, AlignmentI[] views)
 517   {
 518     boolean seqDeleted = false;
 519     command.string = new char[command.seqs.length][];
 520
 521     for (int i = 0; i < command.seqs.length; i++)
 522     {
 523       final SequenceI sequence = command.seqs[i];
 524       if (sequence.getLength() > command.position)
 525       {
 526         command.string[i] = sequence.getSequence(command.position,
 527                 command.position + command.number);
 528         SequenceI oldds = sequence.getDatasetSequence();
 529         if (command.oldds != null && command.oldds[i] != null)
 530         {
 531           // we are redoing an undone cut.
 532           sequence.setDatasetSequence(null);
 533         }
 534         Range cutPositions = sequence.findPositions(command.position + 1,
 535                 command.position + command.number);
 536         boolean cutIsInternal = cutPositions != null
 537                 && sequence.getStart() != cutPositions
 538                 .getBegin() && sequence.getEnd() != cutPositions.getEnd();
 539         sequence.deleteChars(command.position, command.position
 540                 + command.number);
 541
 542         if (command.oldds != null && command.oldds[i] != null)
 543         {
 544           // Undoing previous Paste - so
 545           // oldds entry contains the cut dataset sequence,
 546           // with sequence features in expected place.
 547           sequence.setDatasetSequence(command.oldds[i]);
 548           command.oldds[i] = oldds;
 549         }
 550         else
 551         {
 552           // New cut operation
 553           // We always keep track of the dataset sequence so we can safely
 554           // restore it during the Undo
 555           if (command.oldds == null)
 556           {
 557             command.oldds = new SequenceI[command.seqs.length];
 558           }
 559           command.oldds[i] = oldds;
 560
 561           // do we need to edit sequence features for new sequence ?
 562           if (oldds != sequence.getDatasetSequence()
 563                   || (cutIsInternal
 564                           && sequence.getFeatures().hasFeatures()))
 565           {
 566             if (cutPositions != null)
 567             {
 568               cutFeatures(command, sequence, cutPositions.getBegin(),
 569                               cutPositions.getEnd(), cutIsInternal);
 570             }
 571           }
 572         }
 573       }
 574
 575       if (sequence.getLength() < 1)
 576       {
 577         command.al.deleteSequence(sequence);
 578         seqDeleted = true;
 579       }
 580     }
 581
 582     adjustAnnotations(command, false, seqDeleted, views);
 583   }
 584
 585   /**
 586    * Perform the given Paste command. This may be to add cut or copied sequences
 587    * to an alignment, or to undo a 'Cut' action on a region of the alignment.
 588    *
 589    * @param command
 590    * @param views
 591    */
 592   static void paste(Edit command, AlignmentI[] views)
 593   {
 594     boolean seqWasDeleted = false;
 595
 596     for (int i = 0; i < command.seqs.length; i++)
 597     {
 598       boolean newDSNeeded = false;
 599       boolean newDSWasNeeded = command.oldds != null
 600               && command.oldds[i] != null;
 601       SequenceI sequence = command.seqs[i];
 602       if (sequence.getLength() < 1)
 603       {
 604         /*
 605          * sequence was deleted; re-add it to the alignment
 606          */
 607         if (command.alIndex[i] < command.al.getHeight())
 608         {
 609           List<SequenceI> sequences;
 610           synchronized (sequences = command.al.getSequences())
 611           {
 612             if (!(command.alIndex[i] < 0))
 613             {
 614               sequences.add(command.alIndex[i], sequence);
 615             }
 616           }
 617         }
 618         else
 619         {
 620           command.al.addSequence(sequence);
 621         }
 622         seqWasDeleted = true;
 623       }
 624       int newStart = sequence.getStart();
 625       int newEnd = sequence.getEnd();
 626
 627       StringBuilder tmp = new StringBuilder();
 628       tmp.append(sequence.getSequence());
 629       // Undo of a delete does not replace original dataset sequence on to
 630       // alignment sequence.
 631
 632       int start = 0;
 633       int length = 0;
 634
 635       if (command.string != null && command.string[i] != null)
 636       {
 637         if (command.position >= tmp.length())
 638         {
 639           // This occurs if padding is on, and residues
 640           // are removed from end of alignment
 641           int len = command.position - tmp.length();
 642           while (len > 0)
 643           {
 644             tmp.append(command.gapChar);
 645             len--;
 646           }
 647         }
 648         tmp.insert(command.position, command.string[i]);
 649         for (int s = 0; s < command.string[i].length; s++)
 650         {
 651           if (!Comparison.isGap(command.string[i][s]))
 652           {
 653             length++;
 654             if (!newDSNeeded)
 655             {
 656               newDSNeeded = true;
 657               start = sequence.findPosition(command.position);
 658               // end = sequence
 659               // .findPosition(command.position + command.number);
 660             }
 661             if (sequence.getStart() == start)
 662             {
 663               newStart--;
 664             }
 665             else
 666             {
 667               newEnd++;
 668             }
 669           }
 670         }
 671         command.string[i] = null;
 672       }
 673
 674       sequence.setSequence(tmp.toString());
 675       sequence.setStart(newStart);
 676       sequence.setEnd(newEnd);
 677
 678       /*
 679        * command and Undo share the same dataset sequence if cut was
 680        * at start or end of sequence
 681        */
 682       boolean sameDatasetSequence = false;
 683       if (newDSNeeded)
 684       {
 685         if (sequence.getDatasetSequence() != null)
 686         {
 687           SequenceI ds;
 688           if (newDSWasNeeded)
 689           {
 690             ds = command.oldds[i];
 691           }
 692           else
 693           {
 694             // make a new DS sequence
 695             // use new ds mechanism here
 696             String ungapped = AlignSeq.extractGaps(Comparison.GapChars,
 697                     sequence.getSequenceAsString());
 698             ds = new Sequence(sequence.getName(), ungapped,
 699                     sequence.getStart(), sequence.getEnd());
 700             ds.setDescription(sequence.getDescription());
 701           }
 702           if (command.oldds == null)
 703           {
 704             command.oldds = new SequenceI[command.seqs.length];
 705           }
 706           command.oldds[i] = sequence.getDatasetSequence();
 707           sameDatasetSequence = ds == sequence.getDatasetSequence();
 708           ds.setSequenceFeatures(sequence.getSequenceFeatures());
 709           sequence.setDatasetSequence(ds);
 710         }
 711         undoCutFeatures(command, command.seqs[i], start, length,
 712                 sameDatasetSequence);
 713       }
 714     }
 715     adjustAnnotations(command, true, seqWasDeleted, views);
 716
 717     command.string = null;
 718   }
 719
 720   static void replace(Edit command)
 721   {
 722     StringBuffer tmp;
 723     String oldstring;
 724     int start = command.position;
 725     int end = command.number;
 726     // TODO TUTORIAL - Fix for replacement with different length of sequence (or
 727     // whole sequence)
 728     // TODO Jalview 2.4 bugfix change to an aggregate command - original
 729     // sequence string is cut, new string is pasted in.
 730     command.number = start + command.string[0].length;
 731     for (int i = 0; i < command.seqs.length; i++)
 732     {
 733       boolean newDSWasNeeded = command.oldds != null
 734               && command.oldds[i] != null;
 735       boolean newStartEndWasNeeded = command.oldStartEnd!=null && command.oldStartEnd[i]!=null;
 736
 737       /**
 738        * cut addHistoryItem(new EditCommand("Cut Sequences", EditCommand.CUT,
 739        * cut, sg.getStartRes(), sg.getEndRes()-sg.getStartRes()+1,
 740        * viewport.alignment));
 741        *
 742        */
 743       /**
 744        * then addHistoryItem(new EditCommand( "Add sequences",
 745        * EditCommand.PASTE, sequences, 0, alignment.getWidth(), alignment) );
 746        *
 747        */
 748
 749       Range beforeEditedPositions = command.seqs[i].findPositions(1, start);
 750       Range afterEditedPositions = command.seqs[i]
 751               .findPositions(start + end + 1, command.seqs[i].getLength());
 752
 753       oldstring = command.seqs[i].getSequenceAsString();
 754       tmp = new StringBuffer(oldstring.substring(0, start));
 755       tmp.append(command.string[i]);
 756       String nogaprep = jalview.analysis.AlignSeq.extractGaps(
 757               jalview.util.Comparison.GapChars,
 758               new String(command.string[i]));
 759       int ipos = command.seqs[i].findPosition(start)
 760               - command.seqs[i].getStart();
 761       if (end < oldstring.length())
 762       {
 763         tmp.append(oldstring.substring(end));
 764       }
 765       command.seqs[i].setSequence(tmp.toString());
 766       command.string[i] = oldstring
 767               .substring(start, Math.min(end, oldstring.length()))
 768               .toCharArray();
 769       String nogapold = AlignSeq.extractGaps(Comparison.GapChars,
 770               new String(command.string[i]));
 771
 772       if (!nogaprep.toLowerCase().equals(nogapold.toLowerCase()))
 773       {
 774         // probably need a new dataset sequence
 775         if (newDSWasNeeded)
 776         {
 777           // then just switch the dataset sequence
 778           SequenceI oldds = command.seqs[i].getDatasetSequence();
 779           command.seqs[i].setDatasetSequence(command.oldds[i]);
 780           command.oldds[i] = oldds;
 781         }
 782         else
 783         if (newStartEndWasNeeded)
 784         {
 785           Range newStart = command.oldStartEnd[i];
 786           command.oldStartEnd[i] = new Range(command.seqs[i].getStart(),
 787                   command.seqs[i].getEnd());
 788           command.seqs[i].setStart(newStart.getBegin());
 789           command.seqs[i].setEnd(newStart.getEnd());
 790         }
 791         else
 792         {
 793           // first edit the original dataset sequence string
 794           SequenceI oldds = command.seqs[i].getDatasetSequence();
 795           String fullseq, osp = oldds.getSequenceAsString();
 796
 797           fullseq = osp.substring(0, ipos) + nogaprep
 798                   + osp.substring(ipos + nogaprep.length());
 799
 800           // and check if new sequence data is different..
 801           if (!fullseq.equalsIgnoreCase(osp))
 802           {
 803             // old ds and edited ds are different, so
 804             // create the new dataset sequence
 805             SequenceI newds = new Sequence(oldds);
 806             newds.setSequence(fullseq.toUpperCase());
 807
 808             if (command.oldds == null)
 809             {
 810               command.oldds = new SequenceI[command.seqs.length];
 811             }
 812             command.oldds[i] = command.seqs[i].getDatasetSequence();
 813             // TODO: JAL-1131 ensure newly created dataset sequence is added to
 814             // the set of
 815             // dataset sequences associated with the alignment.
 816             // TODO: JAL-1131 fix up any annotation associated with new dataset
 817             // sequence to ensure that original sequence/annotation
 818             // relationships
 819             // are preserved.
 820             command.seqs[i].setDatasetSequence(newds);
 821           }
 822           else
 823           {
 824             if (command.oldStartEnd == null)
 825             {
 826               command.oldStartEnd = new Range[command.seqs.length];
 827             }
 828             command.oldStartEnd[i] = new Range(command.seqs[i].getStart(),
 829                     command.seqs[i].getEnd());
 830             if (beforeEditedPositions != null
 831                     && afterEditedPositions == null)
 832             {
 833               // modification at end
 834               command.seqs[i].setEnd(
 835                       beforeEditedPositions.getEnd() + nogaprep.length());
 836             }
 837             else if (afterEditedPositions != null
 838                     && beforeEditedPositions == null)
 839             {
 840               // modification at start
 841               command.seqs[i].setStart(
 842                       afterEditedPositions.getBegin() - nogaprep.length());
 843             }
 844             else
 845             {
 846               // edit covered both start and end. Here we can only guess the
 847               // new
 848               // start/end
 849               String nogapalseq = jalview.analysis.AlignSeq.extractGaps(
 850                       jalview.util.Comparison.GapChars,
 851                       command.seqs[i].getSequenceAsString().toUpperCase());
 852               int newStart = command.seqs[i].getDatasetSequence()
 853                       .getSequenceAsString().indexOf(nogapalseq);
 854               if (newStart == -1)
 855               {
 856                 throw new Error(
 857                         "Implementation Error: could not locate start/end "
 858                                 + "in dataset sequence after an edit of the sequence string");
 859               }
 860               int newEnd = newStart + nogapalseq.length() - 1;
 861               command.seqs[i].setStart(newStart);
 862               command.seqs[i].setEnd(newEnd);
 863             }
 864           }
 865         }
 866       }
 867       tmp = null;
 868       oldstring = null;
 869     }
 870   }
 871
 872   final static void adjustAnnotations(Edit command, boolean insert,
 873           boolean modifyVisibility, AlignmentI[] views)
 874   {
 875     AlignmentAnnotation[] annotations = null;
 876
 877     if (modifyVisibility && !insert)
 878     {
 879       // only occurs if a sequence was added or deleted.
 880       command.deletedAnnotationRows = new Hashtable<SequenceI, AlignmentAnnotation[]>();
 881     }
 882     if (command.fullAlignmentHeight)
 883     {
 884       annotations = command.al.getAlignmentAnnotation();
 885     }
 886     else
 887     {
 888       int aSize = 0;
 889       AlignmentAnnotation[] tmp;
 890       for (int s = 0; s < command.seqs.length; s++)
 891       {
 892         command.seqs[s].sequenceChanged();
 893
 894         if (modifyVisibility)
 895         {
 896           // Rows are only removed or added to sequence object.
 897           if (!insert)
 898           {
 899             // remove rows
 900             tmp = command.seqs[s].getAnnotation();
 901             if (tmp != null)
 902             {
 903               int alen = tmp.length;
 904               for (int aa = 0; aa < tmp.length; aa++)
 905               {
 906                 if (!command.al.deleteAnnotation(tmp[aa]))
 907                 {
 908                   // strip out annotation not in the current al (will be put
 909                   // back on insert in all views)
 910                   tmp[aa] = null;
 911                   alen--;
 912                 }
 913               }
 914               command.seqs[s].setAlignmentAnnotation(null);
 915               if (alen != tmp.length)
 916               {
 917                 // save the non-null annotation references only
 918                 AlignmentAnnotation[] saved = new AlignmentAnnotation[alen];
 919                 for (int aa = 0, aapos = 0; aa < tmp.length; aa++)
 920                 {
 921                   if (tmp[aa] != null)
 922                   {
 923                     saved[aapos++] = tmp[aa];
 924                     tmp[aa] = null;
 925                   }
 926                 }
 927                 tmp = saved;
 928                 command.deletedAnnotationRows.put(command.seqs[s], saved);
 929                 // and then remove any annotation in the other views
 930                 for (int alview = 0; views != null
 931                         && alview < views.length; alview++)
 932                 {
 933                   if (views[alview] != command.al)
 934                   {
 935                     AlignmentAnnotation[] toremove = views[alview]
 936                             .getAlignmentAnnotation();
 937                     if (toremove == null || toremove.length == 0)
 938                     {
 939                       continue;
 940                     }
 941                     // remove any alignment annotation on this sequence that's
 942                     // on that alignment view.
 943                     for (int aa = 0; aa < toremove.length; aa++)
 944                     {
 945                       if (toremove[aa].sequenceRef == command.seqs[s])
 946                       {
 947                         views[alview].deleteAnnotation(toremove[aa]);
 948                       }
 949                     }
 950                   }
 951                 }
 952               }
 953               else
 954               {
 955                 // save all the annotation
 956                 command.deletedAnnotationRows.put(command.seqs[s], tmp);
 957               }
 958             }
 959           }
 960           else
 961           {
 962             // recover rows
 963             if (command.deletedAnnotationRows != null
 964                     && command.deletedAnnotationRows
 965                             .containsKey(command.seqs[s]))
 966             {
 967               AlignmentAnnotation[] revealed = command.deletedAnnotationRows
 968                       .get(command.seqs[s]);
 969               command.seqs[s].setAlignmentAnnotation(revealed);
 970               if (revealed != null)
 971               {
 972                 for (int aa = 0; aa < revealed.length; aa++)
 973                 {
 974                   // iterate through al adding original annotation
 975                   command.al.addAnnotation(revealed[aa]);
 976                 }
 977                 for (int aa = 0; aa < revealed.length; aa++)
 978                 {
 979                   command.al.setAnnotationIndex(revealed[aa], aa);
 980                 }
 981                 // and then duplicate added annotation on every other alignment
 982                 // view
 983                 for (int vnum = 0; views != null && vnum < views.length; vnum++)
 984                 {
 985                   if (views[vnum] != command.al)
 986                   {
 987                     int avwidth = views[vnum].getWidth() + 1;
 988                     // duplicate in this view
 989                     for (int a = 0; a < revealed.length; a++)
 990                     {
 991                       AlignmentAnnotation newann = new AlignmentAnnotation(
 992                               revealed[a]);
 993                       command.seqs[s].addAlignmentAnnotation(newann);
 994                       newann.padAnnotation(avwidth);
 995                       views[vnum].addAnnotation(newann);
 996                       views[vnum].setAnnotationIndex(newann, a);
 997                     }
 998                   }
 999                 }
1000               }
1001             }
1002           }
1003           continue;
1004         }
1005
1006         if (command.seqs[s].getAnnotation() == null)
1007         {
1008           continue;
1009         }
1010
1011         if (aSize == 0)
1012         {
1013           annotations = command.seqs[s].getAnnotation();
1014         }
1015         else
1016         {
1017           tmp = new AlignmentAnnotation[aSize
1018                   + command.seqs[s].getAnnotation().length];
1019
1020           System.arraycopy(annotations, 0, tmp, 0, aSize);
1021
1022           System.arraycopy(command.seqs[s].getAnnotation(), 0, tmp, aSize,
1023                   command.seqs[s].getAnnotation().length);
1024
1025           annotations = tmp;
1026         }
1027         aSize = annotations.length;
1028       }
1029     }
1030
1031     if (annotations == null)
1032     {
1033       return;
1034     }
1035
1036     if (!insert)
1037     {
1038       command.deletedAnnotations = new Hashtable<String, Annotation[]>();
1039     }
1040
1041     int aSize;
1042     Annotation[] temp;
1043     for (int a = 0; a < annotations.length; a++)
1044     {
1045       if (annotations[a].autoCalculated
1046               || annotations[a].annotations == null)
1047       {
1048         continue;
1049       }
1050
1051       int tSize = 0;
1052
1053       aSize = annotations[a].annotations.length;
1054       if (insert)
1055       {
1056         temp = new Annotation[aSize + command.number];
1057         if (annotations[a].padGaps)
1058         {
1059           for (int aa = 0; aa < temp.length; aa++)
1060           {
1061             temp[aa] = new Annotation(command.gapChar + "", null, ' ', 0);
1062           }
1063         }
1064       }
1065       else
1066       {
1067         if (command.position < aSize)
1068         {
1069           if (command.position + command.number >= aSize)
1070           {
1071             tSize = aSize;
1072           }
1073           else
1074           {
1075             tSize = aSize - command.number;
1076           }
1077         }
1078         else
1079         {
1080           tSize = aSize;
1081         }
1082
1083         if (tSize < 0)
1084         {
1085           tSize = aSize;
1086         }
1087         temp = new Annotation[tSize];
1088       }
1089
1090       if (insert)
1091       {
1092         if (command.position < annotations[a].annotations.length)
1093         {
1094           System.arraycopy(annotations[a].annotations, 0, temp, 0,
1095                   command.position);
1096
1097           if (command.deletedAnnotations != null
1098                   && command.deletedAnnotations
1099                           .containsKey(annotations[a].annotationId))
1100           {
1101             Annotation[] restore = command.deletedAnnotations
1102                     .get(annotations[a].annotationId);
1103
1104             System.arraycopy(restore, 0, temp, command.position,
1105                     command.number);
1106
1107           }
1108
1109           System.arraycopy(annotations[a].annotations, command.position,
1110                   temp, command.position + command.number,
1111                   aSize - command.position);
1112         }
1113         else
1114         {
1115           if (command.deletedAnnotations != null
1116                   && command.deletedAnnotations
1117                           .containsKey(annotations[a].annotationId))
1118           {
1119             Annotation[] restore = command.deletedAnnotations
1120                     .get(annotations[a].annotationId);
1121
1122             temp = new Annotation[annotations[a].annotations.length
1123                     + restore.length];
1124             System.arraycopy(annotations[a].annotations, 0, temp, 0,
1125                     annotations[a].annotations.length);
1126             System.arraycopy(restore, 0, temp,
1127                     annotations[a].annotations.length, restore.length);
1128           }
1129           else
1130           {
1131             temp = annotations[a].annotations;
1132           }
1133         }
1134       }
1135       else
1136       {
1137         if (tSize != aSize || command.position < 2)
1138         {
1139           int copylen = Math.min(command.position,
1140                   annotations[a].annotations.length);
1141           if (copylen > 0)
1142           {
1143             System.arraycopy(annotations[a].annotations, 0, temp, 0,
1144                     copylen); // command.position);
1145           }
1146
1147           Annotation[] deleted = new Annotation[command.number];
1148           if (copylen >= command.position)
1149           {
1150             copylen = Math.min(command.number,
1151                     annotations[a].annotations.length - command.position);
1152             if (copylen > 0)
1153             {
1154               System.arraycopy(annotations[a].annotations, command.position,
1155                       deleted, 0, copylen); // command.number);
1156             }
1157           }
1158
1159           command.deletedAnnotations.put(annotations[a].annotationId,
1160                   deleted);
1161           if (annotations[a].annotations.length > command.position
1162                   + command.number)
1163           {
1164             System.arraycopy(annotations[a].annotations,
1165                     command.position + command.number, temp,
1166                     command.position, annotations[a].annotations.length
1167                             - command.position - command.number); // aSize
1168           }
1169         }
1170         else
1171         {
1172           int dSize = aSize - command.position;
1173
1174           if (dSize > 0)
1175           {
1176             Annotation[] deleted = new Annotation[command.number];
1177             System.arraycopy(annotations[a].annotations, command.position,
1178                     deleted, 0, dSize);
1179
1180             command.deletedAnnotations.put(annotations[a].annotationId,
1181                     deleted);
1182
1183             tSize = Math.min(annotations[a].annotations.length,
1184                     command.position);
1185             temp = new Annotation[tSize];
1186             System.arraycopy(annotations[a].annotations, 0, temp, 0, tSize);
1187           }
1188           else
1189           {
1190             temp = annotations[a].annotations;
1191           }
1192         }
1193       }
1194
1195       annotations[a].annotations = temp;
1196     }
1197   }
1198
1199   /**
1200    * Restores features to the state before a Cut.
1201    * <ul>
1202    * <li>re-add any features deleted by the cut</li>
1203    * <li>remove any truncated features created by the cut</li>
1204    * <li>shift right any features to the right of the cut</li>
1205    * </ul>
1206    *
1207    * @param command
1208    *          the Cut command
1209    * @param seq
1210    *          the sequence the Cut applied to
1211    * @param start
1212    *          the start residue position of the cut
1213    * @param length
1214    *          the number of residues cut
1215    * @param sameDatasetSequence
1216    *          true if dataset sequence and frame of reference were left
1217    *          unchanged by the Cut
1218    */
1219   final static void undoCutFeatures(Edit command, SequenceI seq,
1220           final int start, final int length, boolean sameDatasetSequence)
1221   {
1222     SequenceI sequence = seq.getDatasetSequence();
1223     if (sequence == null)
1224     {
1225       sequence = seq;
1226     }
1227
1228     /*
1229      * shift right features that lie to the right of the restored cut (but not
1230      * if dataset sequence unchanged - so coordinates were changed by Cut)
1231      */
1232     if (!sameDatasetSequence)
1233     {
1234       /*
1235        * shift right all features right of and not
1236        * contiguous with the cut position
1237        */
1238       seq.getFeatures().shiftFeatures(start + 1, length);
1239
1240       /*
1241        * shift right any features that start at the cut position,
1242        * unless they were truncated
1243        */
1244       List<SequenceFeature> sfs = seq.getFeatures().findFeatures(start,
1245               start);
1246       for (SequenceFeature sf : sfs)
1247       {
1248         if (sf.getBegin() == start)
1249         {
1250           if (!command.truncatedFeatures.containsKey(seq)
1251                   || !command.truncatedFeatures.get(seq).contains(sf))
1252           {
1253             /*
1254              * feature was shifted left to cut position (not truncated),
1255              * so shift it back right
1256              */
1257             SequenceFeature shifted = new SequenceFeature(sf, sf.getBegin()
1258                     + length, sf.getEnd() + length, sf.getFeatureGroup(),
1259                     sf.getScore());
1260             seq.addSequenceFeature(shifted);
1261             seq.deleteFeature(sf);
1262           }
1263         }
1264       }
1265     }
1266
1267     /*
1268      * restore any features that were deleted or truncated
1269      */
1270     if (command.deletedFeatures != null
1271             && command.deletedFeatures.containsKey(seq))
1272     {
1273       for (SequenceFeature deleted : command.deletedFeatures.get(seq))
1274       {
1275         sequence.addSequenceFeature(deleted);
1276       }
1277     }
1278
1279     /*
1280      * delete any truncated features
1281      */
1282     if (command.truncatedFeatures != null
1283             && command.truncatedFeatures.containsKey(seq))
1284     {
1285       for (SequenceFeature amended : command.truncatedFeatures.get(seq))
1286       {
1287         sequence.deleteFeature(amended);
1288       }
1289     }
1290   }
1291
1292   /**
1293    * Returns the list of edit commands wrapped by this object.
1294    *
1295    * @return
1296    */
1297   public List<Edit> getEdits()
1298   {
1299     return this.edits;
1300   }
1301
1302   /**
1303    * Returns a map whose keys are the dataset sequences, and values their
1304    * aligned sequences before the command edit list was applied. The aligned
1305    * sequences are copies, which may be updated without affecting the originals.
1306    *
1307    * The command holds references to the aligned sequences (after editing). If
1308    * the command is an 'undo',then the prior state is simply the aligned state.
1309    * Otherwise, we have to derive the prior state by working backwards through
1310    * the edit list to infer the aligned sequences before editing.
1311    *
1312    * Note: an alternative solution would be to cache the 'before' state of each
1313    * edit, but this would be expensive in space in the common case that the
1314    * original is never needed (edits are not mirrored).
1315    *
1316    * @return
1317    * @throws IllegalStateException
1318    *           on detecting an edit command of a type that can't be unwound
1319    */
1320   public Map<SequenceI, SequenceI> priorState(boolean forUndo)
1321   {
1322     Map<SequenceI, SequenceI> result = new HashMap<SequenceI, SequenceI>();
1323     if (getEdits() == null)
1324     {
1325       return result;
1326     }
1327     if (forUndo)
1328     {
1329       for (Edit e : getEdits())
1330       {
1331         for (SequenceI seq : e.getSequences())
1332         {
1333           SequenceI ds = seq.getDatasetSequence();
1334           // SequenceI preEdit = result.get(ds);
1335           if (!result.containsKey(ds))
1336           {
1337             /*
1338              * copy sequence including start/end (but don't use copy constructor
1339              * as we don't need annotations)
1340              */
1341             SequenceI preEdit = new Sequence("", seq.getSequenceAsString(),
1342                     seq.getStart(), seq.getEnd());
1343             preEdit.setDatasetSequence(ds);
1344             result.put(ds, preEdit);
1345           }
1346         }
1347       }
1348       return result;
1349     }
1350
1351     /*
1352      * Work backwards through the edit list, deriving the sequences before each
1353      * was applied. The final result is the sequence set before any edits.
1354      */
1355     Iterator<Edit> editList = new ReverseListIterator<Edit>(getEdits());
1356     while (editList.hasNext())
1357     {
1358       Edit oldEdit = editList.next();
1359       Action action = oldEdit.getAction();
1360       int position = oldEdit.getPosition();
1361       int number = oldEdit.getNumber();
1362       final char gap = oldEdit.getGapCharacter();
1363       for (SequenceI seq : oldEdit.getSequences())
1364       {
1365         SequenceI ds = seq.getDatasetSequence();
1366         SequenceI preEdit = result.get(ds);
1367         if (preEdit == null)
1368         {
1369           preEdit = new Sequence("", seq.getSequenceAsString(),
1370                   seq.getStart(), seq.getEnd());
1371           preEdit.setDatasetSequence(ds);
1372           result.put(ds, preEdit);
1373         }
1374         /*
1375          * 'Undo' this edit action on the sequence (updating the value in the
1376          * map).
1377          */
1378         if (ds != null)
1379         {
1380           if (action == Action.DELETE_GAP)
1381           {
1382             preEdit.setSequence(new String(StringUtils.insertCharAt(
1383                     preEdit.getSequence(), position, number, gap)));
1384           }
1385           else if (action == Action.INSERT_GAP)
1386           {
1387             preEdit.setSequence(new String(StringUtils.deleteChars(
1388                     preEdit.getSequence(), position, position + number)));
1389           }
1390           else
1391           {
1392             System.err.println("Can't undo edit action " + action);
1393             // throw new IllegalStateException("Can't undo edit action " +
1394             // action);
1395           }
1396         }
1397       }
1398     }
1399     return result;
1400   }
1401
1402   public class Edit
1403   {
1404     public SequenceI[] oldds;
1405
1406     /**
1407      * start and end of sequence prior to edit
1408      */
1409     public Range[] oldStartEnd;
1410
1411     boolean fullAlignmentHeight = false;
1412
1413     Map<SequenceI, AlignmentAnnotation[]> deletedAnnotationRows;
1414
1415     Map<String, Annotation[]> deletedAnnotations;
1416
1417     /*
1418      * features deleted by the cut (re-add on Undo)
1419      * (including the original of any shortened features)
1420      */
1421     Map<SequenceI, List<SequenceFeature>> deletedFeatures;
1422
1423     /*
1424      * shortened features added by the cut (delete on Undo)
1425      */
1426     Map<SequenceI, List<SequenceFeature>> truncatedFeatures;
1427
1428     AlignmentI al;
1429
1430     Action command;
1431
1432     char[][] string;
1433
1434     SequenceI[] seqs;
1435
1436     int[] alIndex;
1437
1438     int position, number;
1439
1440     char gapChar;
1441
1442     public Edit(Action cmd, SequenceI[] sqs, int pos, int count,
1443             char gap)
1444     {
1445       this.command = cmd;
1446       this.seqs = sqs;
1447       this.position = pos;
1448       this.number = count;
1449       this.gapChar = gap;
1450     }
1451
1452     Edit(Action cmd, SequenceI[] sqs, int pos, int count,
1453             AlignmentI align)
1454     {
1455       this(cmd, sqs, pos, count, align.getGapCharacter());
1456
1457       this.al = align;
1458
1459       alIndex = new int[sqs.length];
1460       for (int i = 0; i < sqs.length; i++)
1461       {
1462         alIndex[i] = align.findIndex(sqs[i]);
1463       }
1464
1465       fullAlignmentHeight = (align.getHeight() == sqs.length);
1466     }
1467
1468     Edit(Action cmd, SequenceI[] sqs, int pos, int count,
1469             AlignmentI align, String replace)
1470     {
1471       this(cmd, sqs, pos, count, align);
1472
1473       string = new char[sqs.length][];
1474       for (int i = 0; i < sqs.length; i++)
1475       {
1476         string[i] = replace.toCharArray();
1477       }
1478     }
1479
1480     public SequenceI[] getSequences()
1481     {
1482       return seqs;
1483     }
1484
1485     public int getPosition()
1486     {
1487       return position;
1488     }
1489
1490     public Action getAction()
1491     {
1492       return command;
1493     }
1494
1495     public int getNumber()
1496     {
1497       return number;
1498     }
1499
1500     public char getGapCharacter()
1501     {
1502       return gapChar;
1503     }
1504   }
1505
1506   /**
1507    * Returns an iterator over the list of edit commands which traverses the list
1508    * either forwards or backwards.
1509    *
1510    * @param forwards
1511    * @return
1512    */
1513   public Iterator<Edit> getEditIterator(boolean forwards)
1514   {
1515     if (forwards)
1516     {
1517       return getEdits().iterator();
1518     }
1519     else
1520     {
1521       return new ReverseListIterator<Edit>(getEdits());
1522     }
1523   }
1524
1525   /**
1526    * Adjusts features for Cut, and saves details of changes made to allow Undo
1527    * <ul>
1528    * <li>features left of the cut are unchanged</li>
1529    * <li>features right of the cut are shifted left</li>
1530    * <li>features internal to the cut region are deleted</li>
1531    * <li>features that overlap or span the cut are shortened</li>
1532    * <li>the originals of any deleted or shorted features are saved, to re-add
1533    * on Undo</li>
1534    * <li>any added (shortened) features are saved, to delete on Undo</li>
1535    * </ul>
1536    *
1537    * @param command
1538    * @param seq
1539    * @param fromPosition
1540    * @param toPosition
1541    * @param cutIsInternal
1542    */
1543   protected static void cutFeatures(Edit command, SequenceI seq,
1544           int fromPosition, int toPosition, boolean cutIsInternal)
1545   {
1546     /* if the cut is at start or end of sequence
1547      * then we don't modify the seuqence feature store
1548      */
1549     if (!cutIsInternal)
1550     {
1551       return;
1552     }
1553     List<SequenceFeature> added = new ArrayList<>();
1554     List<SequenceFeature> removed = new ArrayList<>();
1555
1556     SequenceFeaturesI featureStore = seq.getFeatures();
1557     if (toPosition < fromPosition || featureStore == null)
1558     {
1559       return;
1560     }
1561
1562     int cutStartPos = fromPosition;
1563     int cutEndPos = toPosition;
1564     int cutWidth = cutEndPos - cutStartPos + 1;
1565
1566     synchronized (featureStore)
1567     {
1568       /*
1569        * get features that overlap the cut region
1570        */
1571       List<SequenceFeature> toAmend = featureStore.findFeatures(
1572               cutStartPos, cutEndPos);
1573
1574       /*
1575        * add any contact features that span the cut region
1576        * (not returned by findFeatures)
1577        */
1578       for (SequenceFeature contact : featureStore.getContactFeatures())
1579       {
1580         if (contact.getBegin() < cutStartPos
1581                 && contact.getEnd() > cutEndPos)
1582         {
1583           toAmend.add(contact);
1584         }
1585       }
1586
1587       /*
1588        * adjust start-end of overlapping features;
1589        * delete features enclosed by the cut;
1590        * delete partially overlapping contact features
1591        */
1592       for (SequenceFeature sf : toAmend)
1593       {
1594         int sfBegin = sf.getBegin();
1595         int sfEnd = sf.getEnd();
1596         int newBegin = sfBegin;
1597         int newEnd = sfEnd;
1598         boolean toDelete = false;
1599         boolean follows = false;
1600
1601         if (sfBegin >= cutStartPos && sfEnd <= cutEndPos)
1602         {
1603           /*
1604            * feature lies within cut region - delete it
1605            */
1606           toDelete = true;
1607         }
1608         else if (sfBegin < cutStartPos && sfEnd > cutEndPos)
1609         {
1610           /*
1611            * feature spans cut region - left-shift the end
1612            */
1613           newEnd -= cutWidth;
1614         }
1615         else if (sfEnd <= cutEndPos)
1616         {
1617           /*
1618            * feature overlaps left of cut region - truncate right
1619            */
1620           newEnd = cutStartPos - 1;
1621           if (sf.isContactFeature())
1622           {
1623             toDelete = true;
1624           }
1625         }
1626         else if (sfBegin >= cutStartPos)
1627         {
1628           /*
1629            * remaining case - feature overlaps right
1630            * truncate left, adjust end of feature
1631            */
1632           newBegin = cutIsInternal ? cutStartPos : cutEndPos + 1;
1633           newEnd = newBegin + sfEnd - cutEndPos - 1;
1634           if (sf.isContactFeature())
1635           {
1636             toDelete = true;
1637           }
1638         }
1639
1640         seq.deleteFeature(sf);
1641         if (!follows)
1642         {
1643           removed.add(sf);
1644         }
1645         if (!toDelete)
1646         {
1647           SequenceFeature copy = new SequenceFeature(sf, newBegin, newEnd,
1648                   sf.getFeatureGroup(), sf.getScore());
1649           seq.addSequenceFeature(copy);
1650           if (!follows)
1651           {
1652             added.add(copy);
1653           }
1654         }
1655       }
1656
1657       /*
1658        * and left shift any features lying to the right of the cut region
1659        */
1660
1661       featureStore.shiftFeatures(cutEndPos + 1, -cutWidth);
1662     }
1663
1664     /*
1665      * save deleted and amended features, so that Undo can
1666      * re-add or delete them respectively
1667      */
1668     if (command.deletedFeatures == null)
1669     {
1670       command.deletedFeatures = new HashMap<>();
1671     }
1672     if (command.truncatedFeatures == null)
1673     {
1674       command.truncatedFeatures = new HashMap<>();
1675     }
1676     command.deletedFeatures.put(seq, removed);
1677     command.truncatedFeatures.put(seq, added);
1678   }
1679 }