src/jalview/appletgui/AlignmentPanel.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.awt.*;
  21 import java.awt.event.*;
  22
  23 import jalview.datamodel.*;
  24
  25 public class AlignmentPanel extends Panel implements AdjustmentListener
  26 {
  27
  28   public AlignViewport av;
  29
  30   OverviewPanel overviewPanel;
  31
  32   SeqPanel seqPanel;
  33
  34   IdPanel idPanel;
  35
  36   IdwidthAdjuster idwidthAdjuster;
  37
  38   public AlignFrame alignFrame;
  39
  40   ScalePanel scalePanel;
  41
  42   AnnotationPanel annotationPanel;
  43
  44   AnnotationLabels alabels;
  45
  46   // this value is set false when selection area being dragged
  47   boolean fastPaint = true;
  48
  49   public AlignmentPanel(AlignFrame af, final AlignViewport av)
  50   {
  51     try
  52     {
  53       jbInit();
  54     } catch (Exception e)
  55     {
  56       e.printStackTrace();
  57     }
  58
  59     alignFrame = af;
  60     this.av = av;
  61     seqPanel = new SeqPanel(av, this);
  62     idPanel = new IdPanel(av, this);
  63     scalePanel = new ScalePanel(av, this);
  64     idwidthAdjuster = new IdwidthAdjuster(this);
  65     annotationPanel = new AnnotationPanel(this);
  66
  67     sequenceHolderPanel.add(annotationPanel, BorderLayout.SOUTH);
  68
  69     alabels = new AnnotationLabels(this);
  70
  71     setAnnotationVisible(av.showAnnotation);
  72
  73     idPanelHolder.add(idPanel, BorderLayout.CENTER);
  74     idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);
  75     annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);
  76     scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
  77     seqPanelHolder.add(seqPanel, BorderLayout.CENTER);
  78
  79     fontChanged();
  80     setScrollValues(0, 0);
  81
  82     hscroll.addAdjustmentListener(this);
  83     vscroll.addAdjustmentListener(this);
  84
  85     addComponentListener(new ComponentAdapter()
  86     {
  87       public void componentResized(ComponentEvent evt)
  88       {
  89         setScrollValues(av.getStartRes(), av.getStartSeq());
  90         repaint();
  91       }
  92     });
  93
  94     Dimension d = calculateIdWidth();
  95     idPanel.idCanvas.setSize(d);
  96
  97     hscrollFillerPanel.setSize(d.width, annotationPanel.getSize().height);
  98
  99     idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
 100     annotationSpaceFillerHolder.setSize(d.width,
 101             annotationPanel.getSize().height);
 102     alabels.setSize(d.width, annotationPanel.getSize().height);
 103
 104     final AlignmentPanel ap = this;
 105     av.addPropertyChangeListener(new java.beans.PropertyChangeListener()
 106     {
 107       public void propertyChange(java.beans.PropertyChangeEvent evt)
 108       {
 109         if (evt.getPropertyName().equals("alignment"))
 110         {
 111           PaintRefresher.Refresh(ap, av.getSequenceSetId(), true, true);
 112           alignmentChanged();
 113         }
 114       }
 115     });
 116
 117   }
 118
 119   public SequenceRenderer getSequenceRenderer()
 120   {
 121     return seqPanel.seqCanvas.sr;
 122   }
 123
 124   public FeatureRenderer getFeatureRenderer()
 125   {
 126     return seqPanel.seqCanvas.fr;
 127   }
 128
 129   public void alignmentChanged()
 130   {
 131     av.alignmentChanged(this);
 132
 133     if (overviewPanel != null)
 134     {
 135       overviewPanel.updateOverviewImage();
 136     }
 137
 138     alignFrame.updateEditMenuBar();
 139
 140     repaint();
 141   }
 142
 143   public void fontChanged()
 144   {
 145     // set idCanvas bufferedImage to null
 146     // to prevent drawing old image
 147     idPanel.idCanvas.image = null;
 148     FontMetrics fm = getFontMetrics(av.getFont());
 149
 150     scalePanel.setSize(new Dimension(10, av.charHeight + fm.getDescent()));
 151     idwidthAdjuster.setSize(new Dimension(10, av.charHeight
 152             + fm.getDescent()));
 153     av.updateSequenceIdColours();
 154     annotationPanel.image = null;
 155     int ap = annotationPanel.adjustPanelHeight();
 156     annotationPanel.repaint();
 157     Dimension d = calculateIdWidth();
 158     d.setSize(d.width + 4, seqPanel.seqCanvas.getSize().height);
 159     alabels.setSize(d.width + 4, ap);
 160     idPanel.idCanvas.setSize(d);
 161     hscrollFillerPanel.setSize(d);
 162
 163     validate();
 164     repaint();
 165
 166     if (overviewPanel != null)
 167     {
 168       overviewPanel.updateOverviewImage();
 169     }
 170   }
 171
 172   public void setIdWidth(int w, int h)
 173   {
 174     idPanel.idCanvas.setSize(w, h);
 175     idPanelHolder.setSize(w, idPanelHolder.getSize().height);
 176     alabels.setSize(w, alabels.getSize().height);
 177     validate();
 178   }
 179
 180   Dimension calculateIdWidth()
 181   {
 182     if (av.nullFrame == null)
 183     {
 184       av.nullFrame = new Frame();
 185       av.nullFrame.addNotify();
 186     }
 187
 188     Graphics g = av.nullFrame.getGraphics();
 189
 190     FontMetrics fm = g.getFontMetrics(av.font);
 191     AlignmentI al = av.getAlignment();
 192
 193     int i = 0;
 194     int idWidth = 0;
 195     String id;
 196     while (i < al.getHeight() && al.getSequenceAt(i) != null)
 197     {
 198       SequenceI s = al.getSequenceAt(i);
 199       id = s.getDisplayId(av.getShowJVSuffix());
 200
 201       if (fm.stringWidth(id) > idWidth)
 202       {
 203         idWidth = fm.stringWidth(id);
 204       }
 205       i++;
 206     }
 207
 208     // Also check annotation label widths
 209     i = 0;
 210     if (al.getAlignmentAnnotation() != null)
 211     {
 212       fm = g.getFontMetrics(av.nullFrame.getFont());
 213       while (i < al.getAlignmentAnnotation().length)
 214       {
 215         String label = al.getAlignmentAnnotation()[i].label;
 216         if (fm.stringWidth(label) > idWidth)
 217         {
 218           idWidth = fm.stringWidth(label);
 219         }
 220         i++;
 221       }
 222     }
 223
 224     return new Dimension(idWidth, idPanel.idCanvas.getSize().height);
 225   }
 226
 227   /**
 228    * Highlight the given results on the alignment.
 229    *
 230    */
 231   public void highlightSearchResults(SearchResults results)
 232   {
 233     scrollToPosition(results);
 234     seqPanel.seqCanvas.highlightSearchResults(results);
 235   }
 236
 237   /**
 238    * scroll the view to show the position of the highlighted region in results
 239    * (if any) and redraw the overview
 240    *
 241    * @param results
 242    * @return false if results were not found
 243    */
 244   public boolean scrollToPosition(SearchResults results)
 245   {
 246     return scrollToPosition(results, true);
 247   }
 248
 249   /**
 250    * scroll the view to show the position of the highlighted region in results
 251    * (if any)
 252    *
 253    * @param results
 254    * @param redrawOverview
 255    *          - when set, the overview will be recalculated (takes longer)
 256    * @return false if results were not found
 257    */
 258   public boolean scrollToPosition(SearchResults results,
 259           boolean redrawOverview)
 260   {
 261     // do we need to scroll the panel?
 262     if (results != null && results.getSize() > 0)
 263     {
 264       int seqIndex = av.alignment.findIndex(results);
 265       if (seqIndex == -1)
 266       {
 267         return false;
 268       }
 269       SequenceI seq = av.alignment.getSequenceAt(seqIndex);
 270       int[] r = results.getResults(seq, seq.getStart(), seq.getEnd());
 271       if (r == null)
 272       {
 273         return false;
 274       }
 275       int start = r[0];
 276       int end = r[1];
 277       if (start < 0)
 278       {
 279         return false;
 280       }
 281       if (end == seq.getEnd())
 282       {
 283         return false;
 284       }
 285       if (av.hasHiddenColumns)
 286       {
 287         start = av.getColumnSelection().findColumnPosition(start);
 288         end = av.getColumnSelection().findColumnPosition(end);
 289         if (start == end)
 290         {
 291           if (!av.colSel.isVisible(r[0]))
 292           {
 293             // don't scroll - position isn't visible
 294             return false;
 295           }
 296         }
 297       }
 298       if (!av.wrapAlignment)
 299       {
 300         if ((av.getStartRes() > end)
 301                 || (av.getEndRes() < start)
 302                 || ((av.getStartSeq() > seqIndex) || (av.getEndSeq() < seqIndex)))
 303         {
 304           if (start > av.alignment.getWidth() - hextent)
 305           {
 306             start = av.alignment.getWidth() - hextent;
 307             if (start < 0)
 308             {
 309               start = 0;
 310             }
 311           }
 312           if (seqIndex > av.alignment.getHeight() - vextent)
 313           {
 314             seqIndex = av.alignment.getHeight() - vextent;
 315             if (seqIndex < 0)
 316             {
 317               seqIndex = 0;
 318             }
 319           }
 320           setScrollValues(start, seqIndex);
 321         }
 322       }
 323       else
 324       {
 325         scrollToWrappedVisible(start);
 326       }
 327     }
 328     if (redrawOverview && overviewPanel != null)
 329     {
 330       overviewPanel.setBoxPosition();
 331     }
 332     paintAlignment(redrawOverview);
 333     return true;
 334   }
 335
 336   void scrollToWrappedVisible(int res)
 337   {
 338     int cwidth = seqPanel.seqCanvas
 339             .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 340     if (res <= av.getStartRes() || res >= (av.getStartRes() + cwidth))
 341     {
 342       vscroll.setValue(res / cwidth);
 343       av.startRes = vscroll.getValue() * cwidth;
 344     }
 345   }
 346
 347   public OverviewPanel getOverviewPanel()
 348   {
 349     return overviewPanel;
 350   }
 351
 352   public void setOverviewPanel(OverviewPanel op)
 353   {
 354     overviewPanel = op;
 355   }
 356
 357   public void setAnnotationVisible(boolean b)
 358   {
 359     if (!av.wrapAlignment)
 360     {
 361       annotationSpaceFillerHolder.setVisible(b);
 362       annotationPanel.setVisible(b);
 363     }
 364     validate();
 365     repaint();
 366   }
 367
 368   public void setWrapAlignment(boolean wrap)
 369   {
 370     av.startSeq = 0;
 371     av.startRes = 0;
 372     scalePanelHolder.setVisible(!wrap);
 373
 374     hscroll.setVisible(!wrap);
 375     idwidthAdjuster.setVisible(!wrap);
 376
 377     if (wrap)
 378     {
 379       annotationPanel.setVisible(false);
 380       annotationSpaceFillerHolder.setVisible(false);
 381     }
 382     else if (av.showAnnotation)
 383     {
 384       annotationPanel.setVisible(true);
 385       annotationSpaceFillerHolder.setVisible(true);
 386     }
 387
 388     idSpaceFillerPanel1.setVisible(!wrap);
 389
 390     fontChanged(); // This is so that the scalePanel is resized correctly
 391
 392     validate();
 393     repaint();
 394
 395   }
 396
 397   int hextent = 0;
 398
 399   int vextent = 0;
 400
 401   // return value is true if the scroll is valid
 402   public boolean scrollUp(boolean up)
 403   {
 404     if (up)
 405     {
 406       if (vscroll.getValue() < 1)
 407       {
 408         return false;
 409       }
 410       setScrollValues(hscroll.getValue(), vscroll.getValue() - 1);
 411     }
 412     else
 413     {
 414       if (vextent + vscroll.getValue() >= av.getAlignment().getHeight())
 415       {
 416         return false;
 417       }
 418       setScrollValues(hscroll.getValue(), vscroll.getValue() + 1);
 419     }
 420
 421     repaint();
 422     return true;
 423   }
 424
 425   public boolean scrollRight(boolean right)
 426   {
 427     if (!right)
 428     {
 429       if (hscroll.getValue() < 1)
 430       {
 431         return false;
 432       }
 433       setScrollValues(hscroll.getValue() - 1, vscroll.getValue());
 434     }
 435     else
 436     {
 437       if (hextent + hscroll.getValue() >= av.getAlignment().getWidth())
 438       {
 439         return false;
 440       }
 441       setScrollValues(hscroll.getValue() + 1, vscroll.getValue());
 442     }
 443
 444     repaint();
 445     return true;
 446   }
 447
 448   public void setScrollValues(int x, int y)
 449   {
 450     int width = av.alignment.getWidth();
 451     int height = av.alignment.getHeight();
 452
 453     if (av.hasHiddenColumns)
 454     {
 455       width = av.getColumnSelection().findColumnPosition(width);
 456     }
 457
 458     av.setStartRes(x);
 459     av.setEndRes((x + (seqPanel.seqCanvas.getSize().width / av.charWidth)) - 1);
 460
 461     hextent = seqPanel.seqCanvas.getSize().width / av.charWidth;
 462     vextent = seqPanel.seqCanvas.getSize().height / av.charHeight;
 463
 464     if (hextent > width)
 465     {
 466       hextent = width;
 467     }
 468
 469     if (vextent > height)
 470     {
 471       vextent = height;
 472     }
 473
 474     if ((hextent + x) > width)
 475     {
 476       x = width - hextent;
 477     }
 478
 479     if ((vextent + y) > height)
 480     {
 481       y = height - vextent;
 482     }
 483
 484     if (y < 0)
 485     {
 486       y = 0;
 487     }
 488
 489     if (x < 0)
 490     {
 491       x = 0;
 492     }
 493
 494     av.setStartSeq(y);
 495
 496     int endSeq = y + vextent;
 497     if (endSeq > av.alignment.getHeight())
 498     {
 499       endSeq = av.alignment.getHeight();
 500     }
 501
 502     av.setEndSeq(endSeq);
 503     hscroll.setValues(x, hextent, 0, width);
 504     vscroll.setValues(y, vextent, 0, height);
 505
 506     if (overviewPanel != null)
 507     {
 508       overviewPanel.setBoxPosition();
 509     }
 510
 511   }
 512
 513   public void adjustmentValueChanged(AdjustmentEvent evt)
 514   {
 515     int oldX = av.getStartRes();
 516     int oldY = av.getStartSeq();
 517
 518     if (evt == null || evt.getSource() == hscroll)
 519     {
 520       int x = hscroll.getValue();
 521       av.setStartRes(x);
 522       av.setEndRes(x + seqPanel.seqCanvas.getSize().width
 523               / av.getCharWidth() - 1);
 524     }
 525
 526     if (evt == null || evt.getSource() == vscroll)
 527     {
 528       int offy = vscroll.getValue();
 529       if (av.getWrapAlignment())
 530       {
 531         int rowSize = seqPanel.seqCanvas
 532                 .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 533         av.setStartRes(vscroll.getValue() * rowSize);
 534         av.setEndRes((vscroll.getValue() + 1) * rowSize);
 535       }
 536       else
 537       {
 538         av.setStartSeq(offy);
 539         av.setEndSeq(offy + seqPanel.seqCanvas.getSize().height
 540                 / av.getCharHeight());
 541       }
 542     }
 543
 544     if (overviewPanel != null)
 545     {
 546       overviewPanel.setBoxPosition();
 547     }
 548
 549     int scrollX = av.startRes - oldX;
 550     int scrollY = av.startSeq - oldY;
 551
 552     if (av.getWrapAlignment() || !fastPaint || av.MAC)
 553     {
 554       repaint();
 555     }
 556     else
 557     {
 558       // Make sure we're not trying to draw a panel
 559       // larger than the visible window
 560       if (scrollX > av.endRes - av.startRes)
 561       {
 562         scrollX = av.endRes - av.startRes;
 563       }
 564       else if (scrollX < av.startRes - av.endRes)
 565       {
 566         scrollX = av.startRes - av.endRes;
 567       }
 568
 569       idPanel.idCanvas.fastPaint(scrollY);
 570       seqPanel.seqCanvas.fastPaint(scrollX, scrollY);
 571
 572       scalePanel.repaint();
 573       if (av.getShowAnnotation())
 574       {
 575         annotationPanel.fastPaint(av.getStartRes() - oldX);
 576       }
 577     }
 578
 579   }
 580
 581   public void paintAlignment(boolean updateOverview)
 582   {
 583     repaint();
 584
 585     if (updateOverview)
 586     {
 587       jalview.structure.StructureSelectionManager
 588               .getStructureSelectionManager().sequenceColoursChanged(this);
 589
 590       if (overviewPanel != null)
 591       {
 592         overviewPanel.updateOverviewImage();
 593       }
 594     }
 595   }
 596
 597   public void update(Graphics g)
 598   {
 599     paint(g);
 600   }
 601
 602   public void paint(Graphics g)
 603   {
 604     invalidate();
 605     Dimension d = idPanel.idCanvas.getSize();
 606     idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
 607     annotationSpaceFillerHolder.setSize(d.width,
 608             annotationPanel.getSize().height);
 609
 610     alabels.setSize(d.width, annotationPanel.getSize().height);
 611
 612     if (av.getWrapAlignment())
 613     {
 614       int maxwidth = av.alignment.getWidth();
 615
 616       if (av.hasHiddenColumns)
 617       {
 618         maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
 619       }
 620
 621       int canvasWidth = seqPanel.seqCanvas
 622               .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 623
 624       if (canvasWidth > 0)
 625       {
 626         int max = maxwidth / canvasWidth;
 627         vscroll.setMaximum(max);
 628         vscroll.setUnitIncrement(1);
 629         vscroll.setVisibleAmount(1);
 630       }
 631     }
 632     else
 633     {
 634       setScrollValues(av.getStartRes(), av.getStartSeq());
 635     }
 636
 637     alabels.repaint();
 638
 639     seqPanel.seqCanvas.repaint();
 640     scalePanel.repaint();
 641     annotationPanel.repaint();
 642     idPanel.idCanvas.repaint();
 643   }
 644
 645   protected Panel sequenceHolderPanel = new Panel();
 646
 647   protected Scrollbar vscroll = new Scrollbar();
 648
 649   protected Scrollbar hscroll = new Scrollbar();
 650
 651   protected Panel seqPanelHolder = new Panel();
 652
 653   BorderLayout borderLayout1 = new BorderLayout();
 654
 655   BorderLayout borderLayout3 = new BorderLayout();
 656
 657   protected Panel scalePanelHolder = new Panel();
 658
 659   protected Panel idPanelHolder = new Panel();
 660
 661   BorderLayout borderLayout5 = new BorderLayout();
 662
 663   protected Panel idSpaceFillerPanel1 = new Panel();
 664
 665   public Panel annotationSpaceFillerHolder = new Panel();
 666
 667   BorderLayout borderLayout6 = new BorderLayout();
 668
 669   BorderLayout borderLayout7 = new BorderLayout();
 670
 671   Panel hscrollHolder = new Panel();
 672
 673   BorderLayout borderLayout10 = new BorderLayout();
 674
 675   protected Panel hscrollFillerPanel = new Panel();
 676
 677   BorderLayout borderLayout11 = new BorderLayout();
 678
 679   BorderLayout borderLayout4 = new BorderLayout();
 680
 681   BorderLayout borderLayout2 = new BorderLayout();
 682
 683   private void jbInit() throws Exception
 684   {
 685     // idPanelHolder.setPreferredSize(new Dimension(70, 10));
 686     this.setLayout(borderLayout7);
 687
 688     // sequenceHolderPanel.setPreferredSize(new Dimension(150, 150));
 689     sequenceHolderPanel.setLayout(borderLayout3);
 690     seqPanelHolder.setLayout(borderLayout1);
 691     scalePanelHolder.setBackground(Color.white);
 692
 693     // scalePanelHolder.setPreferredSize(new Dimension(10, 30));
 694     scalePanelHolder.setLayout(borderLayout6);
 695     idPanelHolder.setLayout(borderLayout5);
 696     idSpaceFillerPanel1.setBackground(Color.white);
 697
 698     // idSpaceFillerPanel1.setPreferredSize(new Dimension(10, 30));
 699     idSpaceFillerPanel1.setLayout(borderLayout11);
 700     annotationSpaceFillerHolder.setBackground(Color.white);
 701
 702     // annotationSpaceFillerHolder.setPreferredSize(new Dimension(10, 80));
 703     annotationSpaceFillerHolder.setLayout(borderLayout4);
 704     hscroll.setOrientation(Scrollbar.HORIZONTAL);
 705     hscrollHolder.setLayout(borderLayout10);
 706     hscrollFillerPanel.setBackground(Color.white);
 707
 708     // hscrollFillerPanel.setPreferredSize(new Dimension(70, 10));
 709     hscrollHolder.setBackground(Color.white);
 710
 711     // annotationScroller.setPreferredSize(new Dimension(10, 80));
 712     // this.setPreferredSize(new Dimension(220, 166));
 713     seqPanelHolder.setBackground(Color.white);
 714     idPanelHolder.setBackground(Color.white);
 715     sequenceHolderPanel.add(scalePanelHolder, BorderLayout.NORTH);
 716     sequenceHolderPanel.add(seqPanelHolder, BorderLayout.CENTER);
 717     seqPanelHolder.add(vscroll, BorderLayout.EAST);
 718
 719     // Panel3.add(secondaryPanelHolder, BorderLayout.SOUTH);
 720     this.add(idPanelHolder, BorderLayout.WEST);
 721     idPanelHolder.add(idSpaceFillerPanel1, BorderLayout.NORTH);
 722     idPanelHolder.add(annotationSpaceFillerHolder, BorderLayout.SOUTH);
 723     this.add(hscrollHolder, BorderLayout.SOUTH);
 724     hscrollHolder.add(hscroll, BorderLayout.CENTER);
 725     hscrollHolder.add(hscrollFillerPanel, BorderLayout.WEST);
 726     this.add(sequenceHolderPanel, BorderLayout.CENTER);
 727   }
 728
 729 }