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