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     seqPanel.seqCanvas.highlightSearchResults(results);
 234   }
 235
 236   /**
 237    * scroll the view to show the position of the highlighted region in results
 238    * (if any)
 239    *
 240    * @param results
 241    */
 242   public void scrollToPosition(SearchResults results)
 243   {
 244     // do we need to scroll the panel?
 245     if (results != null && results.getSize() > 0)
 246     {
 247       int seqIndex = av.alignment.findIndex(results);
 248       if (seqIndex == -1)
 249       {
 250         return;
 251       }
 252       SequenceI seq = av.alignment.getSequenceAt(seqIndex);
 253       int[] r = results.getResults(seq, seq.getStart(), seq.getEnd());
 254       if (r == null)
 255       {
 256         return;
 257       }
 258       int start = r[0];
 259       int end = r[1];
 260       if (start < 0)
 261       {
 262         return;
 263       }
 264       if (end == seq.getEnd())
 265       {
 266         return;
 267       }
 268       if (av.hasHiddenColumns)
 269       {
 270         start = av.getColumnSelection().findColumnPosition(start);
 271         end = av.getColumnSelection().findColumnPosition(end);
 272         if (start==end)
 273         {
 274           if (!av.colSel.isVisible(r[0]))
 275           {
 276             // don't scroll - position isn't visible
 277             return;
 278           }
 279         }
 280       }
 281       if (!av.wrapAlignment)
 282       {
 283         if ((av.getStartRes() > end)
 284                 || (av.getEndRes() < start)
 285                 || ((av.getStartSeq() > seqIndex) || (av.getEndSeq() < seqIndex)))
 286         {
 287           if (start > av.alignment.getWidth() - hextent)
 288           {
 289             start = av.alignment.getWidth() - hextent;
 290             if (start < 0)
 291             {
 292               start = 0;
 293             }
 294           }
 295           if (seqIndex > av.alignment.getHeight() - vextent)
 296           {
 297             seqIndex = av.alignment.getHeight() - vextent;
 298             if (seqIndex < 0)
 299             {
 300               seqIndex = 0;
 301             }
 302           }
 303           setScrollValues(start, seqIndex);
 304         }
 305       }
 306       else
 307       {
 308         scrollToWrappedVisible(start);
 309       }
 310     }
 311
 312     repaint();
 313   }
 314
 315   void scrollToWrappedVisible(int res)
 316   {
 317     int cwidth = seqPanel.seqCanvas
 318             .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 319     if (res <= av.getStartRes() || res >= (av.getStartRes() + cwidth))
 320     {
 321       vscroll.setValue(res / cwidth);
 322       av.startRes = vscroll.getValue() * cwidth;
 323     }
 324   }
 325
 326   public OverviewPanel getOverviewPanel()
 327   {
 328     return overviewPanel;
 329   }
 330
 331   public void setOverviewPanel(OverviewPanel op)
 332   {
 333     overviewPanel = op;
 334   }
 335
 336   public void setAnnotationVisible(boolean b)
 337   {
 338     if (!av.wrapAlignment)
 339     {
 340       annotationSpaceFillerHolder.setVisible(b);
 341       annotationPanel.setVisible(b);
 342     }
 343     validate();
 344     repaint();
 345   }
 346
 347   public void setWrapAlignment(boolean wrap)
 348   {
 349     av.startSeq = 0;
 350     av.startRes = 0;
 351     scalePanelHolder.setVisible(!wrap);
 352
 353     hscroll.setVisible(!wrap);
 354     idwidthAdjuster.setVisible(!wrap);
 355
 356     if (wrap)
 357     {
 358       annotationPanel.setVisible(false);
 359       annotationSpaceFillerHolder.setVisible(false);
 360     }
 361     else if (av.showAnnotation)
 362     {
 363       annotationPanel.setVisible(true);
 364       annotationSpaceFillerHolder.setVisible(true);
 365     }
 366
 367     idSpaceFillerPanel1.setVisible(!wrap);
 368
 369     fontChanged(); // This is so that the scalePanel is resized correctly
 370
 371     validate();
 372     repaint();
 373
 374   }
 375
 376   int hextent = 0;
 377
 378   int vextent = 0;
 379
 380   // return value is true if the scroll is valid
 381   public boolean scrollUp(boolean up)
 382   {
 383     if (up)
 384     {
 385       if (vscroll.getValue() < 1)
 386       {
 387         return false;
 388       }
 389       setScrollValues(hscroll.getValue(), vscroll.getValue() - 1);
 390     }
 391     else
 392     {
 393       if (vextent + vscroll.getValue() >= av.getAlignment().getHeight())
 394       {
 395         return false;
 396       }
 397       setScrollValues(hscroll.getValue(), vscroll.getValue() + 1);
 398     }
 399
 400     repaint();
 401     return true;
 402   }
 403
 404   public boolean scrollRight(boolean right)
 405   {
 406     if (!right)
 407     {
 408       if (hscroll.getValue() < 1)
 409       {
 410         return false;
 411       }
 412       setScrollValues(hscroll.getValue() - 1, vscroll.getValue());
 413     }
 414     else
 415     {
 416       if (hextent + hscroll.getValue() >= av.getAlignment().getWidth())
 417       {
 418         return false;
 419       }
 420       setScrollValues(hscroll.getValue() + 1, vscroll.getValue());
 421     }
 422
 423     repaint();
 424     return true;
 425   }
 426
 427   public void setScrollValues(int x, int y)
 428   {
 429     int width = av.alignment.getWidth();
 430     int height = av.alignment.getHeight();
 431
 432     if (av.hasHiddenColumns)
 433     {
 434       width = av.getColumnSelection().findColumnPosition(width);
 435     }
 436
 437     av.setStartRes(x);
 438     av.setEndRes((x + (seqPanel.seqCanvas.getSize().width / av.charWidth)) - 1);
 439
 440     hextent = seqPanel.seqCanvas.getSize().width / av.charWidth;
 441     vextent = seqPanel.seqCanvas.getSize().height / av.charHeight;
 442
 443     if (hextent > width)
 444     {
 445       hextent = width;
 446     }
 447
 448     if (vextent > height)
 449     {
 450       vextent = height;
 451     }
 452
 453     if ((hextent + x) > width)
 454     {
 455       x = width - hextent;
 456     }
 457
 458     if ((vextent + y) > height)
 459     {
 460       y = height - vextent;
 461     }
 462
 463     if (y < 0)
 464     {
 465       y = 0;
 466     }
 467
 468     if (x < 0)
 469     {
 470       x = 0;
 471     }
 472
 473     av.setStartSeq(y);
 474
 475     int endSeq = y + vextent;
 476     if (endSeq > av.alignment.getHeight())
 477     {
 478       endSeq = av.alignment.getHeight();
 479     }
 480
 481     av.setEndSeq(endSeq);
 482     hscroll.setValues(x, hextent, 0, width);
 483     vscroll.setValues(y, vextent, 0, height);
 484
 485     if (overviewPanel != null)
 486     {
 487       overviewPanel.setBoxPosition();
 488     }
 489
 490   }
 491
 492   public void adjustmentValueChanged(AdjustmentEvent evt)
 493   {
 494     int oldX = av.getStartRes();
 495     int oldY = av.getStartSeq();
 496
 497     if (evt == null || evt.getSource() == hscroll)
 498     {
 499       int x = hscroll.getValue();
 500       av.setStartRes(x);
 501       av.setEndRes(x + seqPanel.seqCanvas.getSize().width
 502               / av.getCharWidth() - 1);
 503     }
 504
 505     if (evt == null || evt.getSource() == vscroll)
 506     {
 507       int offy = vscroll.getValue();
 508       if (av.getWrapAlignment())
 509       {
 510         int rowSize = seqPanel.seqCanvas
 511                 .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 512         av.setStartRes(vscroll.getValue() * rowSize);
 513         av.setEndRes((vscroll.getValue() + 1) * rowSize);
 514       }
 515       else
 516       {
 517         av.setStartSeq(offy);
 518         av.setEndSeq(offy + seqPanel.seqCanvas.getSize().height
 519                 / av.getCharHeight());
 520       }
 521     }
 522
 523     if (overviewPanel != null)
 524     {
 525       overviewPanel.setBoxPosition();
 526     }
 527
 528     int scrollX = av.startRes - oldX;
 529     int scrollY = av.startSeq - oldY;
 530
 531     if (av.getWrapAlignment() || !fastPaint || av.MAC)
 532     {
 533       repaint();
 534     }
 535     else
 536     {
 537       // Make sure we're not trying to draw a panel
 538       // larger than the visible window
 539       if (scrollX > av.endRes - av.startRes)
 540       {
 541         scrollX = av.endRes - av.startRes;
 542       }
 543       else if (scrollX < av.startRes - av.endRes)
 544       {
 545         scrollX = av.startRes - av.endRes;
 546       }
 547
 548       idPanel.idCanvas.fastPaint(scrollY);
 549       seqPanel.seqCanvas.fastPaint(scrollX, scrollY);
 550
 551       scalePanel.repaint();
 552       if (av.getShowAnnotation())
 553       {
 554         annotationPanel.fastPaint(av.getStartRes() - oldX);
 555       }
 556     }
 557
 558   }
 559
 560   public void paintAlignment(boolean updateOverview)
 561   {
 562     repaint();
 563
 564     if (updateOverview)
 565     {
 566       jalview.structure.StructureSelectionManager
 567               .getStructureSelectionManager().sequenceColoursChanged(this);
 568
 569       if (overviewPanel != null)
 570       {
 571         overviewPanel.updateOverviewImage();
 572       }
 573     }
 574   }
 575
 576   public void update(Graphics g)
 577   {
 578     paint(g);
 579   }
 580
 581   public void paint(Graphics g)
 582   {
 583     invalidate();
 584     Dimension d = idPanel.idCanvas.getSize();
 585     idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
 586     annotationSpaceFillerHolder.setSize(d.width,
 587             annotationPanel.getSize().height);
 588
 589     alabels.setSize(d.width, annotationPanel.getSize().height);
 590
 591     if (av.getWrapAlignment())
 592     {
 593       int maxwidth = av.alignment.getWidth();
 594
 595       if (av.hasHiddenColumns)
 596       {
 597         maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
 598       }
 599
 600       int canvasWidth = seqPanel.seqCanvas
 601               .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 602
 603       if (canvasWidth > 0)
 604       {
 605         int max = maxwidth / canvasWidth;
 606         vscroll.setMaximum(max);
 607         vscroll.setUnitIncrement(1);
 608         vscroll.setVisibleAmount(1);
 609       }
 610     }
 611     else
 612     {
 613       setScrollValues(av.getStartRes(), av.getStartSeq());
 614     }
 615
 616     alabels.repaint();
 617
 618     seqPanel.seqCanvas.repaint();
 619     scalePanel.repaint();
 620     annotationPanel.repaint();
 621     idPanel.idCanvas.repaint();
 622   }
 623
 624   protected Panel sequenceHolderPanel = new Panel();
 625
 626   protected Scrollbar vscroll = new Scrollbar();
 627
 628   protected Scrollbar hscroll = new Scrollbar();
 629
 630   protected Panel seqPanelHolder = new Panel();
 631
 632   BorderLayout borderLayout1 = new BorderLayout();
 633
 634   BorderLayout borderLayout3 = new BorderLayout();
 635
 636   protected Panel scalePanelHolder = new Panel();
 637
 638   protected Panel idPanelHolder = new Panel();
 639
 640   BorderLayout borderLayout5 = new BorderLayout();
 641
 642   protected Panel idSpaceFillerPanel1 = new Panel();
 643
 644   public Panel annotationSpaceFillerHolder = new Panel();
 645
 646   BorderLayout borderLayout6 = new BorderLayout();
 647
 648   BorderLayout borderLayout7 = new BorderLayout();
 649
 650   Panel hscrollHolder = new Panel();
 651
 652   BorderLayout borderLayout10 = new BorderLayout();
 653
 654   protected Panel hscrollFillerPanel = new Panel();
 655
 656   BorderLayout borderLayout11 = new BorderLayout();
 657
 658   BorderLayout borderLayout4 = new BorderLayout();
 659
 660   BorderLayout borderLayout2 = new BorderLayout();
 661
 662   private void jbInit() throws Exception
 663   {
 664     // idPanelHolder.setPreferredSize(new Dimension(70, 10));
 665     this.setLayout(borderLayout7);
 666
 667     // sequenceHolderPanel.setPreferredSize(new Dimension(150, 150));
 668     sequenceHolderPanel.setLayout(borderLayout3);
 669     seqPanelHolder.setLayout(borderLayout1);
 670     scalePanelHolder.setBackground(Color.white);
 671
 672     // scalePanelHolder.setPreferredSize(new Dimension(10, 30));
 673     scalePanelHolder.setLayout(borderLayout6);
 674     idPanelHolder.setLayout(borderLayout5);
 675     idSpaceFillerPanel1.setBackground(Color.white);
 676
 677     // idSpaceFillerPanel1.setPreferredSize(new Dimension(10, 30));
 678     idSpaceFillerPanel1.setLayout(borderLayout11);
 679     annotationSpaceFillerHolder.setBackground(Color.white);
 680
 681     // annotationSpaceFillerHolder.setPreferredSize(new Dimension(10, 80));
 682     annotationSpaceFillerHolder.setLayout(borderLayout4);
 683     hscroll.setOrientation(Scrollbar.HORIZONTAL);
 684     hscrollHolder.setLayout(borderLayout10);
 685     hscrollFillerPanel.setBackground(Color.white);
 686
 687     // hscrollFillerPanel.setPreferredSize(new Dimension(70, 10));
 688     hscrollHolder.setBackground(Color.white);
 689
 690     // annotationScroller.setPreferredSize(new Dimension(10, 80));
 691     // this.setPreferredSize(new Dimension(220, 166));
 692     seqPanelHolder.setBackground(Color.white);
 693     idPanelHolder.setBackground(Color.white);
 694     sequenceHolderPanel.add(scalePanelHolder, BorderLayout.NORTH);
 695     sequenceHolderPanel.add(seqPanelHolder, BorderLayout.CENTER);
 696     seqPanelHolder.add(vscroll, BorderLayout.EAST);
 697
 698     // Panel3.add(secondaryPanelHolder, BorderLayout.SOUTH);
 699     this.add(idPanelHolder, BorderLayout.WEST);
 700     idPanelHolder.add(idSpaceFillerPanel1, BorderLayout.NORTH);
 701     idPanelHolder.add(annotationSpaceFillerHolder, BorderLayout.SOUTH);
 702     this.add(hscrollHolder, BorderLayout.SOUTH);
 703     hscrollHolder.add(hscroll, BorderLayout.CENTER);
 704     hscrollHolder.add(hscrollFillerPanel, BorderLayout.WEST);
 705     this.add(sequenceHolderPanel, BorderLayout.CENTER);
 706   }
 707
 708 }