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