experiment with reinstating the sandbox permissions
[jalview.git] / src / jalview / commands / EditCommand.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
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 of the License, or (at your option) any later version.
10  *  
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 package jalview.commands;
19
20 import java.util.*;
21
22 import jalview.datamodel.*;
23
24 /**
25  * 
26  * <p>
27  * Title: EditCommmand
28  * </p>
29  * 
30  * <p>
31  * Description: Essential information for performing undo and redo for cut/paste
32  * insert/delete gap which can be stored in the HistoryList
33  * </p>
34  * 
35  * <p>
36  * Copyright: Copyright (c) 2006
37  * </p>
38  * 
39  * <p>
40  * Company: Dundee University
41  * </p>
42  * 
43  * @author not attributable
44  * @version 1.0
45  */
46 public class EditCommand implements CommandI
47 {
48   public static final int INSERT_GAP = 0;
49
50   public static final int DELETE_GAP = 1;
51
52   public static final int CUT = 2;
53
54   public static final int PASTE = 3;
55
56   public static final int REPLACE = 4;
57
58   public static final int INSERT_NUC = 5;
59
60   Edit[] edits;
61
62   String description;
63
64   public EditCommand()
65   {
66   }
67
68   public EditCommand(String description)
69   {
70     this.description = description;
71   }
72
73   public EditCommand(String description, int command, SequenceI[] seqs,
74           int position, int number, AlignmentI al)
75   {
76     this.description = description;
77     if (command == CUT || command == PASTE)
78     {
79       edits = new Edit[]
80       { new Edit(command, seqs, position, number, al) };
81     }
82
83     performEdit(0, null);
84   }
85
86   public EditCommand(String description, int command, String replace,
87           SequenceI[] seqs, int position, int number, AlignmentI al)
88   {
89     this.description = description;
90     if (command == REPLACE)
91     {
92       edits = new Edit[]
93       { new Edit(command, seqs, position, number, al, replace) };
94     }
95
96     performEdit(0, null);
97   }
98
99   @Override
100   final public String getDescription()
101   {
102     return description;
103   }
104
105   @Override
106   public int getSize()
107   {
108     return edits == null ? 0 : edits.length;
109   }
110
111   final public AlignmentI getAlignment()
112   {
113     return edits[0].al;
114   }
115
116   /**
117    * append a new editCommand Note. this shouldn't be called if the edit is an
118    * operation affects more alignment objects than the one referenced in al (for
119    * example, cut or pasting whole sequences). Use the form with an additional
120    * AlignmentI[] views parameter.
121    * 
122    * @param command
123    * @param seqs
124    * @param position
125    * @param number
126    * @param al
127    * @param performEdit
128    */
129   final public void appendEdit(int command, SequenceI[] seqs, int position,
130           int number, AlignmentI al, boolean performEdit)
131   {
132     appendEdit(command, seqs, position, number, al, performEdit, null);
133   }
134
135   /**
136    * append a new edit command with a set of alignment views that may be
137    * operated on
138    * 
139    * @param command
140    * @param seqs
141    * @param position
142    * @param number
143    * @param al
144    * @param performEdit
145    * @param views
146    */
147   final public void appendEdit(int command, SequenceI[] seqs, int position,
148           int number, AlignmentI al, boolean performEdit, AlignmentI[] views)
149   {
150     Edit edit = new Edit(command, seqs, position, number,
151             al.getGapCharacter());
152     if (al.getHeight() == seqs.length)
153     {
154       edit.al = al;
155       edit.fullAlignmentHeight = true;
156     }
157
158     if (edits != null)
159     {
160       Edit[] temp = new Edit[edits.length + 1];
161       System.arraycopy(edits, 0, temp, 0, edits.length);
162       edits = temp;
163       edits[edits.length - 1] = edit;
164     }
165     else
166     {
167       edits = new Edit[]
168       { edit };
169     }
170
171     if (performEdit)
172     {
173       performEdit(edits.length - 1, views);
174     }
175   }
176
177   final void performEdit(int commandIndex, AlignmentI[] views)
178   {
179     int eSize = edits.length;
180     for (int e = commandIndex; e < eSize; e++)
181     {
182       switch (edits[e].command)
183       {
184       case INSERT_GAP:
185         insertGap(edits[e]);
186         break;
187       case DELETE_GAP:
188         deleteGap(edits[e]);
189         break;
190       case CUT:
191         cut(edits[e], views);
192         break;
193       case PASTE:
194         paste(edits[e], views);
195         break;
196       case REPLACE:
197         replace(edits[e]);
198         break;
199       // TODO:add deleteNuc for UNDO
200       // case INSERT_NUC:
201       // insertNuc(edits[e]);
202       // break;
203       }
204     }
205   }
206
207   @Override
208   final public void doCommand(AlignmentI[] views)
209   {
210     performEdit(0, views);
211   }
212
213   @Override
214   final public void undoCommand(AlignmentI[] views)
215   {
216     int e = 0, eSize = edits.length;
217     for (e = eSize - 1; e > -1; e--)
218     {
219       switch (edits[e].command)
220       {
221       case INSERT_GAP:
222         deleteGap(edits[e]);
223         break;
224       case DELETE_GAP:
225         insertGap(edits[e]);
226         break;
227       case CUT:
228         paste(edits[e], views);
229         break;
230       case PASTE:
231         cut(edits[e], views);
232         break;
233       case REPLACE:
234         replace(edits[e]);
235         break;
236       }
237     }
238   }
239
240   final void insertGap(Edit command)
241   {
242
243     for (int s = 0; s < command.seqs.length; s++)
244     {
245       command.seqs[s].insertCharAt(command.position, command.number,
246               command.gapChar);
247       // System.out.println("pos: "+command.position+" number: "+command.number);
248     }
249
250     adjustAnnotations(command, true, false, null);
251   }
252
253   //
254   // final void insertNuc(Edit command)
255   // {
256   //
257   // for (int s = 0; s < command.seqs.length; s++)
258   // {
259   // System.out.println("pos: "+command.position+" number: "+command.number);
260   // command.seqs[s].insertCharAt(command.position, command.number,'A');
261   // }
262   //
263   // adjustAnnotations(command, true, false, null);
264   // }
265
266   final void deleteGap(Edit command)
267   {
268     for (int s = 0; s < command.seqs.length; s++)
269     {
270       command.seqs[s].deleteChars(command.position, command.position
271               + command.number);
272     }
273
274     adjustAnnotations(command, false, false, null);
275   }
276
277   void cut(Edit command, AlignmentI[] views)
278   {
279     boolean seqDeleted = false;
280     command.string = new char[command.seqs.length][];
281
282     for (int i = 0; i < command.seqs.length; i++)
283     {
284       if (command.seqs[i].getLength() > command.position)
285       {
286         command.string[i] = command.seqs[i].getSequence(command.position,
287                 command.position + command.number);
288         SequenceI oldds = command.seqs[i].getDatasetSequence();
289         if (command.oldds != null && command.oldds[i] != null)
290         {
291           // we are redoing an undone cut.
292           command.seqs[i].setDatasetSequence(null);
293         }
294         command.seqs[i].deleteChars(command.position, command.position
295                 + command.number);
296         if (command.oldds != null && command.oldds[i] != null)
297         {
298           // oldds entry contains the cut dataset sequence.
299           command.seqs[i].setDatasetSequence(command.oldds[i]);
300           command.oldds[i] = oldds;
301         }
302         else
303         {
304           // modify the oldds if necessary
305           if (oldds != command.seqs[i].getDatasetSequence()
306                   || command.seqs[i].getSequenceFeatures() != null)
307           {
308             if (command.oldds == null)
309             {
310               command.oldds = new SequenceI[command.seqs.length];
311             }
312             command.oldds[i] = oldds;
313             adjustFeatures(
314                     command,
315                     i,
316                     command.seqs[i].findPosition(command.position),
317                     command.seqs[i].findPosition(command.position
318                             + command.number), false);
319           }
320         }
321       }
322
323       if (command.seqs[i].getLength() < 1)
324       {
325         command.al.deleteSequence(command.seqs[i]);
326         seqDeleted = true;
327       }
328     }
329
330     adjustAnnotations(command, false, seqDeleted, views);
331   }
332
333   void paste(Edit command, AlignmentI[] views)
334   {
335     StringBuffer tmp;
336     boolean newDSNeeded;
337     boolean newDSWasNeeded;
338     int newstart, newend;
339     boolean seqWasDeleted = false;
340     int start = 0, end = 0;
341
342     for (int i = 0; i < command.seqs.length; i++)
343     {
344       newDSNeeded = false;
345       newDSWasNeeded = command.oldds != null && command.oldds[i] != null;
346       if (command.seqs[i].getLength() < 1)
347       {
348         // ie this sequence was deleted, we need to
349         // read it to the alignment
350         if (command.alIndex[i] < command.al.getHeight())
351         {
352           List<SequenceI> sequences;
353           synchronized (sequences = command.al.getSequences())
354           {
355             sequences.add(command.alIndex[i], command.seqs[i]);
356           }
357         }
358         else
359         {
360           command.al.addSequence(command.seqs[i]);
361         }
362         seqWasDeleted = true;
363       }
364       newstart = command.seqs[i].getStart();
365       newend = command.seqs[i].getEnd();
366
367       tmp = new StringBuffer();
368       tmp.append(command.seqs[i].getSequence());
369       // Undo of a delete does not replace original dataset sequence on to
370       // alignment sequence.
371
372       if (command.string != null && command.string[i] != null)
373       {
374         if (command.position >= tmp.length())
375         {
376           // This occurs if padding is on, and residues
377           // are removed from end of alignment
378           int length = command.position - tmp.length();
379           while (length > 0)
380           {
381             tmp.append(command.gapChar);
382             length--;
383           }
384         }
385         tmp.insert(command.position, command.string[i]);
386         for (int s = 0; s < command.string[i].length; s++)
387         {
388           if (jalview.schemes.ResidueProperties.aaIndex[command.string[i][s]] != 23)
389           {
390             if (!newDSNeeded)
391             {
392               newDSNeeded = true;
393               start = command.seqs[i].findPosition(command.position);
394               end = command.seqs[i].findPosition(command.position
395                       + command.number);
396             }
397             if (command.seqs[i].getStart() == start)
398               newstart--;
399             else
400               newend++;
401           }
402         }
403         command.string[i] = null;
404       }
405
406       command.seqs[i].setSequence(tmp.toString());
407       command.seqs[i].setStart(newstart);
408       command.seqs[i].setEnd(newend);
409       if (newDSNeeded)
410       {
411         if (command.seqs[i].getDatasetSequence() != null)
412         {
413           SequenceI ds;
414           if (newDSWasNeeded)
415           {
416             ds = command.oldds[i];
417           }
418           else
419           {
420             // make a new DS sequence
421             // use new ds mechanism here
422             ds = new Sequence(command.seqs[i].getName(),
423                     jalview.analysis.AlignSeq.extractGaps(
424                             jalview.util.Comparison.GapChars,
425                             command.seqs[i].getSequenceAsString()),
426                     command.seqs[i].getStart(), command.seqs[i].getEnd());
427             ds.setDescription(command.seqs[i].getDescription());
428           }
429           if (command.oldds == null)
430           {
431             command.oldds = new SequenceI[command.seqs.length];
432           }
433           command.oldds[i] = command.seqs[i].getDatasetSequence();
434           command.seqs[i].setDatasetSequence(ds);
435         }
436         adjustFeatures(command, i, start, end, true);
437       }
438     }
439     adjustAnnotations(command, true, seqWasDeleted, views);
440
441     command.string = null;
442   }
443
444   void replace(Edit command)
445   {
446     StringBuffer tmp;
447     String oldstring;
448     int start = command.position;
449     int end = command.number;
450     // TODO TUTORIAL - Fix for replacement with different length of sequence (or
451     // whole sequence)
452     // TODO Jalview 2.4 bugfix change to an aggregate command - original
453     // sequence string is cut, new string is pasted in.
454     command.number = start + command.string[0].length;
455     for (int i = 0; i < command.seqs.length; i++)
456     {
457       boolean newDSWasNeeded = command.oldds != null
458               && command.oldds[i] != null;
459
460       /**
461        * cut addHistoryItem(new EditCommand("Cut Sequences", EditCommand.CUT,
462        * cut, sg.getStartRes(), sg.getEndRes()-sg.getStartRes()+1,
463        * viewport.alignment));
464        * 
465        */
466       /**
467        * then addHistoryItem(new EditCommand( "Add sequences",
468        * EditCommand.PASTE, sequences, 0, alignment.getWidth(), alignment) );
469        * 
470        */
471       oldstring = command.seqs[i].getSequenceAsString();
472       tmp = new StringBuffer(oldstring.substring(0, start));
473       tmp.append(command.string[i]);
474       String nogaprep = jalview.analysis.AlignSeq.extractGaps(
475               jalview.util.Comparison.GapChars, new String(
476                       command.string[i]));
477       int ipos = command.seqs[i].findPosition(start)
478               - command.seqs[i].getStart();
479       tmp.append(oldstring.substring(end));
480       command.seqs[i].setSequence(tmp.toString());
481       command.string[i] = oldstring.substring(start, end).toCharArray();
482       String nogapold = jalview.analysis.AlignSeq.extractGaps(
483               jalview.util.Comparison.GapChars, new String(
484                       command.string[i]));
485       if (!nogaprep.toLowerCase().equals(nogapold.toLowerCase()))
486       {
487         if (newDSWasNeeded)
488         {
489           SequenceI oldds = command.seqs[i].getDatasetSequence();
490           command.seqs[i].setDatasetSequence(command.oldds[i]);
491           command.oldds[i] = oldds;
492         }
493         else
494         {
495           if (command.oldds == null)
496           {
497             command.oldds = new SequenceI[command.seqs.length];
498           }
499           command.oldds[i] = command.seqs[i].getDatasetSequence();
500           SequenceI newds = new Sequence(
501                   command.seqs[i].getDatasetSequence());
502           String fullseq, osp = newds.getSequenceAsString();
503           fullseq = osp.substring(0, ipos) + nogaprep
504                   + osp.substring(ipos + nogaprep.length());
505           newds.setSequence(fullseq.toUpperCase());
506           // TODO: JAL-1131 ensure newly created dataset sequence is added to
507           // the set of
508           // dataset sequences associated with the alignment.
509           // TODO: JAL-1131 fix up any annotation associated with new dataset
510           // sequence to ensure that original sequence/annotation relationships
511           // are preserved.
512           command.seqs[i].setDatasetSequence(newds);
513
514         }
515       }
516       tmp = null;
517       oldstring = null;
518     }
519   }
520
521   final void adjustAnnotations(Edit command, boolean insert,
522           boolean modifyVisibility, AlignmentI[] views)
523   {
524     AlignmentAnnotation[] annotations = null;
525
526     if (modifyVisibility && !insert)
527     {
528       // only occurs if a sequence was added or deleted.
529       command.deletedAnnotationRows = new Hashtable();
530     }
531     if (command.fullAlignmentHeight)
532     {
533       annotations = command.al.getAlignmentAnnotation();
534     }
535     else
536     {
537       int aSize = 0;
538       AlignmentAnnotation[] tmp;
539       for (int s = 0; s < command.seqs.length; s++)
540       {
541         if (modifyVisibility)
542         {
543           // Rows are only removed or added to sequence object.
544           if (!insert)
545           {
546             // remove rows
547             tmp = command.seqs[s].getAnnotation();
548             if (tmp != null)
549             {
550               int alen = tmp.length;
551               for (int aa = 0; aa < tmp.length; aa++)
552               {
553                 if (!command.al.deleteAnnotation(tmp[aa]))
554                 {
555                   // strip out annotation not in the current al (will be put
556                   // back on insert in all views)
557                   tmp[aa] = null;
558                   alen--;
559                 }
560               }
561               command.seqs[s].setAlignmentAnnotation(null);
562               if (alen != tmp.length)
563               {
564                 // save the non-null annotation references only
565                 AlignmentAnnotation[] saved = new AlignmentAnnotation[alen];
566                 for (int aa = 0, aapos = 0; aa < tmp.length; aa++)
567                 {
568                   if (tmp[aa] != null)
569                   {
570                     saved[aapos++] = tmp[aa];
571                     tmp[aa] = null;
572                   }
573                 }
574                 tmp = saved;
575                 command.deletedAnnotationRows.put(command.seqs[s], saved);
576                 // and then remove any annotation in the other views
577                 for (int alview = 0; views != null && alview < views.length; alview++)
578                 {
579                   if (views[alview] != command.al)
580                   {
581                     AlignmentAnnotation[] toremove = views[alview]
582                             .getAlignmentAnnotation();
583                     if (toremove == null || toremove.length == 0)
584                     {
585                       continue;
586                     }
587                     // remove any alignment annotation on this sequence that's
588                     // on that alignment view.
589                     for (int aa = 0; aa < toremove.length; aa++)
590                     {
591                       if (toremove[aa].sequenceRef == command.seqs[s])
592                       {
593                         views[alview].deleteAnnotation(toremove[aa]);
594                       }
595                     }
596                   }
597                 }
598               }
599               else
600               {
601                 // save all the annotation
602                 command.deletedAnnotationRows.put(command.seqs[s], tmp);
603               }
604             }
605           }
606           else
607           {
608             // recover rows
609             if (command.deletedAnnotationRows != null
610                     && command.deletedAnnotationRows
611                             .containsKey(command.seqs[s]))
612             {
613               AlignmentAnnotation[] revealed = (AlignmentAnnotation[]) command.deletedAnnotationRows
614                       .get(command.seqs[s]);
615               command.seqs[s].setAlignmentAnnotation(revealed);
616               if (revealed != null)
617               {
618                 for (int aa = 0; aa < revealed.length; aa++)
619                 {
620                   // iterate through al adding original annotation
621                   command.al.addAnnotation(revealed[aa]);
622                 }
623                 for (int aa = 0; aa < revealed.length; aa++)
624                 {
625                   command.al.setAnnotationIndex(revealed[aa], aa);
626                 }
627                 // and then duplicate added annotation on every other alignment
628                 // view
629                 for (int vnum = 0; views != null && vnum < views.length; vnum++)
630                 {
631                   if (views[vnum] != command.al)
632                   {
633                     int avwidth = views[vnum].getWidth() + 1;
634                     // duplicate in this view
635                     for (int a = 0; a < revealed.length; a++)
636                     {
637                       AlignmentAnnotation newann = new AlignmentAnnotation(
638                               revealed[a]);
639                       command.seqs[s].addAlignmentAnnotation(newann);
640                       newann.padAnnotation(avwidth);
641                       views[vnum].addAnnotation(newann);
642                       views[vnum].setAnnotationIndex(newann, a);
643                     }
644                   }
645                 }
646               }
647             }
648           }
649           continue;
650         }
651
652         if (command.seqs[s].getAnnotation() == null)
653         {
654           continue;
655         }
656
657         if (aSize == 0)
658         {
659           annotations = command.seqs[s].getAnnotation();
660         }
661         else
662         {
663           tmp = new AlignmentAnnotation[aSize
664                   + command.seqs[s].getAnnotation().length];
665
666           System.arraycopy(annotations, 0, tmp, 0, aSize);
667
668           System.arraycopy(command.seqs[s].getAnnotation(), 0, tmp, aSize,
669                   command.seqs[s].getAnnotation().length);
670
671           annotations = tmp;
672         }
673         aSize = annotations.length;
674       }
675     }
676
677     if (annotations == null)
678     {
679       return;
680     }
681
682     if (!insert)
683     {
684       command.deletedAnnotations = new Hashtable();
685     }
686
687     int aSize;
688     Annotation[] temp;
689     for (int a = 0; a < annotations.length; a++)
690     {
691       if (annotations[a].autoCalculated
692               || annotations[a].annotations == null)
693       {
694         continue;
695       }
696
697       int tSize = 0;
698
699       aSize = annotations[a].annotations.length;
700       if (insert)
701       {
702         temp = new Annotation[aSize + command.number];
703         if (annotations[a].padGaps)
704           for (int aa = 0; aa < temp.length; aa++)
705           {
706             temp[aa] = new Annotation(command.gapChar + "", null, ' ', 0);
707           }
708       }
709       else
710       {
711         if (command.position < aSize)
712         {
713           if (command.position + command.number >= aSize)
714           {
715             tSize = aSize;
716           }
717           else
718           {
719             tSize = aSize - command.number;
720           }
721         }
722         else
723         {
724           tSize = aSize;
725         }
726
727         if (tSize < 0)
728         {
729           tSize = aSize;
730         }
731         temp = new Annotation[tSize];
732       }
733
734       if (insert)
735       {
736         if (command.position < annotations[a].annotations.length)
737         {
738           System.arraycopy(annotations[a].annotations, 0, temp, 0,
739                   command.position);
740
741           if (command.deletedAnnotations != null
742                   && command.deletedAnnotations
743                           .containsKey(annotations[a].annotationId))
744           {
745             Annotation[] restore = (Annotation[]) command.deletedAnnotations
746                     .get(annotations[a].annotationId);
747
748             System.arraycopy(restore, 0, temp, command.position,
749                     command.number);
750
751           }
752
753           System.arraycopy(annotations[a].annotations, command.position,
754                   temp, command.position + command.number, aSize
755                           - command.position);
756         }
757         else
758         {
759           if (command.deletedAnnotations != null
760                   && command.deletedAnnotations
761                           .containsKey(annotations[a].annotationId))
762           {
763             Annotation[] restore = (Annotation[]) command.deletedAnnotations
764                     .get(annotations[a].annotationId);
765
766             temp = new Annotation[annotations[a].annotations.length
767                     + restore.length];
768             System.arraycopy(annotations[a].annotations, 0, temp, 0,
769                     annotations[a].annotations.length);
770             System.arraycopy(restore, 0, temp,
771                     annotations[a].annotations.length, restore.length);
772           }
773           else
774           {
775             temp = annotations[a].annotations;
776           }
777         }
778       }
779       else
780       {
781         if (tSize != aSize || command.position < 2)
782         {
783           int copylen = Math.min(command.position,
784                   annotations[a].annotations.length);
785           if (copylen > 0)
786             System.arraycopy(annotations[a].annotations, 0, temp, 0,
787                     copylen); // command.position);
788
789           Annotation[] deleted = new Annotation[command.number];
790           if (copylen >= command.position)
791           {
792             copylen = Math.min(command.number,
793                     annotations[a].annotations.length - command.position);
794             if (copylen > 0)
795             {
796               System.arraycopy(annotations[a].annotations,
797                       command.position, deleted, 0, copylen); // command.number);
798             }
799           }
800
801           command.deletedAnnotations.put(annotations[a].annotationId,
802                   deleted);
803           if (annotations[a].annotations.length > command.position
804                   + command.number)
805           {
806             System.arraycopy(annotations[a].annotations, command.position
807                     + command.number, temp, command.position,
808                     annotations[a].annotations.length - command.position
809                             - command.number); // aSize
810           }
811         }
812         else
813         {
814           int dSize = aSize - command.position;
815
816           if (dSize > 0)
817           {
818             Annotation[] deleted = new Annotation[command.number];
819             System.arraycopy(annotations[a].annotations, command.position,
820                     deleted, 0, dSize);
821
822             command.deletedAnnotations.put(annotations[a].annotationId,
823                     deleted);
824
825             tSize = Math.min(annotations[a].annotations.length,
826                     command.position);
827             temp = new Annotation[tSize];
828             System.arraycopy(annotations[a].annotations, 0, temp, 0, tSize);
829           }
830           else
831           {
832             temp = annotations[a].annotations;
833           }
834         }
835       }
836
837       annotations[a].annotations = temp;
838     }
839   }
840
841   final void adjustFeatures(Edit command, int index, int i, int j,
842           boolean insert)
843   {
844     SequenceI seq = command.seqs[index];
845     SequenceI sequence = seq.getDatasetSequence();
846     if (sequence == null)
847     {
848       sequence = seq;
849     }
850
851     if (insert)
852     {
853       if (command.editedFeatures != null
854               && command.editedFeatures.containsKey(seq))
855       {
856         sequence.setSequenceFeatures((SequenceFeature[]) command.editedFeatures
857                 .get(seq));
858       }
859
860       return;
861     }
862
863     SequenceFeature[] sf = sequence.getSequenceFeatures();
864
865     if (sf == null)
866     {
867       return;
868     }
869
870     SequenceFeature[] oldsf = new SequenceFeature[sf.length];
871
872     int cSize = j - i;
873
874     for (int s = 0; s < sf.length; s++)
875     {
876       SequenceFeature copy = new SequenceFeature(sf[s]);
877
878       oldsf[s] = copy;
879
880       if (sf[s].getEnd() < i)
881       {
882         continue;
883       }
884
885       if (sf[s].getBegin() > j)
886       {
887         sf[s].setBegin(copy.getBegin() - cSize);
888         sf[s].setEnd(copy.getEnd() - cSize);
889         continue;
890       }
891
892       if (sf[s].getBegin() >= i)
893       {
894         sf[s].setBegin(i);
895       }
896
897       if (sf[s].getEnd() < j)
898       {
899         sf[s].setEnd(j - 1);
900       }
901
902       sf[s].setEnd(sf[s].getEnd() - (cSize));
903
904       if (sf[s].getBegin() > sf[s].getEnd())
905       {
906         sequence.deleteFeature(sf[s]);
907       }
908     }
909
910     if (command.editedFeatures == null)
911     {
912       command.editedFeatures = new Hashtable();
913     }
914
915     command.editedFeatures.put(seq, oldsf);
916
917   }
918
919   class Edit
920   {
921     public SequenceI[] oldds;
922
923     boolean fullAlignmentHeight = false;
924
925     Hashtable deletedAnnotationRows;
926
927     Hashtable deletedAnnotations;
928
929     Hashtable editedFeatures;
930
931     AlignmentI al;
932
933     int command;
934
935     char[][] string;
936
937     SequenceI[] seqs;
938
939     int[] alIndex;
940
941     int position, number;
942
943     char gapChar;
944
945     Edit(int command, SequenceI[] seqs, int position, int number,
946             char gapChar)
947     {
948       this.command = command;
949       this.seqs = seqs;
950       this.position = position;
951       this.number = number;
952       this.gapChar = gapChar;
953     }
954
955     Edit(int command, SequenceI[] seqs, int position, int number,
956             AlignmentI al)
957     {
958       this.gapChar = al.getGapCharacter();
959       this.command = command;
960       this.seqs = seqs;
961       this.position = position;
962       this.number = number;
963       this.al = al;
964
965       alIndex = new int[seqs.length];
966       for (int i = 0; i < seqs.length; i++)
967       {
968         alIndex[i] = al.findIndex(seqs[i]);
969       }
970
971       fullAlignmentHeight = (al.getHeight() == seqs.length);
972     }
973
974     Edit(int command, SequenceI[] seqs, int position, int number,
975             AlignmentI al, String replace)
976     {
977       this.command = command;
978       this.seqs = seqs;
979       this.position = position;
980       this.number = number;
981       this.al = al;
982       this.gapChar = al.getGapCharacter();
983       string = new char[seqs.length][];
984       for (int i = 0; i < seqs.length; i++)
985       {
986         string[i] = replace.toCharArray();
987       }
988
989       fullAlignmentHeight = (al.getHeight() == seqs.length);
990     }
991   }
992 }