src/jalview/appletgui/SeqPanel.java

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