src/jalview/appletgui/AlignmentPanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
   3  * Copyright (C) 2014 The Jalview Authors
   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
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.appletgui;
  22
  23 import jalview.api.AlignViewportI;
  24 import jalview.api.AlignmentViewPanel;
  25 import jalview.datamodel.AlignmentI;
  26 import jalview.datamodel.SearchResults;
  27 import jalview.datamodel.SequenceI;
  28 import jalview.structure.StructureSelectionManager;
  29
  30 import java.awt.BorderLayout;
  31 import java.awt.Color;
  32 import java.awt.Dimension;
  33 import java.awt.FontMetrics;
  34 import java.awt.Frame;
  35 import java.awt.Graphics;
  36 import java.awt.Panel;
  37 import java.awt.Scrollbar;
  38 import java.awt.event.AdjustmentEvent;
  39 import java.awt.event.AdjustmentListener;
  40 import java.awt.event.ComponentAdapter;
  41 import java.awt.event.ComponentEvent;
  42
  43 public class AlignmentPanel extends Panel implements AdjustmentListener,
  44         AlignmentViewPanel
  45 {
  46
  47   public AlignViewport av;
  48
  49   OverviewPanel overviewPanel;
  50
  51   SeqPanel seqPanel;
  52
  53   IdPanel idPanel;
  54
  55   IdwidthAdjuster idwidthAdjuster;
  56
  57   public AlignFrame alignFrame;
  58
  59   ScalePanel scalePanel;
  60
  61   AnnotationPanel annotationPanel;
  62
  63   AnnotationLabels alabels;
  64
  65   // this value is set false when selection area being dragged
  66   boolean fastPaint = true;
  67
  68   public void finalize()
  69   {
  70     alignFrame = null;
  71     av = null;
  72     seqPanel = null;
  73     seqPanelHolder = null;
  74     sequenceHolderPanel = null;
  75     scalePanel = null;
  76     scalePanelHolder = null;
  77     annotationPanel = null;
  78     annotationPanelHolder = null;
  79     annotationSpaceFillerHolder = null;
  80   }
  81
  82   public AlignmentPanel(AlignFrame af, final AlignViewport av)
  83   {
  84     try
  85     {
  86       jbInit();
  87     } catch (Exception e)
  88     {
  89       e.printStackTrace();
  90     }
  91
  92     alignFrame = af;
  93     this.av = av;
  94     seqPanel = new SeqPanel(av, this);
  95     idPanel = new IdPanel(av, this);
  96     scalePanel = new ScalePanel(av, this);
  97     idwidthAdjuster = new IdwidthAdjuster(this);
  98     annotationPanel = new AnnotationPanel(this);
  99     annotationPanelHolder.add(annotationPanel, BorderLayout.CENTER);
 100
 101     sequenceHolderPanel.add(annotationPanelHolder, BorderLayout.SOUTH);
 102     alabels = new AnnotationLabels(this);
 103
 104     setAnnotationVisible(av.isShowAnnotation());
 105
 106     idPanelHolder.add(idPanel, BorderLayout.CENTER);
 107     idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);
 108     annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);
 109     scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
 110     seqPanelHolder.add(seqPanel, BorderLayout.CENTER);
 111
 112     fontChanged();
 113     setScrollValues(0, 0);
 114
 115     apvscroll.addAdjustmentListener(this);
 116     hscroll.addAdjustmentListener(this);
 117     vscroll.addAdjustmentListener(this);
 118
 119     addComponentListener(new ComponentAdapter()
 120     {
 121       public void componentResized(ComponentEvent evt)
 122       {
 123         setScrollValues(av.getStartRes(), av.getStartSeq());
 124         if (getSize().height > 0
 125                 && annotationPanelHolder.getSize().height > 0)
 126         {
 127           validateAnnotationDimensions(false);
 128         }
 129         repaint();
 130       }
 131
 132     });
 133
 134     Dimension d = calculateIdWidth();
 135     idPanel.idCanvas.setSize(d);
 136
 137     hscrollFillerPanel.setSize(d.width, annotationPanel.getSize().height);
 138
 139     idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
 140     annotationSpaceFillerHolder.setSize(d.width,
 141             annotationPanel.getSize().height);
 142     alabels.setSize(d.width, annotationPanel.getSize().height);
 143     final AlignmentPanel ap = this;
 144     av.addPropertyChangeListener(new java.beans.PropertyChangeListener()
 145     {
 146       public void propertyChange(java.beans.PropertyChangeEvent evt)
 147       {
 148         if (evt.getPropertyName().equals("alignment"))
 149         {
 150           PaintRefresher.Refresh(ap, av.getSequenceSetId(), true, true);
 151           alignmentChanged();
 152         }
 153       }
 154     });
 155   }
 156
 157   @Override
 158   public AlignViewportI getAlignViewport()
 159   {
 160     return av;
 161   }
 162   public SequenceRenderer getSequenceRenderer()
 163   {
 164     return seqPanel.seqCanvas.sr;
 165   }
 166   @Override
 167   public jalview.api.FeatureRenderer getFeatureRenderer()
 168   {
 169     return seqPanel.seqCanvas.fr;
 170   }
 171   @Override
 172   public jalview.api.FeatureRenderer cloneFeatureRenderer()
 173   {
 174     FeatureRenderer nfr = new FeatureRenderer(av);
 175     nfr.transferSettings(seqPanel.seqCanvas.fr);
 176     return nfr;
 177   }
 178   public void alignmentChanged()
 179   {
 180     av.alignmentChanged(this);
 181
 182     if (overviewPanel != null)
 183     {
 184       overviewPanel.updateOverviewImage();
 185     }
 186
 187     alignFrame.updateEditMenuBar();
 188
 189     repaint();
 190   }
 191
 192   public void fontChanged()
 193   {
 194     // set idCanvas bufferedImage to null
 195     // to prevent drawing old image
 196     idPanel.idCanvas.image = null;
 197     FontMetrics fm = getFontMetrics(av.getFont());
 198
 199     scalePanel.setSize(new Dimension(10, av.getCharHeight()
 200             + fm.getDescent()));
 201     idwidthAdjuster.setSize(new Dimension(10, av.getCharHeight()
 202             + fm.getDescent()));
 203     av.updateSequenceIdColours();
 204     annotationPanel.image = null;
 205     int ap = annotationPanel.adjustPanelHeight(false);
 206     Dimension d = calculateIdWidth();
 207     d.setSize(d.width + 4, seqPanel.seqCanvas.getSize().height);
 208     alabels.setSize(d.width + 4, ap);
 209
 210     idPanel.idCanvas.setSize(d);
 211     hscrollFillerPanel.setSize(d);
 212
 213     validateAnnotationDimensions(false);
 214     annotationPanel.repaint();
 215     validate();
 216     repaint();
 217
 218     if (overviewPanel != null)
 219     {
 220       overviewPanel.updateOverviewImage();
 221     }
 222   }
 223
 224   public void setIdWidth(int w, int h)
 225   {
 226     idPanel.idCanvas.setSize(w, h);
 227     idPanelHolder.setSize(w, idPanelHolder.getSize().height);
 228     annotationSpaceFillerHolder.setSize(w,
 229             annotationSpaceFillerHolder.getSize().height);
 230     alabels.setSize(w, alabels.getSize().height);
 231     validate();
 232   }
 233
 234   Dimension calculateIdWidth()
 235   {
 236     if (av.nullFrame == null)
 237     {
 238       av.nullFrame = new Frame();
 239       av.nullFrame.addNotify();
 240     }
 241
 242     Graphics g = av.nullFrame.getGraphics();
 243
 244     FontMetrics fm = g.getFontMetrics(av.font);
 245     AlignmentI al = av.getAlignment();
 246
 247     int i = 0;
 248     int idWidth = 0;
 249     String id;
 250     while (i < al.getHeight() && al.getSequenceAt(i) != null)
 251     {
 252       SequenceI s = al.getSequenceAt(i);
 253       id = s.getDisplayId(av.getShowJVSuffix());
 254
 255       if (fm.stringWidth(id) > idWidth)
 256       {
 257         idWidth = fm.stringWidth(id);
 258       }
 259       i++;
 260     }
 261
 262     // Also check annotation label widths
 263     i = 0;
 264     if (al.getAlignmentAnnotation() != null)
 265     {
 266       fm = g.getFontMetrics(av.nullFrame.getFont());
 267       while (i < al.getAlignmentAnnotation().length)
 268       {
 269         String label = al.getAlignmentAnnotation()[i].label;
 270         if (fm.stringWidth(label) > idWidth)
 271         {
 272           idWidth = fm.stringWidth(label);
 273         }
 274         i++;
 275       }
 276     }
 277
 278     return new Dimension(idWidth, idPanel.idCanvas.getSize().height);
 279   }
 280
 281   /**
 282    * Highlight the given results on the alignment.
 283    *
 284    */
 285   public void highlightSearchResults(SearchResults results)
 286   {
 287     scrollToPosition(results);
 288     seqPanel.seqCanvas.highlightSearchResults(results);
 289   }
 290
 291   /**
 292    * scroll the view to show the position of the highlighted region in results
 293    * (if any) and redraw the overview
 294    *
 295    * @param results
 296    * @return false if results were not found
 297    */
 298   public boolean scrollToPosition(SearchResults results)
 299   {
 300     return scrollToPosition(results, true);
 301   }
 302
 303   /**
 304    * scroll the view to show the position of the highlighted region in results
 305    * (if any)
 306    *
 307    * @param results
 308    * @param redrawOverview
 309    *          - when set, the overview will be recalculated (takes longer)
 310    * @return false if results were not found
 311    */
 312   public boolean scrollToPosition(SearchResults results,
 313           boolean redrawOverview)
 314   {
 315
 316     // do we need to scroll the panel?
 317     if (results != null && results.getSize() > 0)
 318     {
 319       AlignmentI alignment = av.getAlignment();
 320       int seqIndex = alignment.findIndex(results);
 321       if (seqIndex == -1)
 322       {
 323         return false;
 324       }
 325       SequenceI seq = alignment.getSequenceAt(seqIndex);
 326       int[] r = results.getResults(seq, 0, alignment.getWidth());
 327       if (r == null)
 328       {
 329         if (av.applet.debug)
 330         {// DEBUG
 331           System.out
 332                   .println("DEBUG: scroll didn't happen - results not within alignment : "
 333                           + seq.getStart() + "," + seq.getEnd());
 334         }
 335         return false;
 336       }
 337       if (av.applet.debug)
 338       {
 339         // DEBUG
 340         /*
 341          * System.out.println("DEBUG: scroll: start=" + r[0] +
 342          * " av.getStartRes()=" + av.getStartRes() + " end=" + r[1] +
 343          * " seq.end=" + seq.getEnd() + " av.getEndRes()=" + av.getEndRes() +
 344          * " hextent=" + hextent);
 345          */
 346       }
 347       int start = r[0];
 348       int end = r[1];
 349       if (start < 0)
 350       {
 351         return false;
 352       }
 353       if (end == seq.getEnd())
 354       {
 355         return false;
 356       }
 357       return scrollTo(start, end, seqIndex, false, redrawOverview);
 358     }
 359     return true;
 360   }
 361
 362   public boolean scrollTo(int ostart, int end, int seqIndex,
 363           boolean scrollToNearest, boolean redrawOverview)
 364   {
 365     int startv, endv, starts, ends, width;
 366
 367     int start = -1;
 368     if (av.hasHiddenColumns())
 369     {
 370       start = av.getColumnSelection().findColumnPosition(ostart);
 371       end = av.getColumnSelection().findColumnPosition(end);
 372       if (start == end)
 373       {
 374         if (!scrollToNearest && !av.getColumnSelection().isVisible(ostart))
 375         {
 376           // don't scroll - position isn't visible
 377           return false;
 378         }
 379       }
 380     }
 381     else
 382     {
 383       start = ostart;
 384     }
 385     if (!av.getWrapAlignment())
 386     {
 387       /*
 388        * int spos=av.getStartRes(),sqpos=av.getStartSeq(); if ((startv =
 389        * av.getStartRes()) >= start) { spos=start-1; // seqIn //
 390        * setScrollValues(start - 1, seqIndex); } else if ((endv =
 391        * av.getEndRes()) <= end) { // setScrollValues(spos=startv + 1 + end -
 392        * endv, seqIndex); spos=startv + 1 + end - endv; } else if ((starts =
 393        * av.getStartSeq()) > seqIndex) { setScrollValues(av.getStartRes(),
 394        * seqIndex); } else if ((ends = av.getEndSeq()) <= seqIndex) {
 395        * setScrollValues(av.getStartRes(), starts + seqIndex - ends + 1); }
 396        *
 397        * /*
 398        */
 399       if ((av.getStartRes() > end)
 400               || (av.getEndRes() < start)
 401               || ((av.getStartSeq() > seqIndex) || (av.getEndSeq() < seqIndex)))
 402       {
 403         if (start > av.getAlignment().getWidth() - hextent)
 404         {
 405           start = av.getAlignment().getWidth() - hextent;
 406           if (start < 0)
 407           {
 408             start = 0;
 409           }
 410
 411         }
 412         if (seqIndex > av.getAlignment().getHeight() - vextent)
 413         {
 414           seqIndex = av.getAlignment().getHeight() - vextent;
 415           if (seqIndex < 0)
 416           {
 417             seqIndex = 0;
 418           }
 419         }
 420         // System.out.println("trying to scroll to: "+start+" "+seqIndex);
 421         setScrollValues(start, seqIndex);
 422       }/**/
 423     }
 424     else
 425     {
 426       scrollToWrappedVisible(start);
 427     }
 428     if (redrawOverview && overviewPanel != null)
 429     {
 430       overviewPanel.setBoxPosition();
 431     }
 432     paintAlignment(redrawOverview);
 433     return true;
 434   }
 435
 436   void scrollToWrappedVisible(int res)
 437   {
 438     int cwidth = seqPanel.seqCanvas
 439             .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 440     if (res <= av.getStartRes() || res >= (av.getStartRes() + cwidth))
 441     {
 442       vscroll.setValue(res / cwidth);
 443       av.startRes = vscroll.getValue() * cwidth;
 444     }
 445   }
 446
 447   public OverviewPanel getOverviewPanel()
 448   {
 449     return overviewPanel;
 450   }
 451
 452   public void setOverviewPanel(OverviewPanel op)
 453   {
 454     overviewPanel = op;
 455   }
 456
 457   public void setAnnotationVisible(boolean b)
 458   {
 459     if (!av.getWrapAlignment())
 460     {
 461       annotationSpaceFillerHolder.setVisible(b);
 462       annotationPanelHolder.setVisible(b);
 463     }
 464     else
 465     {
 466       annotationSpaceFillerHolder.setVisible(false);
 467       annotationPanelHolder.setVisible(false);
 468     }
 469     validate();
 470     repaint();
 471   }
 472
 473   /**
 474    * automatically adjust annotation panel height for new annotation whilst
 475    * ensuring the alignment is still visible.
 476    */
 477   public void adjustAnnotationHeight()
 478   {
 479     // TODO: display vertical annotation scrollbar if necessary
 480     // this is called after loading new annotation onto alignment
 481     if (alignFrame.getSize().height == 0)
 482     {
 483       System.out.println("NEEDS FIXING");
 484     }
 485     fontChanged();
 486     validateAnnotationDimensions(true);
 487     apvscroll.addNotify();
 488     hscroll.addNotify();
 489     validate();
 490     paintAlignment(true);
 491   }
 492
 493   /**
 494    * calculate the annotation dimensions and refresh slider values accordingly.
 495    * need to do repaints/notifys afterwards.
 496    */
 497   protected void validateAnnotationDimensions(boolean adjustPanelHeight)
 498   {
 499     boolean modified = false;
 500     int height = av.calcPanelHeight();
 501     int minsize = 0;
 502     if (hscroll.isVisible())
 503     {
 504       height += (minsize = hscroll.getPreferredSize().height);
 505     }
 506     if (apvscroll.isVisible())
 507     {
 508       minsize += apvscroll.getPreferredSize().height;
 509     }
 510     int mheight = height;
 511     Dimension d = sequenceHolderPanel.getSize(), e = idPanel.getSize();
 512     int seqandannot = d.height - scalePanelHolder.getSize().height;
 513
 514     if (adjustPanelHeight)
 515     {
 516       // NOTE: this logic is different in the application. Need a better
 517       // algorithm to define behaviour
 518       // sets initial preferred height
 519       // try and set height according to alignment
 520       float sscaling = (float) ((av.getCharHeight() * av.getAlignment()
 521               .getHeight()) / (1.0 * mheight));
 522       if (sscaling > 0.5)
 523       {
 524         // if the alignment is too big then
 525         // default is 0.5 split
 526         height = seqandannot / 2;
 527       }
 528       else
 529       {
 530         // otherwise just set the panel so that one row of sequence is visible
 531         height = -av.getCharHeight() * 1
 532                 + (int) (seqandannot * (1 - sscaling));
 533       }
 534     }
 535     else
 536     {
 537       // maintain same window layout whilst updating sliders
 538       height = annotationPanelHolder.getSize().height;
 539     }
 540
 541     if (seqandannot - height < 5)
 542     {
 543       height = seqandannot;
 544     }
 545     annotationPanel.setSize(new Dimension(d.width, height));
 546     alabels.setSize(new Dimension(e.width, height));
 547     annotationSpaceFillerHolder.setSize(new Dimension(e.width, height));
 548     annotationPanelHolder.setSize(new Dimension(d.width, height));
 549     // seqPanelHolder.setSize(d.width, seqandannot - height);
 550     seqPanel.seqCanvas
 551             .setSize(d.width, seqPanel.seqCanvas.getSize().height);
 552     int s = apvscroll.getValue();
 553     if (s > mheight - height)
 554     {
 555       s = 0;
 556     }
 557     apvscroll.setValues(s, height, 0, mheight);
 558     annotationPanel.setScrollOffset(apvscroll.getValue(), false);
 559     alabels.setScrollOffset(apvscroll.getValue(), false);
 560   }
 561
 562   public void setWrapAlignment(boolean wrap)
 563   {
 564     av.startSeq = 0;
 565     av.startRes = 0;
 566     scalePanelHolder.setVisible(!wrap);
 567
 568     hscroll.setVisible(!wrap);
 569     idwidthAdjuster.setVisible(!wrap);
 570
 571     if (wrap)
 572     {
 573       annotationPanelHolder.setVisible(false);
 574       annotationSpaceFillerHolder.setVisible(false);
 575     }
 576     else if (av.isShowAnnotation())
 577     {
 578       annotationPanelHolder.setVisible(true);
 579       annotationSpaceFillerHolder.setVisible(true);
 580     }
 581
 582     idSpaceFillerPanel1.setVisible(!wrap);
 583
 584     fontChanged(); // This is so that the scalePanel is resized correctly
 585
 586     validate();
 587     sequenceHolderPanel.validate();
 588     repaint();
 589
 590   }
 591
 592   int hextent = 0;
 593
 594   int vextent = 0;
 595
 596   // return value is true if the scroll is valid
 597   public boolean scrollUp(boolean up)
 598   {
 599     if (up)
 600     {
 601       if (vscroll.getValue() < 1)
 602       {
 603         return false;
 604       }
 605       setScrollValues(hscroll.getValue(), vscroll.getValue() - 1);
 606     }
 607     else
 608     {
 609       if (vextent + vscroll.getValue() >= av.getAlignment().getHeight())
 610       {
 611         return false;
 612       }
 613       setScrollValues(hscroll.getValue(), vscroll.getValue() + 1);
 614     }
 615
 616     repaint();
 617     return true;
 618   }
 619
 620   public boolean scrollRight(boolean right)
 621   {
 622     if (!right)
 623     {
 624       if (hscroll.getValue() < 1)
 625       {
 626         return false;
 627       }
 628       setScrollValues(hscroll.getValue() - 1, vscroll.getValue());
 629     }
 630     else
 631     {
 632       if (hextent + hscroll.getValue() >= av.getAlignment().getWidth())
 633       {
 634         return false;
 635       }
 636       setScrollValues(hscroll.getValue() + 1, vscroll.getValue());
 637     }
 638
 639     repaint();
 640     return true;
 641   }
 642
 643   public void setScrollValues(int x, int y)
 644   {
 645     int width = av.getAlignment().getWidth();
 646     int height = av.getAlignment().getHeight();
 647
 648     if (av.hasHiddenColumns())
 649     {
 650       width = av.getColumnSelection().findColumnPosition(width);
 651     }
 652     if (x < 0)
 653     {
 654       x = 0;
 655     }
 656     ;
 657
 658     hextent = seqPanel.seqCanvas.getSize().width / av.getCharWidth();
 659     vextent = seqPanel.seqCanvas.getSize().height / av.getCharHeight();
 660
 661     if (hextent > width)
 662     {
 663       hextent = width;
 664     }
 665
 666     if (vextent > height)
 667     {
 668       vextent = height;
 669     }
 670
 671     if ((hextent + x) > width)
 672     {
 673       System.err.println("hextent was " + hextent + " and x was " + x);
 674
 675       x = width - hextent;
 676     }
 677
 678     if ((vextent + y) > height)
 679     {
 680       y = height - vextent;
 681     }
 682
 683     if (y < 0)
 684     {
 685       y = 0;
 686     }
 687
 688     if (x < 0)
 689     {
 690       System.err.println("x was " + x);
 691       x = 0;
 692     }
 693
 694     av.setStartSeq(y);
 695
 696     int endSeq = y + vextent;
 697     if (endSeq > av.getAlignment().getHeight())
 698     {
 699       endSeq = av.getAlignment().getHeight();
 700     }
 701
 702     av.setEndSeq(endSeq);
 703     av.setStartRes(x);
 704     av.setEndRes((x + (seqPanel.seqCanvas.getSize().width / av
 705             .getCharWidth())) - 1);
 706
 707     hscroll.setValues(x, hextent, 0, width);
 708     vscroll.setValues(y, vextent, 0, height);
 709
 710     if (overviewPanel != null)
 711     {
 712       overviewPanel.setBoxPosition();
 713     }
 714     sendViewPosition();
 715
 716   }
 717
 718   public void adjustmentValueChanged(AdjustmentEvent evt)
 719   {
 720     int oldX = av.getStartRes();
 721     int oldY = av.getStartSeq();
 722
 723     if (evt == null || evt.getSource() == apvscroll)
 724     {
 725       annotationPanel.setScrollOffset(apvscroll.getValue(), false);
 726       alabels.setScrollOffset(apvscroll.getValue(), false);
 727       // annotationPanel.image=null;
 728       // alabels.image=null;
 729       // alabels.repaint();
 730       // annotationPanel.repaint();
 731     }
 732     if (evt == null || evt.getSource() == hscroll)
 733     {
 734       int x = hscroll.getValue();
 735       av.setStartRes(x);
 736       av.setEndRes(x + seqPanel.seqCanvas.getSize().width
 737               / av.getCharWidth() - 1);
 738     }
 739
 740     if (evt == null || evt.getSource() == vscroll)
 741     {
 742       int offy = vscroll.getValue();
 743       if (av.getWrapAlignment())
 744       {
 745         int rowSize = seqPanel.seqCanvas
 746                 .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 747         av.setStartRes(vscroll.getValue() * rowSize);
 748         av.setEndRes((vscroll.getValue() + 1) * rowSize);
 749       }
 750       else
 751       {
 752         av.setStartSeq(offy);
 753         av.setEndSeq(offy + seqPanel.seqCanvas.getSize().height
 754                 / av.getCharHeight());
 755       }
 756     }
 757
 758     if (overviewPanel != null)
 759     {
 760       overviewPanel.setBoxPosition();
 761     }
 762
 763     int scrollX = av.startRes - oldX;
 764     int scrollY = av.startSeq - oldY;
 765
 766     if (av.getWrapAlignment() || !fastPaint || av.MAC)
 767     {
 768       repaint();
 769     }
 770     else
 771     {
 772       // Make sure we're not trying to draw a panel
 773       // larger than the visible window
 774       if (scrollX > av.endRes - av.startRes)
 775       {
 776         scrollX = av.endRes - av.startRes;
 777       }
 778       else if (scrollX < av.startRes - av.endRes)
 779       {
 780         scrollX = av.startRes - av.endRes;
 781       }
 782
 783       idPanel.idCanvas.fastPaint(scrollY);
 784       seqPanel.seqCanvas.fastPaint(scrollX, scrollY);
 785
 786       scalePanel.repaint();
 787       if (av.isShowAnnotation())
 788       {
 789         annotationPanel.fastPaint(av.getStartRes() - oldX);
 790       }
 791     }
 792     sendViewPosition();
 793
 794   }
 795
 796   private void sendViewPosition()
 797   {
 798     StructureSelectionManager.getStructureSelectionManager(av.applet)
 799             .sendViewPosition(this, av.startRes, av.endRes, av.startSeq,
 800                     av.endSeq);
 801   }
 802
 803   public void paintAlignment(boolean updateOverview)
 804   {
 805     repaint();
 806
 807     if (updateOverview)
 808     {
 809       jalview.structure.StructureSelectionManager
 810               .getStructureSelectionManager(av.applet)
 811               .sequenceColoursChanged(this);
 812
 813       if (overviewPanel != null)
 814       {
 815         overviewPanel.updateOverviewImage();
 816       }
 817     }
 818   }
 819
 820   public void update(Graphics g)
 821   {
 822     paint(g);
 823   }
 824
 825   public void paint(Graphics g)
 826   {
 827     invalidate();
 828     Dimension d = idPanel.idCanvas.getSize();
 829     idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height);
 830
 831     if (av.getWrapAlignment())
 832     {
 833       int maxwidth = av.getAlignment().getWidth();
 834
 835       if (av.hasHiddenColumns())
 836       {
 837         maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
 838       }
 839
 840       int canvasWidth = seqPanel.seqCanvas
 841               .getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width);
 842
 843       if (canvasWidth > 0)
 844       {
 845         int max = maxwidth / canvasWidth;
 846         vscroll.setMaximum(1 + max);
 847         vscroll.setUnitIncrement(1);
 848         vscroll.setVisibleAmount(1);
 849       }
 850     }
 851     else
 852     {
 853       setScrollValues(av.getStartRes(), av.getStartSeq());
 854     }
 855
 856     seqPanel.seqCanvas.repaint();
 857     idPanel.idCanvas.repaint();
 858     if (!av.getWrapAlignment())
 859     {
 860       if (av.isShowAnnotation())
 861       {
 862         alabels.repaint();
 863         annotationPanel.repaint();
 864       }
 865       scalePanel.repaint();
 866     }
 867
 868   }
 869
 870   protected Panel sequenceHolderPanel = new Panel();
 871
 872   protected Scrollbar vscroll = new Scrollbar();
 873
 874   protected Scrollbar hscroll = new Scrollbar();
 875
 876   protected Panel seqPanelHolder = new Panel();
 877
 878   BorderLayout borderLayout1 = new BorderLayout();
 879
 880   BorderLayout borderLayout3 = new BorderLayout();
 881
 882   protected Panel scalePanelHolder = new Panel();
 883
 884   protected Panel idPanelHolder = new Panel();
 885
 886   BorderLayout borderLayout5 = new BorderLayout();
 887
 888   protected Panel idSpaceFillerPanel1 = new Panel();
 889
 890   public Panel annotationSpaceFillerHolder = new Panel();
 891
 892   BorderLayout borderLayout6 = new BorderLayout();
 893
 894   BorderLayout borderLayout7 = new BorderLayout();
 895
 896   Panel hscrollHolder = new Panel();
 897
 898   BorderLayout borderLayout10 = new BorderLayout();
 899
 900   protected Panel hscrollFillerPanel = new Panel();
 901
 902   BorderLayout borderLayout11 = new BorderLayout();
 903
 904   BorderLayout borderLayout4 = new BorderLayout();
 905
 906   BorderLayout borderLayout2 = new BorderLayout();
 907
 908   Panel annotationPanelHolder = new Panel();
 909
 910   protected Scrollbar apvscroll = new Scrollbar();
 911
 912   BorderLayout borderLayout12 = new BorderLayout();
 913
 914   private void jbInit() throws Exception
 915   {
 916     // idPanelHolder.setPreferredSize(new Dimension(70, 10));
 917     this.setLayout(borderLayout7);
 918
 919     // sequenceHolderPanel.setPreferredSize(new Dimension(150, 150));
 920     sequenceHolderPanel.setLayout(borderLayout3);
 921     seqPanelHolder.setLayout(borderLayout1);
 922     scalePanelHolder.setBackground(Color.white);
 923
 924     // scalePanelHolder.setPreferredSize(new Dimension(10, 30));
 925     scalePanelHolder.setLayout(borderLayout6);
 926     idPanelHolder.setLayout(borderLayout5);
 927     idSpaceFillerPanel1.setBackground(Color.white);
 928
 929     // idSpaceFillerPanel1.setPreferredSize(new Dimension(10, 30));
 930     idSpaceFillerPanel1.setLayout(borderLayout11);
 931     annotationSpaceFillerHolder.setBackground(Color.white);
 932
 933     // annotationSpaceFillerHolder.setPreferredSize(new Dimension(10, 80));
 934     annotationSpaceFillerHolder.setLayout(borderLayout4);
 935     hscroll.setOrientation(Scrollbar.HORIZONTAL);
 936     hscrollHolder.setLayout(borderLayout10);
 937     hscrollFillerPanel.setBackground(Color.white);
 938     apvscroll.setOrientation(Scrollbar.VERTICAL);
 939     apvscroll.setVisible(true);
 940     apvscroll.addAdjustmentListener(this);
 941
 942     annotationPanelHolder.setBackground(Color.white);
 943     annotationPanelHolder.setLayout(borderLayout12);
 944     annotationPanelHolder.add(apvscroll, BorderLayout.EAST);
 945     // hscrollFillerPanel.setPreferredSize(new Dimension(70, 10));
 946     hscrollHolder.setBackground(Color.white);
 947
 948     // annotationScroller.setPreferredSize(new Dimension(10, 80));
 949     // this.setPreferredSize(new Dimension(220, 166));
 950     seqPanelHolder.setBackground(Color.white);
 951     idPanelHolder.setBackground(Color.white);
 952     sequenceHolderPanel.add(scalePanelHolder, BorderLayout.NORTH);
 953     sequenceHolderPanel.add(seqPanelHolder, BorderLayout.CENTER);
 954     seqPanelHolder.add(vscroll, BorderLayout.EAST);
 955
 956     // Panel3.add(secondaryPanelHolder, BorderLayout.SOUTH);
 957     this.add(idPanelHolder, BorderLayout.WEST);
 958     idPanelHolder.add(idSpaceFillerPanel1, BorderLayout.NORTH);
 959     idPanelHolder.add(annotationSpaceFillerHolder, BorderLayout.SOUTH);
 960     this.add(hscrollHolder, BorderLayout.SOUTH);
 961     hscrollHolder.add(hscroll, BorderLayout.CENTER);
 962     hscrollHolder.add(hscrollFillerPanel, BorderLayout.WEST);
 963     this.add(sequenceHolderPanel, BorderLayout.CENTER);
 964   }
 965
 966   /**
 967    * hides or shows dynamic annotation rows based on groups and av state flags
 968    */
 969   public void updateAnnotation()
 970   {
 971     updateAnnotation(false);
 972   }
 973
 974   public void updateAnnotation(boolean applyGlobalSettings)
 975   {
 976     updateAnnotation(applyGlobalSettings, false);
 977   }
 978
 979   public void updateAnnotation(boolean applyGlobalSettings,
 980           boolean preserveNewGroupSettings)
 981   {
 982     av.updateGroupAnnotationSettings(applyGlobalSettings,
 983             preserveNewGroupSettings);
 984     adjustAnnotationHeight();
 985   }
 986
 987   @Override
 988   public AlignmentI getAlignment()
 989   {
 990     return av.getAlignment();
 991   }
 992
 993   @Override
 994   public String getViewName()
 995   {
 996     return getName();
 997   }
 998
 999   @Override
1000   public StructureSelectionManager getStructureSelectionManager()
1001   {
1002     return StructureSelectionManager
1003             .getStructureSelectionManager(av.applet);
1004   }
1005
1006   @Override
1007   public void raiseOOMWarning(String string, OutOfMemoryError error)
1008   {
1009     // TODO: JAL-960
1010     System.err.println("Out of memory whilst '" + string + "'");
1011     error.printStackTrace();
1012   }
1013
1014 }