src/jalview/appletgui/SeqPanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.6)
   3  * Copyright (C) 2010 J Procter, AM Waterhouse, 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();
  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().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     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,
 739             sequence.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.setFont(new Font(av.font.getName(), av.font.getStyle(), fontSize));
 841         av.charWidth = oldWidth;
 842       }
 843       else
 844       {
 845         if (evt.getX() < lastMousePress.x && av.charWidth > 1)
 846         {
 847           av.charWidth--;
 848         }
 849         else if (evt.getX() > lastMousePress.x)
 850         {
 851           av.charWidth++;
 852         }
 853
 854         if (av.charWidth < 1)
 855         {
 856           av.charWidth = 1;
 857         }
 858       }
 859
 860       ap.fontChanged();
 861
 862       FontMetrics fm = getFontMetrics(av.getFont());
 863       av.validCharWidth = fm.charWidth('M') <= av.charWidth;
 864
 865       lastMousePress = evt.getPoint();
 866
 867       ap.paintAlignment(false);
 868       ap.annotationPanel.image = null;
 869       return;
 870     }
 871
 872     if (!editingSeqs)
 873     {
 874       doMouseDraggedDefineMode(evt);
 875       return;
 876     }
 877
 878     int res = findRes(evt);
 879
 880     if (res < 0)
 881     {
 882       res = 0;
 883     }
 884
 885     if ((lastres == -1) || (lastres == res))
 886     {
 887       return;
 888     }
 889
 890     if ((res < av.getAlignment().getWidth()) && (res < lastres))
 891     {
 892       // dragLeft, delete gap
 893       editSequence(false, res);
 894     }
 895     else
 896     {
 897       editSequence(true, res);
 898     }
 899
 900     mouseDragging = true;
 901     if (scrollThread != null)
 902     {
 903       scrollThread.setEvent(evt);
 904     }
 905
 906   }
 907
 908   synchronized void editSequence(boolean insertGap, int startres)
 909   {
 910     int fixedLeft = -1;
 911     int fixedRight = -1;
 912     boolean fixedColumns = false;
 913     SequenceGroup sg = av.getSelectionGroup();
 914
 915     SequenceI seq = av.alignment.getSequenceAt(startseq);
 916
 917     if (!groupEditing && av.hasHiddenRows)
 918     {
 919       if (av.hiddenRepSequences != null
 920               && av.hiddenRepSequences.containsKey(seq))
 921       {
 922         sg = (SequenceGroup) av.hiddenRepSequences.get(seq);
 923         groupEditing = true;
 924       }
 925     }
 926
 927     StringBuffer message = new StringBuffer();
 928     if (groupEditing)
 929     {
 930       message.append("Edit group:");
 931       if (editCommand == null)
 932       {
 933         editCommand = new EditCommand("Edit Group");
 934       }
 935     }
 936     else
 937     {
 938       message.append("Edit sequence: " + seq.getName());
 939       String label = seq.getName();
 940       if (label.length() > 10)
 941       {
 942         label = label.substring(0, 10);
 943       }
 944       if (editCommand == null)
 945       {
 946         editCommand = new EditCommand("Edit " + label);
 947       }
 948     }
 949
 950     if (insertGap)
 951     {
 952       message.append(" insert ");
 953     }
 954     else
 955     {
 956       message.append(" delete ");
 957     }
 958
 959     message.append(Math.abs(startres - lastres) + " gaps.");
 960     ap.alignFrame.statusBar.setText(message.toString());
 961
 962     // Are we editing within a selection group?
 963     if (groupEditing
 964             || (sg != null && sg.getSequences(av.hiddenRepSequences)
 965                     .contains(seq)))
 966     {
 967       fixedColumns = true;
 968
 969       // sg might be null as the user may only see 1 sequence,
 970       // but the sequence represents a group
 971       if (sg == null)
 972       {
 973         if (av.hiddenRepSequences == null
 974                 || !av.hiddenRepSequences.containsKey(seq))
 975         {
 976           endEditing();
 977           return;
 978         }
 979
 980         sg = (SequenceGroup) av.hiddenRepSequences.get(seq);
 981       }
 982
 983       fixedLeft = sg.getStartRes();
 984       fixedRight = sg.getEndRes();
 985
 986       if ((startres < fixedLeft && lastres >= fixedLeft)
 987               || (startres >= fixedLeft && lastres < fixedLeft)
 988               || (startres > fixedRight && lastres <= fixedRight)
 989               || (startres <= fixedRight && lastres > fixedRight))
 990       {
 991         endEditing();
 992         return;
 993       }
 994
 995       if (fixedLeft > startres)
 996       {
 997         fixedRight = fixedLeft - 1;
 998         fixedLeft = 0;
 999       }
1000       else if (fixedRight < startres)
1001       {
1002         fixedLeft = fixedRight;
1003         fixedRight = -1;
1004       }
1005     }
1006
1007     if (av.hasHiddenColumns)
1008     {
1009       fixedColumns = true;
1010       int y1 = av.getColumnSelection().getHiddenBoundaryLeft(startres);
1011       int y2 = av.getColumnSelection().getHiddenBoundaryRight(startres);
1012
1013       if ((insertGap && startres > y1 && lastres < y1)
1014               || (!insertGap && startres < y2 && lastres > y2))
1015       {
1016         endEditing();
1017         return;
1018       }
1019
1020       // System.out.print(y1+" "+y2+" "+fixedLeft+" "+fixedRight+"~~");
1021       // Selection spans a hidden region
1022       if (fixedLeft < y1 && (fixedRight > y2 || fixedRight == -1))
1023       {
1024         if (startres >= y2)
1025         {
1026           fixedLeft = y2;
1027         }
1028         else
1029         {
1030           fixedRight = y2 - 1;
1031         }
1032       }
1033     }
1034
1035     if (groupEditing)
1036     {
1037       Vector vseqs = sg.getSequences(av.hiddenRepSequences);
1038       int g, groupSize = vseqs.size();
1039       SequenceI[] groupSeqs = new SequenceI[groupSize];
1040       for (g = 0; g < groupSeqs.length; g++)
1041       {
1042         groupSeqs[g] = (SequenceI) vseqs.elementAt(g);
1043       }
1044
1045       // drag to right
1046       if (insertGap)
1047       {
1048         // If the user has selected the whole sequence, and is dragging to
1049         // the right, we can still extend the alignment and selectionGroup
1050         if (sg.getStartRes() == 0 && sg.getEndRes() == fixedRight
1051                 && sg.getEndRes() == av.alignment.getWidth() - 1)
1052         {
1053           sg.setEndRes(av.alignment.getWidth() + startres - lastres);
1054           fixedRight = sg.getEndRes();
1055         }
1056
1057         // Is it valid with fixed columns??
1058         // Find the next gap before the end
1059         // of the visible region boundary
1060         boolean blank = false;
1061         for (fixedRight = fixedRight; fixedRight > lastres; fixedRight--)
1062         {
1063           blank = true;
1064
1065           for (g = 0; g < groupSize; g++)
1066           {
1067             for (int j = 0; j < startres - lastres; j++)
1068             {
1069               if (!jalview.util.Comparison.isGap(groupSeqs[g]
1070                       .getCharAt(fixedRight - j)))
1071               {
1072                 blank = false;
1073                 break;
1074               }
1075             }
1076           }
1077           if (blank)
1078           {
1079             break;
1080           }
1081         }
1082
1083         if (!blank)
1084         {
1085           if (sg.getSize() == av.alignment.getHeight())
1086           {
1087             if ((av.hasHiddenColumns && startres < av.getColumnSelection()
1088                     .getHiddenBoundaryRight(startres)))
1089             {
1090               endEditing();
1091               return;
1092             }
1093
1094             int alWidth = av.alignment.getWidth();
1095             if (av.hasHiddenRows)
1096             {
1097               int hwidth = av.alignment.getHiddenSequences().getWidth();
1098               if (hwidth > alWidth)
1099               {
1100                 alWidth = hwidth;
1101               }
1102             }
1103             // We can still insert gaps if the selectionGroup
1104             // contains all the sequences
1105             sg.setEndRes(sg.getEndRes() + startres - lastres);
1106             fixedRight = alWidth + startres - lastres;
1107           }
1108           else
1109           {
1110             endEditing();
1111             return;
1112           }
1113         }
1114       }
1115
1116       // drag to left
1117       else if (!insertGap)
1118       {
1119         // / Are we able to delete?
1120         // ie are all columns blank?
1121
1122         for (g = 0; g < groupSize; g++)
1123         {
1124           for (int j = startres; j < lastres; j++)
1125           {
1126             if (groupSeqs[g].getLength() <= j)
1127             {
1128               continue;
1129             }
1130
1131             if (!jalview.util.Comparison.isGap(groupSeqs[g].getCharAt(j)))
1132             {
1133               // Not a gap, block edit not valid
1134               endEditing();
1135               return;
1136             }
1137           }
1138         }
1139       }
1140
1141       if (insertGap)
1142       {
1143         // dragging to the right
1144         if (fixedColumns && fixedRight != -1)
1145         {
1146           for (int j = lastres; j < startres; j++)
1147           {
1148             insertChar(j, groupSeqs, fixedRight);
1149           }
1150         }
1151         else
1152         {
1153           editCommand.appendEdit(EditCommand.INSERT_GAP, groupSeqs,
1154                   startres, startres - lastres, av.alignment, true);
1155         }
1156       }
1157       else
1158       {
1159         // dragging to the left
1160         if (fixedColumns && fixedRight != -1)
1161         {
1162           for (int j = lastres; j > startres; j--)
1163           {
1164             deleteChar(startres, groupSeqs, fixedRight);
1165           }
1166         }
1167         else
1168         {
1169           editCommand.appendEdit(EditCommand.DELETE_GAP, groupSeqs,
1170                   startres, lastres - startres, av.alignment, true);
1171         }
1172
1173       }
1174     }
1175     else
1176     // ///Editing a single sequence///////////
1177     {
1178       if (insertGap)
1179       {
1180         // dragging to the right
1181         if (fixedColumns && fixedRight != -1)
1182         {
1183           for (int j = lastres; j < startres; j++)
1184           {
1185             insertChar(j, new SequenceI[]
1186             { seq }, fixedRight);
1187           }
1188         }
1189         else
1190         {
1191           editCommand.appendEdit(EditCommand.INSERT_GAP, new SequenceI[]
1192           { seq }, lastres, startres - lastres, av.alignment, true);
1193         }
1194       }
1195       else
1196       {
1197         // dragging to the left
1198         if (fixedColumns && fixedRight != -1)
1199         {
1200           for (int j = lastres; j > startres; j--)
1201           {
1202             if (!jalview.util.Comparison.isGap(seq.getCharAt(startres)))
1203             {
1204               endEditing();
1205               break;
1206             }
1207             deleteChar(startres, new SequenceI[]
1208             { seq }, fixedRight);
1209           }
1210         }
1211         else
1212         {
1213           // could be a keyboard edit trying to delete none gaps
1214           int max = 0;
1215           for (int m = startres; m < lastres; m++)
1216           {
1217             if (!jalview.util.Comparison.isGap(seq.getCharAt(m)))
1218             {
1219               break;
1220             }
1221             max++;
1222           }
1223
1224           if (max > 0)
1225           {
1226             editCommand.appendEdit(EditCommand.DELETE_GAP, new SequenceI[]
1227             { seq }, startres, max, av.alignment, true);
1228           }
1229         }
1230       }
1231     }
1232
1233     lastres = startres;
1234     seqCanvas.repaint();
1235   }
1236
1237   void insertChar(int j, SequenceI[] seq, int fixedColumn)
1238   {
1239     int blankColumn = fixedColumn;
1240     for (int s = 0; s < seq.length; s++)
1241     {
1242       // Find the next gap before the end of the visible region boundary
1243       // If lastCol > j, theres a boundary after the gap insertion
1244
1245       for (blankColumn = fixedColumn; blankColumn > j; blankColumn--)
1246       {
1247         if (jalview.util.Comparison.isGap(seq[s].getCharAt(blankColumn)))
1248         {
1249           // Theres a space, so break and insert the gap
1250           break;
1251         }
1252       }
1253
1254       if (blankColumn <= j)
1255       {
1256         blankColumn = fixedColumn;
1257         endEditing();
1258         return;
1259       }
1260     }
1261
1262     editCommand.appendEdit(EditCommand.DELETE_GAP, seq, blankColumn, 1,
1263             av.alignment, true);
1264
1265     editCommand.appendEdit(EditCommand.INSERT_GAP, seq, j, 1, av.alignment,
1266             true);
1267
1268   }
1269
1270   void deleteChar(int j, SequenceI[] seq, int fixedColumn)
1271   {
1272
1273     editCommand.appendEdit(EditCommand.DELETE_GAP, seq, j, 1, av.alignment,
1274             true);
1275
1276     editCommand.appendEdit(EditCommand.INSERT_GAP, seq, fixedColumn, 1,
1277             av.alignment, true);
1278   }
1279
1280   // ////////////////////////////////////////
1281   // ///Everything below this is for defining the boundary of the rubberband
1282   // ////////////////////////////////////////
1283   public void doMousePressedDefineMode(MouseEvent evt)
1284   {
1285     if (scrollThread != null)
1286     {
1287       scrollThread.running = false;
1288       scrollThread = null;
1289     }
1290
1291     int res = findRes(evt);
1292     int seq = findSeq(evt);
1293     oldSeq = seq;
1294     startWrapBlock = wrappedBlock;
1295
1296     if (seq == -1)
1297     {
1298       return;
1299     }
1300
1301     SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(seq);
1302
1303     if (sequence == null || res > sequence.getLength())
1304     {
1305       return;
1306     }
1307
1308     stretchGroup = av.getSelectionGroup();
1309
1310     if (stretchGroup == null)
1311     {
1312       stretchGroup = av.alignment.findGroup(sequence);
1313       if (stretchGroup != null && res > stretchGroup.getStartRes()
1314               && res < stretchGroup.getEndRes())
1315       {
1316         av.setSelectionGroup(stretchGroup);
1317       }
1318       else
1319       {
1320         stretchGroup = null;
1321       }
1322     }
1323
1324     else if (!stretchGroup.getSequences(null).contains(sequence)
1325             || stretchGroup.getStartRes() > res
1326             || stretchGroup.getEndRes() < res)
1327     {
1328       stretchGroup = null;
1329
1330       SequenceGroup[] allGroups = av.alignment.findAllGroups(sequence);
1331
1332       if (allGroups != null)
1333       {
1334         for (int i = 0; i < allGroups.length; i++)
1335         {
1336           if (allGroups[i].getStartRes() <= res
1337                   && allGroups[i].getEndRes() >= res)
1338           {
1339             stretchGroup = allGroups[i];
1340             break;
1341           }
1342         }
1343       }
1344       av.setSelectionGroup(stretchGroup);
1345     }
1346
1347     // DETECT RIGHT MOUSE BUTTON IN AWT
1348     if ((evt.getModifiers() & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK)
1349     {
1350       SequenceFeature[] allFeatures = findFeaturesAtRes(sequence,
1351               sequence.findPosition(res));
1352
1353       Vector links = null;
1354       if (allFeatures != null)
1355       {
1356         for (int i = 0; i < allFeatures.length; i++)
1357         {
1358           if (allFeatures[i].links != null)
1359           {
1360             if (links == null)
1361             {
1362               links = new Vector();
1363             }
1364             for (int j = 0; j < allFeatures[i].links.size(); j++)
1365             {
1366               links.addElement(allFeatures[i].links.elementAt(j));
1367             }
1368           }
1369         }
1370       }
1371       APopupMenu popup = new APopupMenu(ap, null, links);
1372       this.add(popup);
1373       popup.show(this, evt.getX(), evt.getY());
1374       return;
1375     }
1376
1377     if (av.cursorMode)
1378     {
1379       seqCanvas.cursorX = findRes(evt);
1380       seqCanvas.cursorY = findSeq(evt);
1381       seqCanvas.repaint();
1382       return;
1383     }
1384
1385     // Only if left mouse button do we want to change group sizes
1386
1387     if (stretchGroup == null)
1388     {
1389       // define a new group here
1390       SequenceGroup sg = new SequenceGroup();
1391       sg.setStartRes(res);
1392       sg.setEndRes(res);
1393       sg.addSequence(sequence, false);
1394       av.setSelectionGroup(sg);
1395       stretchGroup = sg;
1396
1397       if (av.getConservationSelected())
1398       {
1399         SliderPanel.setConservationSlider(ap, av.getGlobalColourScheme(),
1400                 "Background");
1401       }
1402       if (av.getAbovePIDThreshold())
1403       {
1404         SliderPanel.setPIDSliderSource(ap, av.getGlobalColourScheme(),
1405                 "Background");
1406       }
1407
1408     }
1409   }
1410
1411   public void doMouseReleasedDefineMode(MouseEvent evt)
1412   {
1413     if (stretchGroup == null)
1414     {
1415       return;
1416     }
1417
1418     if (stretchGroup.cs != null)
1419     {
1420       if (stretchGroup.cs instanceof ClustalxColourScheme)
1421       {
1422         ((ClustalxColourScheme) stretchGroup.cs).resetClustalX(
1423                 stretchGroup.getSequences(av.hiddenRepSequences),
1424                 stretchGroup.getWidth());
1425       }
1426
1427       if (stretchGroup.cs instanceof Blosum62ColourScheme
1428               || stretchGroup.cs instanceof PIDColourScheme
1429               || stretchGroup.cs.conservationApplied()
1430               || stretchGroup.cs.getThreshold() > 0)
1431       {
1432         stretchGroup.recalcConservation();
1433       }
1434
1435       if (stretchGroup.cs.conservationApplied())
1436       {
1437         SliderPanel.setConservationSlider(ap, stretchGroup.cs,
1438                 stretchGroup.getName());
1439         stretchGroup.recalcConservation();
1440       }
1441       else
1442       {
1443         SliderPanel.setPIDSliderSource(ap, stretchGroup.cs,
1444                 stretchGroup.getName());
1445       }
1446     }
1447     changeEndRes = false;
1448     changeStartRes = false;
1449     stretchGroup = null;
1450     PaintRefresher.Refresh(ap, av.getSequenceSetId());
1451     ap.paintAlignment(true);
1452     av.sendSelection();
1453   }
1454
1455   public void doMouseDraggedDefineMode(MouseEvent evt)
1456   {
1457     int res = findRes(evt);
1458     int y = findSeq(evt);
1459
1460     if (wrappedBlock != startWrapBlock)
1461     {
1462       return;
1463     }
1464
1465     if (stretchGroup == null)
1466     {
1467       return;
1468     }
1469
1470     mouseDragging = true;
1471
1472     if (y > av.alignment.getHeight())
1473     {
1474       y = av.alignment.getHeight() - 1;
1475     }
1476
1477     if (res >= av.alignment.getWidth())
1478     {
1479       res = av.alignment.getWidth() - 1;
1480     }
1481
1482     if (stretchGroup.getEndRes() == res)
1483     {
1484       // Edit end res position of selected group
1485       changeEndRes = true;
1486     }
1487     else if (stretchGroup.getStartRes() == res)
1488     {
1489       // Edit start res position of selected group
1490       changeStartRes = true;
1491     }
1492
1493     if (res < 0)
1494     {
1495       res = 0;
1496     }
1497
1498     if (changeEndRes)
1499     {
1500       if (res > (stretchGroup.getStartRes() - 1))
1501       {
1502         stretchGroup.setEndRes(res);
1503       }
1504     }
1505     else if (changeStartRes)
1506     {
1507       if (res < (stretchGroup.getEndRes() + 1))
1508       {
1509         stretchGroup.setStartRes(res);
1510       }
1511     }
1512
1513     int dragDirection = 0;
1514
1515     if (y > oldSeq)
1516     {
1517       dragDirection = 1;
1518     }
1519     else if (y < oldSeq)
1520     {
1521       dragDirection = -1;
1522     }
1523
1524     while ((y != oldSeq) && (oldSeq > -1) && (y < av.alignment.getHeight()))
1525     {
1526       // This routine ensures we don't skip any sequences, as the
1527       // selection is quite slow.
1528       Sequence seq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
1529
1530       oldSeq += dragDirection;
1531
1532       if (oldSeq < 0)
1533       {
1534         break;
1535       }
1536
1537       Sequence nextSeq = (Sequence) av.getAlignment().getSequenceAt(oldSeq);
1538
1539       if (stretchGroup.getSequences(null).contains(nextSeq))
1540       {
1541         stretchGroup.deleteSequence(seq, false);
1542       }
1543       else
1544       {
1545         if (seq != null)
1546         {
1547           stretchGroup.addSequence(seq, false);
1548         }
1549
1550         stretchGroup.addSequence(nextSeq, false);
1551       }
1552     }
1553
1554     if (oldSeq < 0)
1555     {
1556       oldSeq = -1;
1557     }
1558
1559     if (res > av.endRes || res < av.startRes || y < av.startSeq
1560             || y > av.endSeq)
1561     {
1562       mouseExited(evt);
1563     }
1564
1565     if (scrollThread != null)
1566     {
1567       scrollThread.setEvent(evt);
1568     }
1569
1570     seqCanvas.repaint();
1571   }
1572
1573   public void mouseEntered(MouseEvent e)
1574   {
1575     if (oldSeq < 0)
1576     {
1577       oldSeq = 0;
1578     }
1579
1580     if (scrollThread != null)
1581     {
1582       scrollThread.running = false;
1583       scrollThread = null;
1584     }
1585   }
1586
1587   public void mouseExited(MouseEvent e)
1588   {
1589     if (av.getWrapAlignment())
1590     {
1591       return;
1592     }
1593
1594     if (mouseDragging && scrollThread == null)
1595     {
1596       scrollThread = new ScrollThread();
1597     }
1598   }
1599
1600   void scrollCanvas(MouseEvent evt)
1601   {
1602     if (evt == null)
1603     {
1604       if (scrollThread != null)
1605       {
1606         scrollThread.running = false;
1607         scrollThread = null;
1608       }
1609       mouseDragging = false;
1610     }
1611     else
1612     {
1613       if (scrollThread == null)
1614       {
1615         scrollThread = new ScrollThread();
1616       }
1617
1618       mouseDragging = true;
1619       scrollThread.setEvent(evt);
1620     }
1621
1622   }
1623
1624   // this class allows scrolling off the bottom of the visible alignment
1625   class ScrollThread extends Thread
1626   {
1627     MouseEvent evt;
1628
1629     boolean running = false;
1630
1631     public ScrollThread()
1632     {
1633       start();
1634     }
1635
1636     public void setEvent(MouseEvent e)
1637     {
1638       evt = e;
1639     }
1640
1641     public void stopScrolling()
1642     {
1643       running = false;
1644     }
1645
1646     public void run()
1647     {
1648       running = true;
1649       while (running)
1650       {
1651
1652         if (evt != null)
1653         {
1654
1655           if (mouseDragging && evt.getY() < 0 && av.getStartSeq() > 0)
1656           {
1657             running = ap.scrollUp(true);
1658           }
1659
1660           if (mouseDragging && evt.getY() >= getSize().height
1661                   && av.alignment.getHeight() > av.getEndSeq())
1662           {
1663             running = ap.scrollUp(false);
1664           }
1665
1666           if (mouseDragging && evt.getX() < 0)
1667           {
1668             running = ap.scrollRight(false);
1669           }
1670
1671           else if (mouseDragging && evt.getX() >= getSize().width)
1672           {
1673             running = ap.scrollRight(true);
1674           }
1675         }
1676
1677         try
1678         {
1679           Thread.sleep(75);
1680         } catch (Exception ex)
1681         {
1682         }
1683       }
1684     }
1685   }
1686   /**
1687    * modify current selection according to a received message.
1688    */
1689   public void selection(SequenceGroup seqsel, ColumnSelection colsel,
1690           SelectionSource source)
1691   {
1692     // TODO: fix this hack - source of messages is align viewport, but SeqPanel
1693     // handles selection messages...
1694     // TODO: extend config options to allow user to control if selections may be
1695     // shared between viewports.
1696     if (av!=null && (av == source
1697             || !av.followSelection
1698             || (source instanceof AlignViewport && ((AlignViewport) source)
1699                     .getSequenceSetId().equals(av.getSequenceSetId()))))
1700     {
1701       return;
1702     }
1703     // do we want to thread this ? (contention with seqsel and colsel locks, I
1704     // suspect)
1705     // rules are: colsel is copied if there is a real intersection between
1706     // sequence selection
1707     boolean repaint = false, copycolsel = true;
1708     if (av.selectionGroup == null || !av.isSelectionGroupChanged())
1709     {
1710       SequenceGroup sgroup = null;
1711       if (seqsel != null)
1712       {
1713         if (av.alignment == null)
1714         {
1715           System.out.println("Selection message: alignviewport av SeqSetId="
1716                   + av.getSequenceSetId() + " ViewId=" + av.getViewId()
1717                   + " 's alignment is NULL! returning immediatly.");
1718           return;
1719         }
1720         sgroup = seqsel.intersect(av.alignment,
1721                 (av.hasHiddenRows) ? av.hiddenRepSequences : null);
1722         if ((sgroup == null || sgroup.getSize() == 0)
1723                 && (colsel == null || colsel.size() == 0))
1724         {
1725           // don't copy columns if the region didn't intersect.
1726           copycolsel = false;
1727         }
1728       }
1729       if (sgroup != null && sgroup.getSize() > 0)
1730       {
1731         av.setSelectionGroup(sgroup);
1732       }
1733       else
1734       {
1735         av.setSelectionGroup(null);
1736       }
1737       repaint = av.isSelectionGroupChanged();
1738     }
1739     if (copycolsel && (av.colSel == null || !av.isColSelChanged()))
1740     {
1741       // the current selection is unset or from a previous message
1742       // so import the new colsel.
1743       if (colsel == null || colsel.size() == 0)
1744       {
1745         if (av.colSel != null)
1746         {
1747           av.colSel.clear();
1748         }
1749       }
1750       else
1751       {
1752         // TODO: shift colSel according to the intersecting sequences
1753         if (av.colSel == null)
1754         {
1755           av.colSel = new ColumnSelection(colsel);
1756         }
1757         else
1758         {
1759           av.colSel.setElementsFrom(colsel);
1760         }
1761       }
1762       repaint |= av.isColSelChanged();
1763     }
1764     if (copycolsel && av.hasHiddenColumns
1765             && (av.colSel == null || av.colSel.getHiddenColumns() == null))
1766     {
1767       System.err.println("Bad things");
1768     }
1769     if (repaint)
1770     {
1771       // probably finessing with multiple redraws here
1772       PaintRefresher.Refresh(this, av.getSequenceSetId());
1773       // ap.paintAlignment(false);
1774     }
1775   }
1776
1777 }