src/jalview/appletgui/AlignmentPanel.java

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