src/jalview/appletgui/AlignmentPanel.java

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