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