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 \r
 453   public void mouseReleased(MouseEvent evt)\r
 454   {\r
 455     mouseDragging = false;\r
 456     mouseWheelPressed = false;\r
 457     ap.paintAlignment(true);\r
 458 \r
 459     if (!editingSeqs)\r
 460     {\r
 461       doMouseReleasedDefineMode(evt);\r
 462       return;\r
 463     }\r
 464 \r
 465     endEditing();\r
 466 \r
 467   }\r
 468 \r
 469   int startWrapBlock = -1;\r
 470   int wrappedBlock = -1;\r
 471   int findRes(MouseEvent evt)\r
 472   {\r
 473     int res = 0;\r
 474     int x = evt.getX();\r
 475 \r
 476     if (av.wrapAlignment)\r
 477     {\r
 478 \r
 479       int hgap = av.charHeight;\r
 480       if (av.scaleAboveWrapped)\r
 481       {\r
 482         hgap += av.charHeight;\r
 483       }\r
 484 \r
 485       int cHeight = av.getAlignment().getHeight() * av.charHeight\r
 486           + hgap + seqCanvas.getAnnotationHeight();\r
 487 \r
 488       int y = evt.getY();\r
 489       y -= hgap;\r
 490       x -= seqCanvas.LABEL_WEST;\r
 491 \r
 492       int cwidth = seqCanvas.getWrappedCanvasWidth(getSize().width);\r
 493       if (cwidth < 1)\r
 494       {\r
 495         return 0;\r
 496       }\r
 497 \r
 498       wrappedBlock = y / cHeight;\r
 499       wrappedBlock += av.getStartRes() / cwidth;\r
 500 \r
 501       res = wrappedBlock * cwidth + x / av.getCharWidth();\r
 502 \r
 503     }\r
 504     else\r
 505     {\r
 506       res = (x / av.getCharWidth()) + av.getStartRes();\r
 507     }\r
 508 \r
 509     if (av.hasHiddenColumns)\r
 510     {\r
 511       res = av.getColumnSelection().adjustForHiddenColumns(res);\r
 512     }\r
 513 \r
 514     return res;\r
 515 \r
 516   }\r
 517 \r
 518   int findSeq(MouseEvent evt)\r
 519   {\r
 520 \r
 521     int seq = 0;\r
 522     int y = evt.getY();\r
 523 \r
 524     if (av.wrapAlignment)\r
 525     {\r
 526       int hgap = av.charHeight;\r
 527       if (av.scaleAboveWrapped)\r
 528       {\r
 529         hgap += av.charHeight;\r
 530       }\r
 531 \r
 532       int cHeight = av.getAlignment().getHeight() * av.charHeight\r
 533           + hgap + seqCanvas.getAnnotationHeight();\r
 534 \r
 535       y -= hgap;\r
 536 \r
 537       seq = Math.min( (y % cHeight) / av.getCharHeight(),\r
 538                      av.alignment.getHeight() - 1);\r
 539       if (seq < 0)\r
 540       {\r
 541         seq = 0;\r
 542       }\r
 543     }\r
 544     else\r
 545     {\r
 546       seq = Math.min( (y / av.getCharHeight()) + av.getStartSeq(),\r
 547                      av.alignment.getHeight() - 1);\r
 548       if (seq < 0)\r
 549       {\r
 550         seq = 0;\r
 551       }\r
 552     }\r
 553 \r
 554     return seq;\r
 555   }\r
 556 \r
 557   public void doMousePressed(MouseEvent evt)\r
 558   {\r
 559 \r
 560     int seq = findSeq(evt);\r
 561     int res = findRes(evt);\r
 562 \r
 563     if (seq < av.getAlignment().getHeight() &&\r
 564         res < av.getAlignment().getSequenceAt(seq).getLength())\r
 565     {\r
 566       //char resstr = align.getSequenceAt(seq).getSequence().charAt(res);\r
 567       // Find the residue's position in the sequence (res is the position\r
 568       // in the alignment\r
 569 \r
 570       startseq = seq;\r
 571       lastres = res;\r
 572     }\r
 573     else\r
 574     {\r
 575       startseq = -1;\r
 576       lastres = -1;\r
 577     }\r
 578 \r
 579     return;\r
 580   }\r
 581 \r
 582 \r
 583   String lastMessage;\r
 584   public void mouseOverSequence(SequenceI sequence, int index)\r
 585   {\r
 586     String tmp = sequence.hashCode()+index+"";\r
 587     if (lastMessage == null || !lastMessage.equals(tmp))\r
 588       ssm.mouseOverSequence(sequence, index);\r
 589 \r
 590     lastMessage = tmp;\r
 591   }\r
 592 \r
 593 \r
 594   public void highlightSequence(jalview.datamodel.SequenceI seq, int index)\r
 595   {\r
 596     if(av.alignment.findIndex(seq)>-1)\r
 597     {\r
 598       SearchResults highlight = new SearchResults();\r
 599       highlight.addResult(seq,index,index);\r
 600       seqCanvas.highlightSearchResults(highlight);\r
 601     }\r
 602   }\r
 603 \r
 604   public void updateColours(SequenceI seq, int index)\r
 605   {\r
 606     System.out.println("update the seqPanel colours");\r
 607     //repaint();\r
 608   }\r
 609 \r
 610   public void mouseMoved(MouseEvent evt)\r
 611   {\r
 612     int res = findRes(evt);\r
 613     int seq = findSeq(evt);\r
 614 \r
 615     if (seq >= av.getAlignment().getHeight() || seq < 0 || res < 0)\r
 616     {\r
 617       if (tooltip != null)\r
 618       {\r
 619         tooltip.setTip("");\r
 620       }\r
 621       return;\r
 622     }\r
 623 \r
 624     SequenceI sequence = av.getAlignment().getSequenceAt(seq);\r
 625     if (res > sequence.getLength())\r
 626     {\r
 627       if (tooltip != null)\r
 628       {\r
 629         tooltip.setTip("");\r
 630       }\r
 631       return;\r
 632     }\r
 633 \r
 634 \r
 635     if (ssm != null)\r
 636       mouseOverSequence(sequence, sequence.findPosition(res));\r
 637 \r
 638 \r
 639     StringBuffer text = new StringBuffer("Sequence " + (seq + 1) + " ID: " +\r
 640                                          sequence.getName());\r
 641 \r
 642     Object obj = null;\r
 643     if (av.alignment.isNucleotide())\r
 644     {\r
 645       obj = ResidueProperties.nucleotideName.get(sequence.getCharAt(res) +\r
 646                                                  "");\r
 647       if (obj != null)\r
 648       {\r
 649         text.append(" Nucleotide: ");\r
 650       }\r
 651     }\r
 652     else\r
 653     {\r
 654       obj = ResidueProperties.aa2Triplet.get(sequence.getCharAt(res) + "");\r
 655       if (obj != null)\r
 656       {\r
 657         text.append("  Residue: ");\r
 658       }\r
 659     }\r
 660 \r
 661     if (obj != null)\r
 662     {\r
 663       if (obj != "")\r
 664       {\r
 665         text.append(obj + " (" + sequence.findPosition(res) + ")");\r
 666       }\r
 667     }\r
 668 \r
 669     ap.alignFrame.statusBar.setText(text.toString());\r
 670 \r
 671     StringBuffer tooltipText = new StringBuffer();\r
 672     SequenceGroup[] groups = av.alignment.findAllGroups(sequence);\r
 673     if (groups != null)\r
 674     {\r
 675       for (int g = 0; g < groups.length; g++)\r
 676       {\r
 677         if (groups[g].getStartRes() <= res && groups[g].getEndRes() >= res)\r
 678         {\r
 679           if (!groups[g].getName().startsWith("JTreeGroup") &&\r
 680               !groups[g].getName().startsWith("JGroup"))\r
 681           {\r
 682             tooltipText.append(groups[g].getName() + " ");\r
 683           }\r
 684           if (groups[g].getDescription() != null)\r
 685           {\r
 686             tooltipText.append(groups[g].getDescription());\r
 687           }\r
 688           tooltipText.append("\n");\r
 689         }\r
 690       }\r
 691     }\r
 692 \r
 693     // use aa to see if the mouse pointer is on a\r
 694     if (av.showSequenceFeatures\r
 695         && sequence.getSequenceFeatures() != null\r
 696         && av.featuresDisplayed != null)\r
 697     {\r
 698 \r
 699       Vector allFeatures = getAllFeaturesAtRes(sequence,\r
 700                                                sequence.findPosition(res));\r
 701 \r
 702       int index = 0;\r
 703       while (index < allFeatures.size())\r
 704       {\r
 705         SequenceFeature sf = (SequenceFeature) allFeatures.elementAt(index);\r
 706 \r
 707         tooltipText.append(sf.getType() + " " + sf.begin + ":" + sf.end);\r
 708 \r
 709         if (sf.getDescription() != null)\r
 710         {\r
 711           tooltipText.append(" " + sf.getDescription());\r
 712         }\r
 713 \r
 714         if (sf.getValue("status") != null)\r
 715         {\r
 716           String status = sf.getValue("status").toString();\r
 717           if (status.length() > 0)\r
 718           {\r
 719             tooltipText.append(" (" + sf.getValue("status") + ")");\r
 720           }\r
 721         }\r
 722         tooltipText.append("\n");\r
 723 \r
 724         index++;\r
 725       }\r
 726     }\r
 727 \r
 728     if (tooltip == null)\r
 729     {\r
 730       tooltip = new Tooltip(tooltipText.toString(), seqCanvas);\r
 731     }\r
 732     else\r
 733     {\r
 734       tooltip.setTip(tooltipText.toString());\r
 735     }\r
 736   }\r
 737 \r
 738   Vector getAllFeaturesAtRes(SequenceI seq, int res)\r
 739   {\r
 740     Vector allFeatures = new Vector();\r
 741     int index = 0;\r
 742     if (seq.getSequenceFeatures() != null)\r
 743     {\r
 744       while (index < seq.getSequenceFeatures().length)\r
 745       {\r
 746         SequenceFeature sf = seq.getSequenceFeatures()[index];\r
 747         if (sf.getBegin() <= res &&\r
 748             sf.getEnd() >= res)\r
 749         {\r
 750           if (av.featuresDisplayed.containsKey(sf.getType()))\r
 751           {\r
 752             allFeatures.addElement(sf);\r
 753           }\r
 754         }\r
 755         index++;\r
 756       }\r
 757     }\r
 758     return allFeatures;\r
 759   }\r
 760 \r
 761   Tooltip tooltip;\r
 762 \r
 763   public void mouseDragged(MouseEvent evt)\r
 764   {\r
 765     if (mouseWheelPressed)\r
 766     {\r
 767       int oldWidth = av.charWidth;\r
 768 \r
 769       //Which is bigger, left-right or up-down?\r
 770       if (Math.abs(evt.getY() - lastMousePress.y)\r
 771           > Math.abs(evt.getX() - lastMousePress.x))\r
 772       {\r
 773         int fontSize = av.font.getSize();\r
 774 \r
 775         if (evt.getY() < lastMousePress.y && av.charHeight > 1)\r
 776         {\r
 777           fontSize--;\r
 778         }\r
 779         else if (evt.getY() > lastMousePress.y)\r
 780         {\r
 781           fontSize++;\r
 782         }\r
 783 \r
 784         if (fontSize < 1)\r
 785         {\r
 786           fontSize = 1;\r
 787         }\r
 788 \r
 789         av.setFont(new Font(av.font.getName(), av.font.getStyle(), fontSize));\r
 790         av.charWidth = oldWidth;\r
 791       }\r
 792       else\r
 793       {\r
 794         if (evt.getX() < lastMousePress.x && av.charWidth > 1)\r
 795         {\r
 796           av.charWidth--;\r
 797         }\r
 798         else if (evt.getX() > lastMousePress.x)\r
 799         {\r
 800           av.charWidth++;\r
 801         }\r
 802 \r
 803         if (av.charWidth < 1)\r
 804         {\r
 805           av.charWidth = 1;\r
 806         }\r
 807       }\r
 808 \r
 809       ap.fontChanged();\r
 810 \r
 811       FontMetrics fm = getFontMetrics(av.getFont());\r
 812       av.validCharWidth = fm.charWidth('M') <= av.charWidth;\r
 813 \r
 814       lastMousePress = evt.getPoint();\r
 815 \r
 816       ap.paintAlignment(false);\r
 817       ap.annotationPanel.image = null;\r
 818       return;\r
 819     }\r
 820 \r
 821     if (!editingSeqs)\r
 822     {\r
 823       doMouseDraggedDefineMode(evt);\r
 824       return;\r
 825     }\r
 826 \r
 827     int res = findRes(evt);\r
 828 \r
 829     if (res < 0)\r
 830     {\r
 831       res = 0;\r
 832     }\r
 833 \r
 834     if ( (lastres == -1) || (lastres == res))\r
 835     {\r
 836       return;\r
 837     }\r
 838 \r
 839     if ( (res < av.getAlignment().getWidth()) && (res < lastres))\r
 840     {\r
 841       // dragLeft, delete gap\r
 842       editSequence(false, res);\r
 843     }\r
 844     else\r
 845     {\r
 846       editSequence(true, res);\r
 847     }\r
 848 \r
 849     mouseDragging = true;\r
 850     if (scrollThread != null)\r
 851     {\r
 852       scrollThread.setEvent(evt);\r
 853     }\r
 854 \r
 855   }\r
 856 \r
 857   synchronized void editSequence(boolean insertGap, int startres)\r
 858   {\r
 859     int fixedLeft = -1;\r
 860     int fixedRight = -1;\r
 861     boolean fixedColumns = false;\r
 862     SequenceGroup sg = av.getSelectionGroup();\r
 863 \r
 864     SequenceI seq = av.alignment.getSequenceAt(startseq);\r
 865 \r
 866     if (!groupEditing && av.hasHiddenRows)\r
 867     {\r
 868       if (av.hiddenRepSequences != null\r
 869           && av.hiddenRepSequences.containsKey(seq))\r
 870       {\r
 871         sg = (SequenceGroup) av.hiddenRepSequences.get(seq);\r
 872         groupEditing = true;\r
 873       }\r
 874     }\r
 875 \r
 876     StringBuffer message = new StringBuffer();\r
 877     if (groupEditing)\r
 878     {\r
 879       message.append("Edit group:");\r
 880       if (editCommand == null)\r
 881       {\r
 882         editCommand = new EditCommand("Edit Group");\r
 883       }\r
 884     }\r
 885     else\r
 886     {\r
 887       message.append("Edit sequence: " + seq.getName());\r
 888       String label = seq.getName();\r
 889       if (label.length() > 10)\r
 890       {\r
 891         label = label.substring(0, 10);\r
 892       }\r
 893       if (editCommand == null)\r
 894       {\r
 895         editCommand = new EditCommand("Edit " + label);\r
 896       }\r
 897     }\r
 898 \r
 899     if (insertGap)\r
 900     {\r
 901       message.append(" insert ");\r
 902     }\r
 903     else\r
 904     {\r
 905       message.append(" delete ");\r
 906     }\r
 907 \r
 908     message.append(Math.abs(startres - lastres) + " gaps.");\r
 909     ap.alignFrame.statusBar.setText(message.toString());\r
 910 \r
 911     //Are we editing within a selection group?\r
 912     if (groupEditing\r
 913         || (sg != null && sg.getSequences(av.hiddenRepSequences).contains(seq)))\r
 914     {\r
 915       fixedColumns = true;\r
 916 \r
 917       //sg might be null as the user may only see 1 sequence,\r
 918       //but the sequence represents a group\r
 919       if (sg == null)\r
 920       {\r
 921         if (av.hiddenRepSequences == null\r
 922             || !av.hiddenRepSequences.containsKey(seq))\r
 923         {\r
 924           endEditing();\r
 925           return;\r
 926         }\r
 927 \r
 928         sg = (SequenceGroup) av.hiddenRepSequences.get(seq);\r
 929       }\r
 930 \r
 931       fixedLeft = sg.getStartRes();\r
 932       fixedRight = sg.getEndRes();\r
 933 \r
 934       if ( (startres < fixedLeft && lastres >= fixedLeft)\r
 935           || (startres >= fixedLeft && lastres < fixedLeft)\r
 936           || (startres > fixedRight && lastres <= fixedRight)\r
 937           || (startres <= fixedRight && lastres > fixedRight))\r
 938       {\r
 939         endEditing();\r
 940         return;\r
 941       }\r
 942 \r
 943       if (fixedLeft > startres)\r
 944       {\r
 945         fixedRight = fixedLeft - 1;\r
 946         fixedLeft = 0;\r
 947       }\r
 948       else if (fixedRight < startres)\r
 949       {\r
 950         fixedLeft = fixedRight;\r
 951         fixedRight = -1;\r
 952       }\r
 953     }\r
 954 \r
 955     if (av.hasHiddenColumns)\r
 956     {\r
 957       fixedColumns = true;\r
 958       int y1 = av.getColumnSelection().getHiddenBoundaryLeft(startres);\r
 959       int y2 = av.getColumnSelection().getHiddenBoundaryRight(startres);\r
 960 \r
 961       if ( (insertGap && startres > y1 && lastres < y1)\r
 962           || (!insertGap && startres < y2 && lastres > y2))\r
 963       {\r
 964         endEditing();\r
 965         return;\r
 966       }\r
 967 \r
 968       //System.out.print(y1+" "+y2+" "+fixedLeft+" "+fixedRight+"~~");\r
 969       //Selection spans a hidden region\r
 970       if (fixedLeft < y1 && (fixedRight > y2 || fixedRight == -1))\r
 971       {\r
 972         if (startres >= y2)\r
 973         {\r
 974           fixedLeft = y2;\r
 975         }\r
 976         else\r
 977         {\r
 978           fixedRight = y2 - 1;\r
 979         }\r
 980       }\r
 981     }\r
 982 \r
 983     if (groupEditing)\r
 984     {\r
 985       Vector vseqs = sg.getSequences(av.hiddenRepSequences);\r
 986       int g, groupSize = vseqs.size();\r
 987       SequenceI[] groupSeqs = new SequenceI[groupSize];\r
 988       for (g = 0; g < groupSeqs.length; g++)\r
 989       {\r
 990         groupSeqs[g] = (SequenceI) vseqs.elementAt(g);\r
 991       }\r
 992 \r
 993       // drag to right\r
 994       if (insertGap)\r
 995       {\r
 996         //If the user has selected the whole sequence, and is dragging to\r
 997         // the right, we can still extend the alignment and selectionGroup\r
 998         if (sg.getStartRes() == 0\r
 999             && sg.getEndRes() == fixedRight\r
1000             && sg.getEndRes() == av.alignment.getWidth() - 1\r
1001             )\r
1002         {\r
1003           sg.setEndRes(av.alignment.getWidth() + startres - lastres);\r
1004           fixedRight = sg.getEndRes();\r
1005         }\r
1006 \r
1007         // Is it valid with fixed columns??\r
1008         // Find the next gap before the end\r
1009         // of the visible region boundary\r
1010         boolean blank = false;\r
1011         for (fixedRight = fixedRight;\r
1012              fixedRight > lastres;\r
1013              fixedRight--)\r
1014         {\r
1015           blank = true;\r
1016 \r
1017           for (g = 0; g < groupSize; g++)\r
1018           {\r
1019             for (int j = 0; j < startres - lastres; j++)\r
1020             {\r
1021               if (!jalview.util.Comparison.isGap(\r
1022                   groupSeqs[g].getCharAt(fixedRight - j)))\r
1023               {\r
1024                 blank = false;\r
1025                 break;\r
1026               }\r
1027             }\r
1028           }\r
1029           if (blank)\r
1030           {\r
1031             break;\r
1032           }\r
1033         }\r
1034 \r
1035         if (!blank)\r
1036         {\r
1037           if (sg.getSize() == av.alignment.getHeight())\r
1038           {\r
1039             if ( (av.hasHiddenColumns\r
1040                   &&\r
1041                   startres < av.getColumnSelection().getHiddenBoundaryRight(startres)))\r
1042             {\r
1043               endEditing();\r
1044               return;\r
1045             }\r
1046 \r
1047             int alWidth = av.alignment.getWidth();\r
1048             if (av.hasHiddenRows)\r
1049             {\r
1050               int hwidth = av.alignment.getHiddenSequences().getWidth();\r
1051               if (hwidth > alWidth)\r
1052               {\r
1053                 alWidth = hwidth;\r
1054               }\r
1055             }\r
1056             //We can still insert gaps if the selectionGroup\r
1057             //contains all the sequences\r
1058             sg.setEndRes(sg.getEndRes() + startres - lastres);\r
1059             fixedRight = alWidth + startres - lastres;\r
1060           }\r
1061           else\r
1062           {\r
1063             endEditing();\r
1064             return;\r
1065           }\r
1066         }\r
1067       }\r
1068 \r
1069       // drag to left\r
1070       else if (!insertGap)\r
1071       {\r
1072         /// Are we able to delete?\r
1073         // ie are all columns blank?\r
1074 \r
1075         for (g = 0; g < groupSize; g++)\r
1076         {\r
1077           for (int j = startres; j < lastres; j++)\r
1078           {\r
1079             if (groupSeqs[g].getLength() <= j)\r
1080             {\r
1081               continue;\r
1082             }\r
1083 \r
1084             if (!jalview.util.Comparison.isGap(\r
1085                 groupSeqs[g].getCharAt(j)))\r
1086             {\r
1087               // Not a gap, block edit not valid\r
1088               endEditing();\r
1089               return;\r
1090             }\r
1091           }\r
1092         }\r
1093       }\r
1094 \r
1095       if (insertGap)\r
1096       {\r
1097         // dragging to the right\r
1098         if (fixedColumns && fixedRight != -1)\r
1099         {\r
1100           for (int j = lastres; j < startres; j++)\r
1101           {\r
1102             insertChar(j, groupSeqs, fixedRight);\r
1103           }\r
1104         }\r
1105         else\r
1106         {\r
1107           editCommand.appendEdit(EditCommand.INSERT_GAP,\r
1108                                  groupSeqs,\r
1109                                  startres, startres - lastres,\r
1110                                  av.alignment,\r
1111                                  true);\r
1112         }\r
1113       }\r
1114       else\r
1115       {\r
1116         // dragging to the left\r
1117         if (fixedColumns && fixedRight != -1)\r
1118         {\r
1119           for (int j = lastres; j > startres; j--)\r
1120           {\r
1121             deleteChar(startres, groupSeqs, fixedRight);\r
1122           }\r
1123         }\r
1124         else\r
1125         {\r
1126           editCommand.appendEdit(EditCommand.DELETE_GAP,\r
1127                                  groupSeqs,\r
1128                                  startres, lastres - startres,\r
1129                                  av.alignment,\r
1130                                  true);\r
1131         }\r
1132 \r
1133       }\r
1134     }\r
1135     else /////Editing a single sequence///////////\r
1136     {\r
1137       if (insertGap)\r
1138       {\r
1139         // dragging to the right\r
1140         if (fixedColumns && fixedRight != -1)\r
1141         {\r
1142           for (int j = lastres; j < startres; j++)\r
1143           {\r
1144             insertChar(j, new SequenceI[]\r
1145                        {seq}, fixedRight);\r
1146           }\r
1147         }\r
1148         else\r
1149         {\r
1150           editCommand.appendEdit(EditCommand.INSERT_GAP,\r
1151                                  new SequenceI[]\r
1152                                  {seq},\r
1153                                  lastres, startres - lastres,\r
1154                                  av.alignment,\r
1155                                  true);\r
1156         }\r
1157       }\r
1158       else\r
1159       {\r
1160         // dragging to the left\r
1161         if (fixedColumns && fixedRight != -1)\r
1162         {\r
1163           for (int j = lastres; j > startres; j--)\r
1164           {\r
1165             if (!jalview.util.Comparison.isGap(seq.getCharAt(startres)))\r
1166             {\r
1167               endEditing();\r
1168               break;\r
1169             }\r
1170             deleteChar(startres, new SequenceI[]\r
1171                        {seq}, fixedRight);\r
1172           }\r
1173         }\r
1174         else\r
1175         {\r
1176           //could be a keyboard edit trying to delete none gaps\r
1177           int max = 0;\r
1178           for (int m = startres; m < lastres; m++)\r
1179           {\r
1180             if (!jalview.util.Comparison.isGap(seq.getCharAt(m)))\r
1181             {\r
1182               break;\r
1183             }\r
1184             max++;\r
1185           }\r
1186 \r
1187           if (max > 0)\r
1188           {\r
1189             editCommand.appendEdit(EditCommand.DELETE_GAP,\r
1190                                    new SequenceI[]\r
1191                                    {seq},\r
1192                                    startres, max,\r
1193                                    av.alignment,\r
1194                                    true);\r
1195           }\r
1196         }\r
1197       }\r
1198     }\r
1199 \r
1200     lastres = startres;\r
1201     seqCanvas.repaint();\r
1202   }\r
1203 \r
1204   void insertChar(int j, SequenceI[] seq, int fixedColumn)\r
1205   {\r
1206     int blankColumn = fixedColumn;\r
1207     for (int s = 0; s < seq.length; s++)\r
1208     {\r
1209       //Find the next gap before the end of the visible region boundary\r
1210       //If lastCol > j, theres a boundary after the gap insertion\r
1211 \r
1212       for (blankColumn = fixedColumn; blankColumn > j; blankColumn--)\r
1213       {\r
1214         if (jalview.util.Comparison.isGap(seq[s].getCharAt(blankColumn)))\r
1215         {\r
1216           //Theres a space, so break and insert the gap\r
1217           break;\r
1218         }\r
1219       }\r
1220 \r
1221       if (blankColumn <= j)\r
1222       {\r
1223         blankColumn = fixedColumn;\r
1224         endEditing();\r
1225         return;\r
1226       }\r
1227     }\r
1228 \r
1229     editCommand.appendEdit(EditCommand.DELETE_GAP,\r
1230                            seq,\r
1231                            blankColumn, 1, av.alignment, true);\r
1232 \r
1233     editCommand.appendEdit(EditCommand.INSERT_GAP,\r
1234                            seq,\r
1235                            j, 1, av.alignment,\r
1236                            true);\r
1237 \r
1238   }\r
1239 \r
1240   void deleteChar(int j, SequenceI[] seq, int fixedColumn)\r
1241   {\r
1242 \r
1243     editCommand.appendEdit(EditCommand.DELETE_GAP,\r
1244                            seq,\r
1245                            j, 1, av.alignment, true);\r
1246 \r
1247     editCommand.appendEdit(EditCommand.INSERT_GAP,\r
1248                            seq,\r
1249                            fixedColumn, 1, av.alignment, true);\r
1250   }\r
1251 \r
1252 //////////////////////////////////////////\r
1253 /////Everything below this is for defining the boundary of the rubberband\r
1254 //////////////////////////////////////////\r
1255   public void doMousePressedDefineMode(MouseEvent evt)\r
1256   {\r
1257     if (scrollThread != null)\r
1258     {\r
1259       scrollThread.running = false;\r
1260       scrollThread = null;\r
1261     }\r
1262 \r
1263     int res = findRes(evt);\r
1264     int seq = findSeq(evt);\r
1265     oldSeq = seq;\r
1266     startWrapBlock = wrappedBlock;\r
1267 \r
1268     if (seq == -1)\r
1269     {\r
1270       return;\r
1271     }\r
1272 \r
1273     SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(seq);\r
1274 \r
1275     if (sequence == null || res > sequence.getLength())\r
1276     {\r
1277       return;\r
1278     }\r
1279 \r
1280     stretchGroup = av.getSelectionGroup();\r
1281 \r
1282     if (stretchGroup == null)\r
1283     {\r
1284       stretchGroup = av.alignment.findGroup(sequence);\r
1285       if (stretchGroup != null && res > stretchGroup.getStartRes() &&\r
1286           res < stretchGroup.getEndRes())\r
1287       {\r
1288         av.setSelectionGroup(stretchGroup);\r
1289       }\r
1290       else\r
1291       {\r
1292         stretchGroup = null;\r
1293       }\r
1294     }\r
1295 \r
1296     else if (!stretchGroup.getSequences(null).contains(sequence)\r
1297              || stretchGroup.getStartRes() > res\r
1298              || stretchGroup.getEndRes() < res)\r
1299     {\r
1300       stretchGroup = null;\r
1301 \r
1302       SequenceGroup[] allGroups = av.alignment.findAllGroups(sequence);\r
1303 \r
1304       if (allGroups != null)\r
1305       {\r
1306         for (int i = 0; i < allGroups.length; i++)\r
1307         {\r
1308           if (allGroups[i].getStartRes() <= res &&\r
1309               allGroups[i].getEndRes() >= res)\r
1310           {\r
1311             stretchGroup = allGroups[i];\r
1312             break;\r
1313           }\r
1314         }\r
1315       }\r
1316       av.setSelectionGroup(stretchGroup);\r
1317     }\r
1318 \r
1319     // DETECT RIGHT MOUSE BUTTON IN AWT\r
1320     if ( (evt.getModifiers() & InputEvent.BUTTON3_MASK) ==\r
1321         InputEvent.BUTTON3_MASK)\r
1322     {\r
1323       Vector allFeatures = getAllFeaturesAtRes(sequence,\r
1324                                                sequence.findPosition(res));\r
1325 \r
1326       Vector links = null;\r
1327       if (allFeatures != null)\r
1328       {\r
1329         for (int i = 0; i < allFeatures.size(); i++)\r
1330         {\r
1331           SequenceFeature sf = (SequenceFeature) allFeatures.elementAt(i);\r
1332           if (sf.links != null)\r
1333           {\r
1334             links = new Vector();\r
1335             for (int j = 0; j < sf.links.size(); j++)\r
1336             {\r
1337               links.addElement(sf.links.elementAt(j));\r
1338             }\r
1339           }\r
1340         }\r
1341       }\r
1342       APopupMenu popup = new APopupMenu(ap, null, links);\r
1343       this.add(popup);\r
1344       popup.show(this, evt.getX(), evt.getY());\r
1345       return;\r
1346     }\r
1347 \r
1348     if (av.cursorMode)\r
1349     {\r
1350       seqCanvas.cursorX = findRes(evt);\r
1351       seqCanvas.cursorY = findSeq(evt);\r
1352       seqCanvas.repaint();\r
1353       return;\r
1354     }\r
1355 \r
1356     //Only if left mouse button do we want to change group sizes\r
1357 \r
1358     if (stretchGroup == null)\r
1359     {\r
1360       // define a new group here\r
1361       SequenceGroup sg = new SequenceGroup();\r
1362       sg.setStartRes(res);\r
1363       sg.setEndRes(res);\r
1364       sg.addSequence(sequence, false);\r
1365       av.setSelectionGroup(sg);\r
1366       stretchGroup = sg;\r
1367 \r
1368       if (av.getConservationSelected())\r
1369       {\r
1370         SliderPanel.setConservationSlider(ap, av.getGlobalColourScheme(),\r
1371                                           "Background");\r
1372       }\r
1373       if (av.getAbovePIDThreshold())\r
1374       {\r
1375         SliderPanel.setPIDSliderSource(ap, av.getGlobalColourScheme(),\r
1376                                        "Background");\r
1377       }\r
1378 \r
1379     }\r
1380   }\r
1381 \r
1382   public void doMouseReleasedDefineMode(MouseEvent evt)\r
1383   {\r
1384     if (stretchGroup == null)\r
1385     {\r
1386       return;\r
1387     }\r
1388 \r
1389     if (stretchGroup.cs != null)\r
1390     {\r
1391       if (stretchGroup.cs instanceof ClustalxColourScheme)\r
1392       {\r
1393         ( (ClustalxColourScheme) stretchGroup.cs).resetClustalX(\r
1394             stretchGroup.getSequences(av.hiddenRepSequences),\r
1395             stretchGroup.getWidth());\r
1396       }\r
1397 \r
1398       if (stretchGroup.cs instanceof Blosum62ColourScheme\r
1399           || stretchGroup.cs instanceof PIDColourScheme\r
1400           || stretchGroup.cs.conservationApplied()\r
1401           || stretchGroup.cs.getThreshold() > 0)\r
1402       {\r
1403         stretchGroup.recalcConservation();\r
1404       }\r
1405 \r
1406       if (stretchGroup.cs.conservationApplied())\r
1407       {\r
1408         SliderPanel.setConservationSlider(ap, stretchGroup.cs,\r
1409                                           stretchGroup.getName());\r
1410         stretchGroup.recalcConservation();\r
1411       }\r
1412       else\r
1413       {\r
1414         SliderPanel.setPIDSliderSource(ap, stretchGroup.cs,\r
1415                                        stretchGroup.getName());\r
1416       }\r
1417     }\r
1418     changeEndRes = false;\r
1419     changeStartRes = false;\r
1420     stretchGroup = null;\r
1421     PaintRefresher.Refresh(ap, av.getSequenceSetId());\r
1422     ap.paintAlignment(true);\r
1423   }\r
1424 \r
1425   public void doMouseDraggedDefineMode(MouseEvent evt)\r
1426   {\r
1427     int res = findRes(evt);\r
1428     int y = findSeq(evt);\r
1429 \r
1430     if (wrappedBlock != startWrapBlock)\r
1431     {\r
1432       return;\r
1433     }\r
1434 \r
1435     if (stretchGroup == null)\r
1436     {\r
1437       return;\r
1438     }\r
1439 \r
1440     mouseDragging = true;\r
1441 \r
1442     if (y > av.alignment.getHeight())\r
1443     {\r
1444       y = av.alignment.getHeight() - 1;\r
1445     }\r
1446 \r
1447     if (res >= av.alignment.getWidth())\r
1448     {\r
1449       res = av.alignment.getWidth() - 1;\r
1450     }\r
1451 \r
1452     if (stretchGroup.getEndRes() == res)\r
1453     {\r
1454       // Edit end res position of selected group\r
1455       changeEndRes = true;\r
1456     }\r
1457     else if (stretchGroup.getStartRes() == res)\r
1458     {\r
1459       // Edit start res position of selected group\r
1460       changeStartRes = true;\r
1461     }\r
1462 \r
1463     if (res < 0)\r
1464     {\r
1465       res = 0;\r
1466     }\r
1467 \r
1468     if (changeEndRes)\r
1469     {\r
1470       if (res > (stretchGroup.getStartRes() - 1))\r
1471       {\r
1472         stretchGroup.setEndRes(res);\r
1473       }\r
1474     }\r
1475     else if (changeStartRes)\r
1476     {\r
1477       if (res < (stretchGroup.getEndRes() + 1))\r
1478       {\r
1479         stretchGroup.setStartRes(res);\r
1480       }\r
1481     }\r
1482 \r
1483     int dragDirection = 0;\r
1484 \r
1485     if (y > oldSeq)\r
1486     {\r
1487       dragDirection = 1;\r
1488     }\r
1489     else if (y < oldSeq)\r
1490     {\r
1491       dragDirection = -1;\r
1492     }\r
1493 \r
1494     while ( (y != oldSeq) && (oldSeq > -1) && (y < av.alignment.getHeight()))\r
1495     {\r
1496       // This routine ensures we don't skip any sequences, as the\r
1497       // selection is quite slow.\r
1498       Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);\r
1499 \r
1500       oldSeq += dragDirection;\r
1501 \r
1502       if (oldSeq < 0)\r
1503       {\r
1504         break;\r
1505       }\r
1506 \r
1507       Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);\r
1508 \r
1509       if (stretchGroup.getSequences(null).contains(nextSeq))\r
1510       {\r
1511         stretchGroup.deleteSequence(seq, false);\r
1512       }\r
1513       else\r
1514       {\r
1515         if (seq != null)\r
1516         {\r
1517           stretchGroup.addSequence(seq, false);\r
1518         }\r
1519 \r
1520         stretchGroup.addSequence(nextSeq, false);\r
1521       }\r
1522     }\r
1523 \r
1524     if (oldSeq < 0)\r
1525     {\r
1526       oldSeq = -1;\r
1527     }\r
1528 \r
1529     if (res > av.endRes || res < av.startRes\r
1530         || y < av.startSeq || y > av.endSeq)\r
1531     {\r
1532       mouseExited(evt);\r
1533     }\r
1534 \r
1535     if (scrollThread != null)\r
1536     {\r
1537       scrollThread.setEvent(evt);\r
1538     }\r
1539 \r
1540     seqCanvas.repaint();\r
1541   }\r
1542 \r
1543   public void mouseEntered(MouseEvent e)\r
1544   {\r
1545     if (oldSeq < 0)\r
1546     {\r
1547       oldSeq = 0;\r
1548     }\r
1549 \r
1550     if (scrollThread != null)\r
1551     {\r
1552       scrollThread.running = false;\r
1553       scrollThread = null;\r
1554     }\r
1555   }\r
1556 \r
1557   public void mouseExited(MouseEvent e)\r
1558   {\r
1559     if (av.getWrapAlignment())\r
1560     {\r
1561       return;\r
1562     }\r
1563 \r
1564     if (mouseDragging && scrollThread == null)\r
1565     {\r
1566       scrollThread = new ScrollThread();\r
1567     }\r
1568   }\r
1569 \r
1570   void scrollCanvas(MouseEvent evt)\r
1571   {\r
1572     if (evt == null)\r
1573     {\r
1574       if (scrollThread != null)\r
1575       {\r
1576         scrollThread.running = false;\r
1577         scrollThread = null;\r
1578       }\r
1579       mouseDragging = false;\r
1580     }\r
1581     else\r
1582     {\r
1583       if (scrollThread == null)\r
1584       {\r
1585         scrollThread = new ScrollThread();\r
1586       }\r
1587 \r
1588       mouseDragging = true;\r
1589       scrollThread.setEvent(evt);\r
1590     }\r
1591 \r
1592   }\r
1593 \r
1594   // this class allows scrolling off the bottom of the visible alignment\r
1595   class ScrollThread\r
1596       extends Thread\r
1597   {\r
1598     MouseEvent evt;\r
1599     boolean running = false;\r
1600     public ScrollThread()\r
1601     {\r
1602       start();\r
1603     }\r
1604 \r
1605     public void setEvent(MouseEvent e)\r
1606     {\r
1607       evt = e;\r
1608     }\r
1609 \r
1610     public void stopScrolling()\r
1611     {\r
1612       running = false;\r
1613     }\r
1614 \r
1615     public void run()\r
1616     {\r
1617       running = true;\r
1618       while (running)\r
1619       {\r
1620 \r
1621         if (evt != null)\r
1622         {\r
1623 \r
1624           if (mouseDragging && evt.getY() < 0 && av.getStartSeq() > 0)\r
1625           {\r
1626             running = ap.scrollUp(true);\r
1627           }\r
1628 \r
1629           if (mouseDragging && evt.getY() >= getSize().height &&\r
1630               av.alignment.getHeight() > av.getEndSeq())\r
1631           {\r
1632             running = ap.scrollUp(false);\r
1633           }\r
1634 \r
1635           if (mouseDragging && evt.getX() < 0)\r
1636           {\r
1637             running = ap.scrollRight(false);\r
1638           }\r
1639 \r
1640           else if (mouseDragging && evt.getX() >= getSize().width)\r
1641           {\r
1642             running = ap.scrollRight(true);\r
1643           }\r
1644         }\r
1645 \r
1646         try\r
1647         {\r
1648           Thread.sleep(75);\r
1649         }\r
1650         catch (Exception ex)\r
1651         {}\r
1652       }\r
1653     }\r
1654   }\r
1655 \r
1656 }\r