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