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