experiment with reinstating the sandbox permissions
[jalview.git] / src / jalview / appletgui / SeqPanel.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.appletgui;
19
20 import java.util.*;
21
22 import java.awt.*;
23 import java.awt.event.*;
24
25 import jalview.commands.*;
26 import jalview.datamodel.*;
27 import jalview.schemes.*;
28 import jalview.structure.SelectionSource;
29 import jalview.structure.SequenceListener;
30 import jalview.structure.StructureSelectionManager;
31
32 public class SeqPanel extends Panel implements MouseMotionListener,
33         MouseListener, SequenceListener
34 {
35
36   public SeqCanvas seqCanvas;
37
38   public AlignmentPanel ap;
39
40   protected int lastres;
41
42   protected int startseq;
43
44   protected AlignViewport av;
45
46   // if character is inserted or deleted, we will need to recalculate the
47   // conservation
48   boolean seqEditOccurred = false;
49
50   ScrollThread scrollThread = null;
51
52   boolean mouseDragging = false;
53
54   boolean editingSeqs = false;
55
56   boolean groupEditing = false;
57
58   int oldSeq = -1;
59
60   boolean changeEndSeq = false;
61
62   boolean changeStartSeq = false;
63
64   boolean changeEndRes = false;
65
66   boolean changeStartRes = false;
67
68   SequenceGroup stretchGroup = null;
69
70   StringBuffer keyboardNo1;
71
72   StringBuffer keyboardNo2;
73
74   boolean mouseWheelPressed = false;
75
76   Point lastMousePress;
77
78   EditCommand editCommand;
79
80   StructureSelectionManager ssm;
81
82   public SeqPanel(AlignViewport avp, AlignmentPanel p)
83   {
84     this.av = avp;
85
86     seqCanvas = new SeqCanvas(avp);
87     setLayout(new BorderLayout());
88     add(seqCanvas);
89
90     ap = p;
91
92     seqCanvas.addMouseMotionListener(this);
93     seqCanvas.addMouseListener(this);
94     ssm = StructureSelectionManager.getStructureSelectionManager(av.applet);
95     ssm.addStructureViewerListener(this);
96
97     seqCanvas.repaint();
98   }
99
100   void endEditing()
101   {
102     if (editCommand != null && editCommand.getSize() > 0)
103     {
104       ap.alignFrame.addHistoryItem(editCommand);
105       av.firePropertyChange("alignment", null, av.getAlignment()
106               .getSequences());
107     }
108
109     startseq = -1;
110     lastres = -1;
111     editingSeqs = false;
112     groupEditing = false;
113     keyboardNo1 = null;
114     keyboardNo2 = null;
115     editCommand = null;
116   }
117
118   void setCursorRow()
119   {
120     seqCanvas.cursorY = getKeyboardNo1() - 1;
121     scrollToVisible();
122   }
123
124   void setCursorColumn()
125   {
126     seqCanvas.cursorX = getKeyboardNo1() - 1;
127     scrollToVisible();
128   }
129
130   void setCursorRowAndColumn()
131   {
132     if (keyboardNo2 == null)
133     {
134       keyboardNo2 = new StringBuffer();
135     }
136     else
137     {
138       seqCanvas.cursorX = getKeyboardNo1() - 1;
139       seqCanvas.cursorY = getKeyboardNo2() - 1;
140       scrollToVisible();
141     }
142   }
143
144   void setCursorPosition()
145   {
146     SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(
147             seqCanvas.cursorY);
148
149     seqCanvas.cursorX = sequence.findIndex(getKeyboardNo1()) - 1;
150     scrollToVisible();
151   }
152
153   void moveCursor(int dx, int dy)
154   {
155     seqCanvas.cursorX += dx;
156     seqCanvas.cursorY += dy;
157     if (av.hasHiddenColumns()
158             && !av.getColumnSelection().isVisible(seqCanvas.cursorX))
159     {
160       int original = seqCanvas.cursorX - dx;
161       int maxWidth = av.getAlignment().getWidth();
162
163       while (!av.getColumnSelection().isVisible(seqCanvas.cursorX)
164               && seqCanvas.cursorX < maxWidth && seqCanvas.cursorX > 0)
165       {
166         seqCanvas.cursorX += dx;
167       }
168
169       if (seqCanvas.cursorX >= maxWidth
170               || !av.getColumnSelection().isVisible(seqCanvas.cursorX))
171       {
172         seqCanvas.cursorX = original;
173       }
174     }
175     scrollToVisible();
176   }
177
178   void scrollToVisible()
179   {
180     if (seqCanvas.cursorX < 0)
181     {
182       seqCanvas.cursorX = 0;
183     }
184     else if (seqCanvas.cursorX > av.getAlignment().getWidth() - 1)
185     {
186       seqCanvas.cursorX = av.getAlignment().getWidth() - 1;
187     }
188
189     if (seqCanvas.cursorY < 0)
190     {
191       seqCanvas.cursorY = 0;
192     }
193     else if (seqCanvas.cursorY > av.getAlignment().getHeight() - 1)
194     {
195       seqCanvas.cursorY = av.getAlignment().getHeight() - 1;
196     }
197
198     endEditing();
199     if (av.wrapAlignment)
200     {
201       ap.scrollToWrappedVisible(seqCanvas.cursorX);
202     }
203     else
204     {
205       while (seqCanvas.cursorY < av.startSeq)
206       {
207         ap.scrollUp(true);
208       }
209       while (seqCanvas.cursorY + 1 > av.endSeq)
210       {
211         ap.scrollUp(false);
212       }
213       while (seqCanvas.cursorX < av.getColumnSelection()
214               .adjustForHiddenColumns(av.startRes))
215       {
216
217         if (!ap.scrollRight(false))
218         {
219           break;
220         }
221       }
222       while (seqCanvas.cursorX > av.getColumnSelection()
223               .adjustForHiddenColumns(av.endRes))
224       {
225         if (!ap.scrollRight(true))
226         {
227           break;
228         }
229       }
230     }
231     setStatusMessage(av.getAlignment().getSequenceAt(seqCanvas.cursorY),
232             seqCanvas.cursorX, seqCanvas.cursorY);
233
234     seqCanvas.repaint();
235   }
236
237   void setSelectionAreaAtCursor(boolean topLeft)
238   {
239     SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(
240             seqCanvas.cursorY);
241
242     if (av.getSelectionGroup() != null)
243     {
244       SequenceGroup sg = av.getSelectionGroup();
245       // Find the top and bottom of this group
246       int min = av.getAlignment().getHeight(), max = 0;
247       for (int i = 0; i < sg.getSize(); i++)
248       {
249         int index = av.getAlignment().findIndex(sg.getSequenceAt(i));
250         if (index > max)
251         {
252           max = index;
253         }
254         if (index < min)
255         {
256           min = index;
257         }
258       }
259
260       max++;
261
262       if (topLeft)
263       {
264         sg.setStartRes(seqCanvas.cursorX);
265         if (sg.getEndRes() < seqCanvas.cursorX)
266         {
267           sg.setEndRes(seqCanvas.cursorX);
268         }
269
270         min = seqCanvas.cursorY;
271       }
272       else
273       {
274         sg.setEndRes(seqCanvas.cursorX);
275         if (sg.getStartRes() > seqCanvas.cursorX)
276         {
277           sg.setStartRes(seqCanvas.cursorX);
278         }
279
280         max = seqCanvas.cursorY + 1;
281       }
282
283       if (min > max)
284       {
285         // Only the user can do this
286         av.setSelectionGroup(null);
287       }
288       else
289       {
290         // Now add any sequences between min and max
291         sg.clear();
292         for (int i = min; i < max; i++)
293         {
294           sg.addSequence(av.getAlignment().getSequenceAt(i), false);
295         }
296       }
297     }
298
299     if (av.getSelectionGroup() == null)
300     {
301       SequenceGroup sg = new SequenceGroup();
302       sg.setStartRes(seqCanvas.cursorX);
303       sg.setEndRes(seqCanvas.cursorX);
304       sg.addSequence(sequence, false);
305       av.setSelectionGroup(sg);
306     }
307     ap.paintAlignment(false);
308     av.sendSelection();
309   }
310
311   void insertGapAtCursor(boolean group)
312   {
313     groupEditing = group;
314     startseq = seqCanvas.cursorY;
315     lastres = seqCanvas.cursorX;
316     editSequence(true, seqCanvas.cursorX + getKeyboardNo1());
317     endEditing();
318   }
319
320   void deleteGapAtCursor(boolean group)
321   {
322     groupEditing = group;
323     startseq = seqCanvas.cursorY;
324     lastres = seqCanvas.cursorX + getKeyboardNo1();
325     editSequence(false, seqCanvas.cursorX);
326     endEditing();
327   }
328
329   void numberPressed(char value)
330   {
331     if (keyboardNo1 == null)
332     {
333       keyboardNo1 = new StringBuffer();
334     }
335
336     if (keyboardNo2 != null)
337     {
338       keyboardNo2.append(value);
339     }
340     else
341     {
342       keyboardNo1.append(value);
343     }
344   }
345   int getKeyboardNo1()
346   {
347     try {
348     if (keyboardNo1 != null) 
349     {
350       int value = Integer.parseInt(keyboardNo1.toString());
351       keyboardNo1 = null;
352       return value;
353     }
354     } catch (Exception x)
355     {}
356     keyboardNo1 = null;
357     return 1;
358   }
359
360   int getKeyboardNo2()
361   {
362     try {
363     if (keyboardNo2!=null){
364       int value = Integer.parseInt(keyboardNo2.toString());
365       keyboardNo2 = null;
366       return value;
367     }
368     } catch (Exception x)
369     {}
370     keyboardNo2 = null;
371     return 1;
372   }
373   
374   void setStatusMessage(SequenceI sequence, int res, int seq)
375   {
376     StringBuffer text = new StringBuffer("Sequence " + (seq + 1) + " ID: "
377             + sequence.getName());
378
379     Object obj = null;
380     if (av.getAlignment().isNucleotide())
381     {
382       obj = ResidueProperties.nucleotideName.get(sequence.getCharAt(res)
383               + "");
384       if (obj != null)
385       {
386         text.append(" Nucleotide: ");
387       }
388     }
389     else
390     {
391       obj = ResidueProperties.aa2Triplet.get(sequence.getCharAt(res) + "");
392       if (obj != null)
393       {
394         text.append("  Residue: ");
395       }
396     }
397
398     if (obj != null)
399     {
400
401       if (obj != "")
402       {
403         text.append(obj + " (" + sequence.findPosition(res) + ")");
404       }
405     }
406
407     ap.alignFrame.statusBar.setText(text.toString());
408
409   }
410
411   public void mousePressed(MouseEvent evt)
412   {
413     lastMousePress = evt.getPoint();
414
415     // For now, ignore the mouseWheel font resizing on Macs
416     // As the Button2_mask always seems to be true
417     if ((evt.getModifiers() & InputEvent.BUTTON2_MASK) == InputEvent.BUTTON2_MASK
418             && !av.MAC)
419     {
420       mouseWheelPressed = true;
421       return;
422     }
423
424     if (evt.isShiftDown() || evt.isControlDown() || evt.isAltDown())
425     {
426       if (evt.isControlDown() || evt.isAltDown())
427       {
428         groupEditing = true;
429       }
430       editingSeqs = true;
431     }
432     else
433     {
434       doMousePressedDefineMode(evt);
435       return;
436     }
437
438     int seq = findSeq(evt);
439     int res = findRes(evt);
440
441     if (seq < 0 || res < 0)
442     {
443       return;
444     }
445
446     if ((seq < av.getAlignment().getHeight())
447             && (res < av.getAlignment().getSequenceAt(seq).getLength()))
448     {
449       startseq = seq;
450       lastres = res;
451     }
452     else
453     {
454       startseq = -1;
455       lastres = -1;
456     }
457
458     return;
459   }
460
461   public void mouseClicked(MouseEvent evt)
462   {
463     SequenceI sequence = av.getAlignment().getSequenceAt(findSeq(evt));
464     if (evt.getClickCount() > 1)
465     {
466       if (av.getSelectionGroup() != null
467               && av.getSelectionGroup().getSize() == 1
468               && av.getSelectionGroup().getEndRes()
469                       - av.getSelectionGroup().getStartRes() < 2)
470       {
471         av.setSelectionGroup(null);
472       }
473
474       SequenceFeature[] features = findFeaturesAtRes(sequence,
475               sequence.findPosition(findRes(evt)));
476
477       if (features != null && features.length > 0)
478       {
479         SearchResults highlight = new SearchResults();
480         highlight.addResult(sequence, features[0].getBegin(),
481                 features[0].getEnd());
482         seqCanvas.highlightSearchResults(highlight);
483       }
484       if (features != null && features.length > 0)
485       {
486         seqCanvas.getFeatureRenderer().amendFeatures(new SequenceI[]
487         { sequence }, features, false, ap);
488
489         seqCanvas.highlightSearchResults(null);
490       }
491     }
492   }
493
494   public void mouseReleased(MouseEvent evt)
495   {
496     mouseDragging = false;
497     mouseWheelPressed = false;
498     ap.paintAlignment(true);
499
500     if (!editingSeqs)
501     {
502       doMouseReleasedDefineMode(evt);
503       return;
504     }
505
506     endEditing();
507
508   }
509
510   int startWrapBlock = -1;
511
512   int wrappedBlock = -1;
513
514   int findRes(MouseEvent evt)
515   {
516     int res = 0;
517     int x = evt.getX();
518
519     if (av.wrapAlignment)
520     {
521
522       int hgap = av.charHeight;
523       if (av.scaleAboveWrapped)
524       {
525         hgap += av.charHeight;
526       }
527
528       int cHeight = av.getAlignment().getHeight() * av.charHeight + hgap
529               + seqCanvas.getAnnotationHeight();
530
531       int y = evt.getY();
532       y -= hgap;
533       x -= seqCanvas.LABEL_WEST;
534
535       int cwidth = seqCanvas.getWrappedCanvasWidth(getSize().width);
536       if (cwidth < 1)
537       {
538         return 0;
539       }
540
541       wrappedBlock = y / cHeight;
542       wrappedBlock += av.getStartRes() / cwidth;
543
544       res = wrappedBlock * cwidth + x / av.getCharWidth();
545
546     }
547     else
548     {
549       res = (x / av.getCharWidth()) + av.getStartRes();
550     }
551
552     if (av.hasHiddenColumns())
553     {
554       res = av.getColumnSelection().adjustForHiddenColumns(res);
555     }
556
557     return res;
558
559   }
560
561   int findSeq(MouseEvent evt)
562   {
563     final int sqnum = findAlRow(evt);
564     return (sqnum < 0) ? 0 : sqnum;
565   }
566
567   /**
568    * 
569    * @param evt
570    * @return row in alignment that was selected (or -1 for column selection)
571    */
572   private int findAlRow(MouseEvent evt)
573   {
574     int seq = 0;
575     int y = evt.getY();
576
577     if (av.wrapAlignment)
578     {
579       int hgap = av.charHeight;
580       if (av.scaleAboveWrapped)
581       {
582         hgap += av.charHeight;
583       }
584
585       int cHeight = av.getAlignment().getHeight() * av.charHeight + hgap
586               + seqCanvas.getAnnotationHeight();
587
588       y -= hgap;
589
590       seq = Math.min((y % cHeight) / av.getCharHeight(), av.getAlignment()
591               .getHeight() - 1);
592       if (seq < 0)
593       {
594         seq = -1;
595       }
596     }
597     else
598     {
599       seq = Math.min((y / av.getCharHeight()) + av.getStartSeq(), av
600               .getAlignment().getHeight() - 1);
601       if (seq < 0)
602       {
603         seq = -1;
604       }
605     }
606
607     return seq;
608   }
609
610   public void doMousePressed(MouseEvent evt)
611   {
612
613     int seq = findSeq(evt);
614     int res = findRes(evt);
615
616     if (seq < av.getAlignment().getHeight()
617             && res < av.getAlignment().getSequenceAt(seq).getLength())
618     {
619       // char resstr = align.getSequenceAt(seq).getSequence().charAt(res);
620       // Find the residue's position in the sequence (res is the position
621       // in the alignment
622
623       startseq = seq;
624       lastres = res;
625     }
626     else
627     {
628       startseq = -1;
629       lastres = -1;
630     }
631
632     return;
633   }
634
635   String lastMessage;
636
637   public void mouseOverSequence(SequenceI sequence, int index, int pos)
638   {
639     String tmp = sequence.hashCode() + index + "";
640     if (lastMessage == null || !lastMessage.equals(tmp))
641       ssm.mouseOverSequence(sequence, index, pos, av);
642
643     lastMessage = tmp;
644   }
645
646   public void highlightSequence(SearchResults results)
647   {
648     if (av.followHighlight)
649     {
650       if (ap.scrollToPosition(results, true))
651       {
652         ap.alignFrame.repaint();
653       }
654     }
655     seqCanvas.highlightSearchResults(results);
656
657   }
658
659   public void updateColours(SequenceI seq, int index)
660   {
661     System.out.println("update the seqPanel colours");
662     // repaint();
663   }
664
665   public void mouseMoved(MouseEvent evt)
666   {
667     int res = findRes(evt);
668     int seq = findSeq(evt);
669
670     if (seq >= av.getAlignment().getHeight() || seq < 0 || res < 0)
671     {
672       if (tooltip != null)
673       {
674         tooltip.setTip("");
675       }
676       return;
677     }
678
679     SequenceI sequence = av.getAlignment().getSequenceAt(seq);
680     if (res > sequence.getLength())
681     {
682       if (tooltip != null)
683       {
684         tooltip.setTip("");
685       }
686       return;
687     }
688
689     int respos = sequence.findPosition(res);
690     if (ssm != null)
691       mouseOverSequence(sequence, res, respos);
692
693     StringBuffer text = new StringBuffer("Sequence " + (seq + 1) + " ID: "
694             + sequence.getName());
695
696     Object obj = null;
697     if (av.getAlignment().isNucleotide())
698     {
699       obj = ResidueProperties.nucleotideName.get(sequence.getCharAt(res)
700               + "");
701       if (obj != null)
702       {
703         text.append(" Nucleotide: ");
704       }
705     }
706     else
707     {
708       obj = ResidueProperties.aa2Triplet.get(sequence.getCharAt(res) + "");
709       if (obj != null)
710       {
711         text.append("  Residue: ");
712       }
713     }
714
715     if (obj != null)
716     {
717       if (obj != "")
718       {
719         text.append(obj + " (" + respos + ")");
720       }
721     }
722
723     ap.alignFrame.statusBar.setText(text.toString());
724
725     StringBuffer tooltipText = new StringBuffer();
726     SequenceGroup[] groups = av.getAlignment().findAllGroups(sequence);
727     if (groups != null)
728     {
729       for (int g = 0; g < groups.length; g++)
730       {
731         if (groups[g].getStartRes() <= res && groups[g].getEndRes() >= res)
732         {
733           if (!groups[g].getName().startsWith("JTreeGroup")
734                   && !groups[g].getName().startsWith("JGroup"))
735           {
736             tooltipText.append(groups[g].getName() + " ");
737           }
738           if (groups[g].getDescription() != null)
739           {
740             tooltipText.append(groups[g].getDescription());
741           }
742           tooltipText.append("\n");
743         }
744       }
745     }
746
747     // use aa to see if the mouse pointer is on a
748     SequenceFeature[] allFeatures = findFeaturesAtRes(sequence,
749             sequence.findPosition(res));
750
751     int index = 0;
752     while (index < allFeatures.length)
753     {
754       SequenceFeature sf = allFeatures[index];
755
756       tooltipText.append(sf.getType() + " " + sf.begin + ":" + sf.end);
757
758       if (sf.getDescription() != null)
759       {
760         tooltipText.append(" " + sf.getDescription());
761       }
762
763       if (sf.getValue("status") != null)
764       {
765         String status = sf.getValue("status").toString();
766         if (status.length() > 0)
767         {
768           tooltipText.append(" (" + sf.getValue("status") + ")");
769         }
770       }
771       tooltipText.append("\n");
772
773       index++;
774     }
775
776     if (tooltip == null)
777     {
778       tooltip = new Tooltip(tooltipText.toString(), seqCanvas);
779     }
780     else
781     {
782       tooltip.setTip(tooltipText.toString());
783     }
784   }
785
786   SequenceFeature[] findFeaturesAtRes(SequenceI sequence, int res)
787   {
788     Vector tmp = new Vector();
789     SequenceFeature[] features = sequence.getSequenceFeatures();
790     if (features != null)
791     {
792       for (int i = 0; i < features.length; i++)
793       {
794         if (av.featuresDisplayed == null
795                 || !av.featuresDisplayed.containsKey(features[i].getType()))
796         {
797           continue;
798         }
799
800         if (features[i].featureGroup != null
801                 && seqCanvas.fr.featureGroups != null
802                 && seqCanvas.fr.featureGroups
803                         .containsKey(features[i].featureGroup)
804                 && !((Boolean) seqCanvas.fr.featureGroups
805                         .get(features[i].featureGroup)).booleanValue())
806           continue;
807
808         if ((features[i].getBegin() <= res)
809                 && (features[i].getEnd() >= res))
810         {
811           tmp.addElement(features[i]);
812         }
813       }
814     }
815
816     features = new SequenceFeature[tmp.size()];
817     tmp.copyInto(features);
818
819     return features;
820   }
821
822   Tooltip tooltip;
823
824   public void mouseDragged(MouseEvent evt)
825   {
826     if (mouseWheelPressed)
827     {
828       int oldWidth = av.charWidth;
829
830       // Which is bigger, left-right or up-down?
831       if (Math.abs(evt.getY() - lastMousePress.y) > Math.abs(evt.getX()
832               - lastMousePress.x))
833       {
834         int fontSize = av.font.getSize();
835
836         if (evt.getY() < lastMousePress.y && av.charHeight > 1)
837         {
838           fontSize--;
839         }
840         else if (evt.getY() > lastMousePress.y)
841         {
842           fontSize++;
843         }
844
845         if (fontSize < 1)
846         {
847           fontSize = 1;
848         }
849
850         av.setFont(new Font(av.font.getName(), av.font.getStyle(), fontSize));
851         av.charWidth = oldWidth;
852       }
853       else
854       {
855         if (evt.getX() < lastMousePress.x && av.charWidth > 1)
856         {
857           av.charWidth--;
858         }
859         else if (evt.getX() > lastMousePress.x)
860         {
861           av.charWidth++;
862         }
863
864         if (av.charWidth < 1)
865         {
866           av.charWidth = 1;
867         }
868       }
869
870       ap.fontChanged();
871
872       FontMetrics fm = getFontMetrics(av.getFont());
873       av.validCharWidth = fm.charWidth('M') <= av.charWidth;
874
875       lastMousePress = evt.getPoint();
876
877       ap.paintAlignment(false);
878       ap.annotationPanel.image = null;
879       return;
880     }
881
882     if (!editingSeqs)
883     {
884       doMouseDraggedDefineMode(evt);
885       return;
886     }
887
888     int res = findRes(evt);
889
890     if (res < 0)
891     {
892       res = 0;
893     }
894
895     if ((lastres == -1) || (lastres == res))
896     {
897       return;
898     }
899
900     if ((res < av.getAlignment().getWidth()) && (res < lastres))
901     {
902       // dragLeft, delete gap
903       editSequence(false, res);
904     }
905     else
906     {
907       editSequence(true, res);
908     }
909
910     mouseDragging = true;
911     if (scrollThread != null)
912     {
913       scrollThread.setEvent(evt);
914     }
915
916   }
917
918   synchronized void editSequence(boolean insertGap, int startres)
919   {
920     int fixedLeft = -1;
921     int fixedRight = -1;
922     boolean fixedColumns = false;
923     SequenceGroup sg = av.getSelectionGroup();
924
925     SequenceI seq = av.getAlignment().getSequenceAt(startseq);
926
927     if (!groupEditing && av.hasHiddenRows())
928     {
929       if (av.isHiddenRepSequence(seq))
930       {
931         sg = (SequenceGroup) av.getRepresentedSequences(seq);
932         groupEditing = true;
933       }
934     }
935
936     StringBuffer message = new StringBuffer();
937     if (groupEditing)
938     {
939       message.append("Edit group:");
940       if (editCommand == null)
941       {
942         editCommand = new EditCommand("Edit Group");
943       }
944     }
945     else
946     {
947       message.append("Edit sequence: " + seq.getName());
948       String label = seq.getName();
949       if (label.length() > 10)
950       {
951         label = label.substring(0, 10);
952       }
953       if (editCommand == null)
954       {
955         editCommand = new EditCommand("Edit " + label);
956       }
957     }
958
959     if (insertGap)
960     {
961       message.append(" insert ");
962     }
963     else
964     {
965       message.append(" delete ");
966     }
967
968     message.append(Math.abs(startres - lastres) + " gaps.");
969     ap.alignFrame.statusBar.setText(message.toString());
970
971     // Are we editing within a selection group?
972     if (groupEditing
973             || (sg != null && sg.getSequences(av.getHiddenRepSequences())
974                     .contains(seq)))
975     {
976       fixedColumns = true;
977
978       // sg might be null as the user may only see 1 sequence,
979       // but the sequence represents a group
980       if (sg == null)
981       {
982         if (!av.isHiddenRepSequence(seq))
983         {
984           endEditing();
985           return;
986         }
987
988         sg = av.getRepresentedSequences(seq);
989       }
990
991       fixedLeft = sg.getStartRes();
992       fixedRight = sg.getEndRes();
993
994       if ((startres < fixedLeft && lastres >= fixedLeft)
995               || (startres >= fixedLeft && lastres < fixedLeft)
996               || (startres > fixedRight && lastres <= fixedRight)
997               || (startres <= fixedRight && lastres > fixedRight))
998       {
999         endEditing();
1000         return;
1001       }
1002
1003       if (fixedLeft > startres)
1004       {
1005         fixedRight = fixedLeft - 1;
1006         fixedLeft = 0;
1007       }
1008       else if (fixedRight < startres)
1009       {
1010         fixedLeft = fixedRight;
1011         fixedRight = -1;
1012       }
1013     }
1014
1015     if (av.hasHiddenColumns())
1016     {
1017       fixedColumns = true;
1018       int y1 = av.getColumnSelection().getHiddenBoundaryLeft(startres);
1019       int y2 = av.getColumnSelection().getHiddenBoundaryRight(startres);
1020
1021       if ((insertGap && startres > y1 && lastres < y1)
1022               || (!insertGap && startres < y2 && lastres > y2))
1023       {
1024         endEditing();
1025         return;
1026       }
1027
1028       // System.out.print(y1+" "+y2+" "+fixedLeft+" "+fixedRight+"~~");
1029       // Selection spans a hidden region
1030       if (fixedLeft < y1 && (fixedRight > y2 || fixedRight == -1))
1031       {
1032         if (startres >= y2)
1033         {
1034           fixedLeft = y2;
1035         }
1036         else
1037         {
1038           fixedRight = y2 - 1;
1039         }
1040       }
1041     }
1042
1043     if (groupEditing)
1044     {
1045       SequenceI[] groupSeqs = sg.getSequences(av.getHiddenRepSequences())
1046               .toArray(new SequenceI[0]);
1047
1048       // drag to right
1049       if (insertGap)
1050       {
1051         // If the user has selected the whole sequence, and is dragging to
1052         // the right, we can still extend the alignment and selectionGroup
1053         if (sg.getStartRes() == 0 && sg.getEndRes() == fixedRight
1054                 && sg.getEndRes() == av.getAlignment().getWidth() - 1)
1055         {
1056           sg.setEndRes(av.getAlignment().getWidth() + startres - lastres);
1057           fixedRight = sg.getEndRes();
1058         }
1059
1060         // Is it valid with fixed columns??
1061         // Find the next gap before the end
1062         // of the visible region boundary
1063         boolean blank = false;
1064         for (fixedRight = fixedRight; fixedRight > lastres; fixedRight--)
1065         {
1066           blank = true;
1067
1068           for (SequenceI gs : groupSeqs)
1069           {
1070             for (int j = 0; j < startres - lastres; j++)
1071             {
1072               if (!jalview.util.Comparison.isGap(gs.getCharAt(fixedRight
1073                       - j)))
1074               {
1075                 blank = false;
1076                 break;
1077               }
1078             }
1079           }
1080           if (blank)
1081           {
1082             break;
1083           }
1084         }
1085
1086         if (!blank)
1087         {
1088           if (sg.getSize() == av.getAlignment().getHeight())
1089           {
1090             if ((av.hasHiddenColumns() && startres < av
1091                     .getColumnSelection().getHiddenBoundaryRight(startres)))
1092             {
1093               endEditing();
1094               return;
1095             }
1096
1097             int alWidth = av.getAlignment().getWidth();
1098             if (av.hasHiddenRows())
1099             {
1100               int hwidth = av.getAlignment().getHiddenSequences()
1101                       .getWidth();
1102               if (hwidth > alWidth)
1103               {
1104                 alWidth = hwidth;
1105               }
1106             }
1107             // We can still insert gaps if the selectionGroup
1108             // contains all the sequences
1109             sg.setEndRes(sg.getEndRes() + startres - lastres);
1110             fixedRight = alWidth + startres - lastres;
1111           }
1112           else
1113           {
1114             endEditing();
1115             return;
1116           }
1117         }
1118       }
1119
1120       // drag to left
1121       else if (!insertGap)
1122       {
1123         // / Are we able to delete?
1124         // ie are all columns blank?
1125
1126         for (SequenceI gs : groupSeqs)
1127         {
1128           for (int j = startres; j < lastres; j++)
1129           {
1130             if (gs.getLength() <= j)
1131             {
1132               continue;
1133             }
1134
1135             if (!jalview.util.Comparison.isGap(gs.getCharAt(j)))
1136             {
1137               // Not a gap, block edit not valid
1138               endEditing();
1139               return;
1140             }
1141           }
1142         }
1143       }
1144
1145       if (insertGap)
1146       {
1147         // dragging to the right
1148         if (fixedColumns && fixedRight != -1)
1149         {
1150           for (int j = lastres; j < startres; j++)
1151           {
1152             insertChar(j, groupSeqs, fixedRight);
1153           }
1154         }
1155         else
1156         {
1157           editCommand.appendEdit(EditCommand.INSERT_GAP, groupSeqs,
1158                   startres, startres - lastres, av.getAlignment(), true);
1159         }
1160       }
1161       else
1162       {
1163         // dragging to the left
1164         if (fixedColumns && fixedRight != -1)
1165         {
1166           for (int j = lastres; j > startres; j--)
1167           {
1168             deleteChar(startres, groupSeqs, fixedRight);
1169           }
1170         }
1171         else
1172         {
1173           editCommand.appendEdit(EditCommand.DELETE_GAP, groupSeqs,
1174                   startres, lastres - startres, av.getAlignment(), true);
1175         }
1176
1177       }
1178     }
1179     else
1180     // ///Editing a single sequence///////////
1181     {
1182       if (insertGap)
1183       {
1184         // dragging to the right
1185         if (fixedColumns && fixedRight != -1)
1186         {
1187           for (int j = lastres; j < startres; j++)
1188           {
1189             insertChar(j, new SequenceI[]
1190             { seq }, fixedRight);
1191           }
1192         }
1193         else
1194         {
1195           editCommand.appendEdit(EditCommand.INSERT_GAP, new SequenceI[]
1196           { seq }, lastres, startres - lastres, av.getAlignment(), true);
1197         }
1198       }
1199       else
1200       {
1201         // dragging to the left
1202         if (fixedColumns && fixedRight != -1)
1203         {
1204           for (int j = lastres; j > startres; j--)
1205           {
1206             if (!jalview.util.Comparison.isGap(seq.getCharAt(startres)))
1207             {
1208               endEditing();
1209               break;
1210             }
1211             deleteChar(startres, new SequenceI[]
1212             { seq }, fixedRight);
1213           }
1214         }
1215         else
1216         {
1217           // could be a keyboard edit trying to delete none gaps
1218           int max = 0;
1219           for (int m = startres; m < lastres; m++)
1220           {
1221             if (!jalview.util.Comparison.isGap(seq.getCharAt(m)))
1222             {
1223               break;
1224             }
1225             max++;
1226           }
1227
1228           if (max > 0)
1229           {
1230             editCommand.appendEdit(EditCommand.DELETE_GAP, new SequenceI[]
1231             { seq }, startres, max, av.getAlignment(), true);
1232           }
1233         }
1234       }
1235     }
1236
1237     lastres = startres;
1238     seqCanvas.repaint();
1239   }
1240
1241   void insertChar(int j, SequenceI[] seq, int fixedColumn)
1242   {
1243     int blankColumn = fixedColumn;
1244     for (int s = 0; s < seq.length; s++)
1245     {
1246       // Find the next gap before the end of the visible region boundary
1247       // If lastCol > j, theres a boundary after the gap insertion
1248
1249       for (blankColumn = fixedColumn; blankColumn > j; blankColumn--)
1250       {
1251         if (jalview.util.Comparison.isGap(seq[s].getCharAt(blankColumn)))
1252         {
1253           // Theres a space, so break and insert the gap
1254           break;
1255         }
1256       }
1257
1258       if (blankColumn <= j)
1259       {
1260         blankColumn = fixedColumn;
1261         endEditing();
1262         return;
1263       }
1264     }
1265
1266     editCommand.appendEdit(EditCommand.DELETE_GAP, seq, blankColumn, 1,
1267             av.getAlignment(), true);
1268
1269     editCommand.appendEdit(EditCommand.INSERT_GAP, seq, j, 1,
1270             av.getAlignment(), true);
1271
1272   }
1273
1274   void deleteChar(int j, SequenceI[] seq, int fixedColumn)
1275   {
1276
1277     editCommand.appendEdit(EditCommand.DELETE_GAP, seq, j, 1,
1278             av.getAlignment(), true);
1279
1280     editCommand.appendEdit(EditCommand.INSERT_GAP, seq, fixedColumn, 1,
1281             av.getAlignment(), true);
1282   }
1283
1284   // ////////////////////////////////////////
1285   // ///Everything below this is for defining the boundary of the rubberband
1286   // ////////////////////////////////////////
1287   public void doMousePressedDefineMode(MouseEvent evt)
1288   {
1289     if (scrollThread != null)
1290     {
1291       scrollThread.running = false;
1292       scrollThread = null;
1293     }
1294
1295     int res = findRes(evt);
1296     int seq = findSeq(evt);
1297     oldSeq = seq;
1298     startWrapBlock = wrappedBlock;
1299
1300     if (seq == -1)
1301     {
1302       return;
1303     }
1304
1305     SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(seq);
1306
1307     if (sequence == null || res > sequence.getLength())
1308     {
1309       return;
1310     }
1311
1312     stretchGroup = av.getSelectionGroup();
1313
1314     if (stretchGroup == null)
1315     {
1316       stretchGroup = av.getAlignment().findGroup(sequence);
1317       if (stretchGroup != null && res > stretchGroup.getStartRes()
1318               && res < stretchGroup.getEndRes())
1319       {
1320         av.setSelectionGroup(stretchGroup);
1321       }
1322       else
1323       {
1324         stretchGroup = null;
1325       }
1326     }
1327
1328     else if (!stretchGroup.getSequences(null).contains(sequence)
1329             || stretchGroup.getStartRes() > res
1330             || stretchGroup.getEndRes() < res)
1331     {
1332       stretchGroup = null;
1333
1334       SequenceGroup[] allGroups = av.getAlignment().findAllGroups(sequence);
1335
1336       if (allGroups != null)
1337       {
1338         for (int i = 0; i < allGroups.length; i++)
1339         {
1340           if (allGroups[i].getStartRes() <= res
1341                   && allGroups[i].getEndRes() >= res)
1342           {
1343             stretchGroup = allGroups[i];
1344             break;
1345           }
1346         }
1347       }
1348       av.setSelectionGroup(stretchGroup);
1349     }
1350
1351     // DETECT RIGHT MOUSE BUTTON IN AWT
1352     if ((evt.getModifiers() & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK)
1353     {
1354       SequenceFeature[] allFeatures = findFeaturesAtRes(sequence,
1355               sequence.findPosition(res));
1356
1357       Vector links = null;
1358       if (allFeatures != null)
1359       {
1360         for (int i = 0; i < allFeatures.length; i++)
1361         {
1362           if (allFeatures[i].links != null)
1363           {
1364             if (links == null)
1365             {
1366               links = new Vector();
1367             }
1368             for (int j = 0; j < allFeatures[i].links.size(); j++)
1369             {
1370               links.addElement(allFeatures[i].links.elementAt(j));
1371             }
1372           }
1373         }
1374       }
1375       APopupMenu popup = new APopupMenu(ap, null, links);
1376       this.add(popup);
1377       popup.show(this, evt.getX(), evt.getY());
1378       return;
1379     }
1380
1381     if (av.cursorMode)
1382     {
1383       seqCanvas.cursorX = findRes(evt);
1384       seqCanvas.cursorY = findSeq(evt);
1385       seqCanvas.repaint();
1386       return;
1387     }
1388
1389     // Only if left mouse button do we want to change group sizes
1390
1391     if (stretchGroup == null)
1392     {
1393       // define a new group here
1394       SequenceGroup sg = new SequenceGroup();
1395       sg.setStartRes(res);
1396       sg.setEndRes(res);
1397       sg.addSequence(sequence, false);
1398       av.setSelectionGroup(sg);
1399       stretchGroup = sg;
1400
1401       if (av.getConservationSelected())
1402       {
1403         SliderPanel.setConservationSlider(ap, av.getGlobalColourScheme(),
1404                 "Background");
1405       }
1406       if (av.getAbovePIDThreshold())
1407       {
1408         SliderPanel.setPIDSliderSource(ap, av.getGlobalColourScheme(),
1409                 "Background");
1410       }
1411
1412     }
1413   }
1414
1415   public void doMouseReleasedDefineMode(MouseEvent evt)
1416   {
1417     if (stretchGroup == null)
1418     {
1419       return;
1420     }
1421
1422     stretchGroup.recalcConservation(); // always do this - annotation has own
1423                                        // state
1424     if (stretchGroup.cs != null)
1425     {
1426       stretchGroup.cs.alignmentChanged(stretchGroup,
1427               av.getHiddenRepSequences());
1428
1429       if (stretchGroup.cs.conservationApplied())
1430       {
1431         SliderPanel.setConservationSlider(ap, stretchGroup.cs,
1432                 stretchGroup.getName());
1433       }
1434       else
1435       {
1436         SliderPanel.setPIDSliderSource(ap, stretchGroup.cs,
1437                 stretchGroup.getName());
1438       }
1439     }
1440     changeEndRes = false;
1441     changeStartRes = false;
1442     stretchGroup = null;
1443     PaintRefresher.Refresh(ap, av.getSequenceSetId());
1444     ap.paintAlignment(true);
1445     av.sendSelection();
1446   }
1447
1448   public void doMouseDraggedDefineMode(MouseEvent evt)
1449   {
1450     int res = findRes(evt);
1451     int y = findSeq(evt);
1452
1453     if (wrappedBlock != startWrapBlock)
1454     {
1455       return;
1456     }
1457
1458     if (stretchGroup == null)
1459     {
1460       return;
1461     }
1462
1463     mouseDragging = true;
1464
1465     if (y > av.getAlignment().getHeight())
1466     {
1467       y = av.getAlignment().getHeight() - 1;
1468     }
1469
1470     if (res >= av.getAlignment().getWidth())
1471     {
1472       res = av.getAlignment().getWidth() - 1;
1473     }
1474
1475     if (stretchGroup.getEndRes() == res)
1476     {
1477       // Edit end res position of selected group
1478       changeEndRes = true;
1479     }
1480     else if (stretchGroup.getStartRes() == res)
1481     {
1482       // Edit start res position of selected group
1483       changeStartRes = true;
1484     }
1485
1486     if (res < 0)
1487     {
1488       res = 0;
1489     }
1490
1491     if (changeEndRes)
1492     {
1493       if (res > (stretchGroup.getStartRes() - 1))
1494       {
1495         stretchGroup.setEndRes(res);
1496       }
1497     }
1498     else if (changeStartRes)
1499     {
1500       if (res < (stretchGroup.getEndRes() + 1))
1501       {
1502         stretchGroup.setStartRes(res);
1503       }
1504     }
1505
1506     int dragDirection = 0;
1507
1508     if (y > oldSeq)
1509     {
1510       dragDirection = 1;
1511     }
1512     else if (y < oldSeq)
1513     {
1514       dragDirection = -1;
1515     }
1516
1517     while ((y != oldSeq) && (oldSeq > -1)
1518             && (y < av.getAlignment().getHeight()))
1519     {
1520       // This routine ensures we don't skip any sequences, as the
1521       // selection is quite slow.
1522       Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
1523
1524       oldSeq += dragDirection;
1525
1526       if (oldSeq < 0)
1527       {
1528         break;
1529       }
1530
1531       Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
1532
1533       if (stretchGroup.getSequences(null).contains(nextSeq))
1534       {
1535         stretchGroup.deleteSequence(seq, false);
1536       }
1537       else
1538       {
1539         if (seq != null)
1540         {
1541           stretchGroup.addSequence(seq, false);
1542         }
1543
1544         stretchGroup.addSequence(nextSeq, false);
1545       }
1546     }
1547
1548     if (oldSeq < 0)
1549     {
1550       oldSeq = -1;
1551     }
1552
1553     if (res > av.endRes || res < av.startRes || y < av.startSeq
1554             || y > av.endSeq)
1555     {
1556       mouseExited(evt);
1557     }
1558
1559     if (scrollThread != null)
1560     {
1561       scrollThread.setEvent(evt);
1562     }
1563
1564     seqCanvas.repaint();
1565   }
1566
1567   public void mouseEntered(MouseEvent e)
1568   {
1569     if (oldSeq < 0)
1570     {
1571       oldSeq = 0;
1572     }
1573
1574     if (scrollThread != null)
1575     {
1576       scrollThread.running = false;
1577       scrollThread = null;
1578     }
1579   }
1580
1581   public void mouseExited(MouseEvent e)
1582   {
1583     if (av.getWrapAlignment())
1584     {
1585       return;
1586     }
1587
1588     if (mouseDragging && scrollThread == null)
1589     {
1590       scrollThread = new ScrollThread();
1591     }
1592   }
1593
1594   void scrollCanvas(MouseEvent evt)
1595   {
1596     if (evt == null)
1597     {
1598       if (scrollThread != null)
1599       {
1600         scrollThread.running = false;
1601         scrollThread = null;
1602       }
1603       mouseDragging = false;
1604     }
1605     else
1606     {
1607       if (scrollThread == null)
1608       {
1609         scrollThread = new ScrollThread();
1610       }
1611
1612       mouseDragging = true;
1613       scrollThread.setEvent(evt);
1614     }
1615
1616   }
1617
1618   // this class allows scrolling off the bottom of the visible alignment
1619   class ScrollThread extends Thread
1620   {
1621     MouseEvent evt;
1622
1623     boolean running = false;
1624
1625     public ScrollThread()
1626     {
1627       start();
1628     }
1629
1630     public void setEvent(MouseEvent e)
1631     {
1632       evt = e;
1633     }
1634
1635     public void stopScrolling()
1636     {
1637       running = false;
1638     }
1639
1640     public void run()
1641     {
1642       running = true;
1643       while (running)
1644       {
1645
1646         if (evt != null)
1647         {
1648
1649           if (mouseDragging && evt.getY() < 0 && av.getStartSeq() > 0)
1650           {
1651             running = ap.scrollUp(true);
1652           }
1653
1654           if (mouseDragging && evt.getY() >= getSize().height
1655                   && av.getAlignment().getHeight() > av.getEndSeq())
1656           {
1657             running = ap.scrollUp(false);
1658           }
1659
1660           if (mouseDragging && evt.getX() < 0)
1661           {
1662             running = ap.scrollRight(false);
1663           }
1664
1665           else if (mouseDragging && evt.getX() >= getSize().width)
1666           {
1667             running = ap.scrollRight(true);
1668           }
1669         }
1670
1671         try
1672         {
1673           Thread.sleep(75);
1674         } catch (Exception ex)
1675         {
1676         }
1677       }
1678     }
1679   }
1680
1681   /**
1682    * modify current selection according to a received message.
1683    */
1684   public void selection(SequenceGroup seqsel, ColumnSelection colsel,
1685           SelectionSource source)
1686   {
1687     // TODO: fix this hack - source of messages is align viewport, but SeqPanel
1688     // handles selection messages...
1689     // TODO: extend config options to allow user to control if selections may be
1690     // shared between viewports.
1691     if (av != null
1692             && (av == source || !av.followSelection || (source instanceof AlignViewport && ((AlignViewport) source)
1693                     .getSequenceSetId().equals(av.getSequenceSetId()))))
1694     {
1695       return;
1696     }
1697     // do we want to thread this ? (contention with seqsel and colsel locks, I
1698     // suspect)
1699     // rules are: colsel is copied if there is a real intersection between
1700     // sequence selection
1701     boolean repaint = false, copycolsel = true;
1702     if (av.getSelectionGroup() == null || !av.isSelectionGroupChanged(true))
1703     {
1704       SequenceGroup sgroup = null;
1705       if (seqsel != null && seqsel.getSize() > 0)
1706       {
1707         if (av.getAlignment() == null)
1708         {
1709           System.out
1710                   .println("Selection message: alignviewport av SeqSetId="
1711                           + av.getSequenceSetId() + " ViewId="
1712                           + av.getViewId()
1713                           + " 's alignment is NULL! returning immediatly.");
1714           return;
1715         }
1716         sgroup = seqsel.intersect(av.getAlignment(),
1717                 (av.hasHiddenRows()) ? av.getHiddenRepSequences() : null);
1718         if ((sgroup == null || sgroup.getSize() == 0)
1719                 && (colsel == null || colsel.size() == 0))
1720         {
1721           // don't copy columns if the region didn't intersect.
1722           copycolsel = false;
1723         }
1724       }
1725       if (sgroup != null && sgroup.getSize() > 0)
1726       {
1727         av.setSelectionGroup(sgroup);
1728       }
1729       else
1730       {
1731         av.setSelectionGroup(null);
1732       }
1733       repaint = av.isSelectionGroupChanged(true);
1734     }
1735     if (copycolsel
1736             && (av.getColumnSelection() == null || !av
1737                     .isColSelChanged(true)))
1738     {
1739       // the current selection is unset or from a previous message
1740       // so import the new colsel.
1741       if (colsel == null || colsel.size() == 0)
1742       {
1743         if (av.getColumnSelection() != null)
1744         {
1745           av.getColumnSelection().clear();
1746         }
1747       }
1748       else
1749       {
1750         // TODO: shift colSel according to the intersecting sequences
1751         if (av.getColumnSelection() == null)
1752         {
1753           av.setColumnSelection(new ColumnSelection(colsel));
1754         }
1755         else
1756         {
1757           av.getColumnSelection().setElementsFrom(colsel);
1758         }
1759       }
1760       repaint |= av.isColSelChanged(true);
1761     }
1762     if (copycolsel
1763             && av.hasHiddenColumns()
1764             && (av.getColumnSelection() == null || av.getColumnSelection()
1765                     .getHiddenColumns() == null))
1766     {
1767       System.err.println("Bad things");
1768     }
1769     if (repaint)
1770     {
1771       ap.scalePanelHolder.repaint();
1772       ap.repaint();
1773     }
1774   }
1775
1776   /**
1777    * scroll to the given row/column - or nearest visible location
1778    * 
1779    * @param row
1780    * @param column
1781    */
1782   public void scrollTo(int row, int column)
1783   {
1784
1785     row = row < 0 ? ap.av.startSeq : row;
1786     column = column < 0 ? ap.av.startRes : column;
1787     ap.scrollTo(column, column, row, true, true);
1788   }
1789
1790   /**
1791    * scroll to the given row - or nearest visible location
1792    * 
1793    * @param row
1794    */
1795   public void scrollToRow(int row)
1796   {
1797
1798     row = row < 0 ? ap.av.startSeq : row;
1799     ap.scrollTo(ap.av.startRes, ap.av.startRes, row, true, true);
1800   }
1801
1802   /**
1803    * scroll to the given column - or nearest visible location
1804    * 
1805    * @param column
1806    */
1807   public void scrollToColumn(int column)
1808   {
1809
1810     column = column < 0 ? ap.av.startRes : column;
1811     ap.scrollTo(column, column, ap.av.startSeq, true, true);
1812   }
1813
1814 }