src/jalview/appletgui/SeqPanel.java

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