src/jalview/gui/AlignmentPanel.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ 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.gui;
  22
  23 import jalview.analysis.AnnotationSorter;
  24 import jalview.api.AlignViewportI;
  25 import jalview.api.AlignmentViewPanel;
  26 import jalview.bin.Cache;
  27 import jalview.datamodel.AlignmentI;
  28 import jalview.datamodel.SearchResultsI;
  29 import jalview.datamodel.SequenceFeature;
  30 import jalview.datamodel.SequenceGroup;
  31 import jalview.datamodel.SequenceI;
  32 import jalview.jbgui.GAlignmentPanel;
  33 import jalview.math.AlignmentDimension;
  34 import jalview.schemes.ResidueProperties;
  35 import jalview.structure.StructureSelectionManager;
  36 import jalview.util.MessageManager;
  37 import jalview.util.Platform;
  38 import jalview.viewmodel.ViewportListenerI;
  39 import jalview.viewmodel.ViewportRanges;
  40
  41 import java.awt.BorderLayout;
  42 import java.awt.Color;
  43 import java.awt.Container;
  44 import java.awt.Dimension;
  45 import java.awt.Font;
  46 import java.awt.FontMetrics;
  47 import java.awt.Graphics;
  48 import java.awt.Insets;
  49 import java.awt.event.AdjustmentEvent;
  50 import java.awt.event.AdjustmentListener;
  51 import java.awt.event.ComponentAdapter;
  52 import java.awt.event.ComponentEvent;
  53 import java.awt.print.PageFormat;
  54 import java.awt.print.Printable;
  55 import java.awt.print.PrinterException;
  56 import java.beans.PropertyChangeEvent;
  57 import java.beans.PropertyChangeListener;
  58 import java.io.File;
  59 import java.io.FileWriter;
  60 import java.io.PrintWriter;
  61 import java.util.List;
  62
  63 import javax.swing.SwingUtilities;
  64
  65 /**
  66  * DOCUMENT ME!
  67  *
  68  * @author $author$
  69  * @version $Revision: 1.161 $
  70  */
  71 public class AlignmentPanel extends GAlignmentPanel implements
  72         AdjustmentListener, Printable, AlignmentViewPanel,
  73         ViewportListenerI
  74 {
  75   public AlignViewport av;
  76
  77   ViewportRanges vpRanges;
  78
  79   OverviewPanel overviewPanel;
  80
  81   private SeqPanel seqPanel;
  82
  83   private IdPanel idPanel;
  84
  85   private boolean headless;
  86
  87   IdwidthAdjuster idwidthAdjuster;
  88
  89   /** DOCUMENT ME!! */
  90   public AlignFrame alignFrame;
  91
  92   private ScalePanel scalePanel;
  93
  94   private AnnotationPanel annotationPanel;
  95
  96   private AnnotationLabels alabels;
  97
  98   // this value is set false when selection area being dragged
  99   boolean fastPaint = true;
 100
 101   private int hextent = 0;
 102
 103   private int vextent = 0;
 104
 105   /*
 106    * Flag set while scrolling to follow complementary cDNA/protein scroll. When
 107    * true, suppresses invoking the same method recursively.
 108    */
 109   private boolean dontScrollComplement;
 110
 111   private PropertyChangeListener propertyChangeListener;
 112
 113   /**
 114    * Creates a new AlignmentPanel object.
 115    *
 116    * @param af
 117    * @param av
 118    */
 119   public AlignmentPanel(AlignFrame af, final AlignViewport av)
 120   {
 121     alignFrame = af;
 122     this.av = av;
 123     vpRanges = av.getRanges();
 124     setSeqPanel(new SeqPanel(av, this));
 125     setIdPanel(new IdPanel(av, this));
 126
 127     setScalePanel(new ScalePanel(av, this));
 128
 129     idPanelHolder.add(getIdPanel(), BorderLayout.CENTER);
 130     idwidthAdjuster = new IdwidthAdjuster(this);
 131     idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);
 132
 133     setAnnotationPanel(new AnnotationPanel(this));
 134     setAlabels(new AnnotationLabels(this));
 135
 136     annotationScroller.setViewportView(getAnnotationPanel());
 137     annotationSpaceFillerHolder.add(getAlabels(), BorderLayout.CENTER);
 138
 139     scalePanelHolder.add(getScalePanel(), BorderLayout.CENTER);
 140     seqPanelHolder.add(getSeqPanel(), BorderLayout.CENTER);
 141
 142     setScrollValues(0, 0);
 143
 144     hscroll.addAdjustmentListener(this);
 145     vscroll.addAdjustmentListener(this);
 146
 147     addComponentListener(new ComponentAdapter()
 148     {
 149       @Override
 150       public void componentResized(ComponentEvent evt)
 151       {
 152         // reset the viewport ranges when the alignment panel is resized
 153         // in particular, this initialises the end residue value when Jalview
 154         // is initialised
 155         if (av.getWrapAlignment())
 156         {
 157           int widthInRes = getSeqPanel().seqCanvas
 158                   .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
 159           vpRanges.setViewportWidth(widthInRes);
 160         }
 161         else
 162         {
 163           int widthInRes = getSeqPanel().seqCanvas.getWidth()
 164                   / av.getCharWidth();
 165           int heightInSeq = getSeqPanel().seqCanvas.getHeight()
 166                   / av.getCharHeight();
 167
 168           vpRanges.setViewportWidth(widthInRes);
 169           vpRanges.setViewportHeight(heightInSeq);
 170         }
 171       }
 172
 173     });
 174
 175     final AlignmentPanel ap = this;
 176     propertyChangeListener = new PropertyChangeListener()
 177     {
 178       @Override
 179       public void propertyChange(PropertyChangeEvent evt)
 180       {
 181         if (evt.getPropertyName().equals("alignment"))
 182         {
 183           PaintRefresher.Refresh(ap, av.getSequenceSetId(), true, true);
 184           alignmentChanged();
 185         }
 186       }
 187     };
 188     av.addPropertyChangeListener(propertyChangeListener);
 189
 190     av.getRanges().addPropertyChangeListener(this);
 191     fontChanged();
 192     adjustAnnotationHeight();
 193     updateLayout();
 194   }
 195
 196   @Override
 197   public AlignViewportI getAlignViewport()
 198   {
 199     return av;
 200   }
 201
 202   public void alignmentChanged()
 203   {
 204     av.alignmentChanged(this);
 205
 206     alignFrame.updateEditMenuBar();
 207
 208     paintAlignment(true);
 209
 210   }
 211
 212   /**
 213    * DOCUMENT ME!
 214    */
 215   public void fontChanged()
 216   {
 217     // set idCanvas bufferedImage to null
 218     // to prevent drawing old image
 219     FontMetrics fm = getFontMetrics(av.getFont());
 220
 221     scalePanelHolder.setPreferredSize(new Dimension(10, av.getCharHeight()
 222             + fm.getDescent()));
 223     idSpaceFillerPanel1.setPreferredSize(new Dimension(10, av
 224             .getCharHeight() + fm.getDescent()));
 225
 226     getIdPanel().getIdCanvas().gg = null;
 227     getSeqPanel().seqCanvas.img = null;
 228     getAnnotationPanel().adjustPanelHeight();
 229
 230     Dimension d = calculateIdWidth();
 231
 232     d.setSize(d.width + 4, d.height);
 233     getIdPanel().getIdCanvas().setPreferredSize(d);
 234     hscrollFillerPanel.setPreferredSize(d);
 235
 236     if (this.alignFrame.getSplitViewContainer() != null)
 237     {
 238       ((SplitFrame) this.alignFrame.getSplitViewContainer()).adjustLayout();
 239     }
 240
 241     repaint();
 242   }
 243
 244   /**
 245    * Calculate the width of the alignment labels based on the displayed names
 246    * and any bounds on label width set in preferences.
 247    *
 248    * @return Dimension giving the maximum width of the alignment label panel
 249    *         that should be used.
 250    */
 251   public Dimension calculateIdWidth()
 252   {
 253     // calculate sensible default width when no preference is available
 254     Dimension r = null;
 255     if (av.getIdWidth() < 0)
 256     {
 257       int afwidth = (alignFrame != null ? alignFrame.getWidth() : 300);
 258       int maxwidth = Math.max(20, Math.min(afwidth - 200, 2 * afwidth / 3));
 259       r = calculateIdWidth(maxwidth);
 260       av.setIdWidth(r.width);
 261     }
 262     else
 263     {
 264       r = new Dimension();
 265       r.width = av.getIdWidth();
 266       r.height = 0;
 267     }
 268     return r;
 269   }
 270
 271   /**
 272    * Calculate the width of the alignment labels based on the displayed names
 273    * and any bounds on label width set in preferences.
 274    *
 275    * @param maxwidth
 276    *          -1 or maximum width allowed for IdWidth
 277    * @return Dimension giving the maximum width of the alignment label panel
 278    *         that should be used.
 279    */
 280   public Dimension calculateIdWidth(int maxwidth)
 281   {
 282     Container c = new Container();
 283
 284     FontMetrics fm = c.getFontMetrics(new Font(av.font.getName(),
 285             Font.ITALIC, av.font.getSize()));
 286
 287     AlignmentI al = av.getAlignment();
 288     int i = 0;
 289     int idWidth = 0;
 290     String id;
 291
 292     while ((i < al.getHeight()) && (al.getSequenceAt(i) != null))
 293     {
 294       SequenceI s = al.getSequenceAt(i);
 295
 296       id = s.getDisplayId(av.getShowJVSuffix());
 297
 298       if (fm.stringWidth(id) > idWidth)
 299       {
 300         idWidth = fm.stringWidth(id);
 301       }
 302
 303       i++;
 304     }
 305
 306     // Also check annotation label widths
 307     i = 0;
 308
 309     if (al.getAlignmentAnnotation() != null)
 310     {
 311       fm = c.getFontMetrics(getAlabels().getFont());
 312
 313       while (i < al.getAlignmentAnnotation().length)
 314       {
 315         String label = al.getAlignmentAnnotation()[i].label;
 316
 317         if (fm.stringWidth(label) > idWidth)
 318         {
 319           idWidth = fm.stringWidth(label);
 320         }
 321
 322         i++;
 323       }
 324     }
 325
 326     return new Dimension(maxwidth < 0 ? idWidth : Math.min(maxwidth,
 327             idWidth), 12);
 328   }
 329
 330   /**
 331    * Highlight the given results on the alignment.
 332    *
 333    */
 334   public void highlightSearchResults(SearchResultsI results)
 335   {
 336     scrollToPosition(results);
 337     getSeqPanel().seqCanvas.highlightSearchResults(results);
 338   }
 339
 340   /**
 341    * Scroll the view to show the position of the highlighted region in results
 342    * (if any) and redraw the overview
 343    *
 344    * @param results
 345    */
 346   public boolean scrollToPosition(SearchResultsI results)
 347   {
 348     return scrollToPosition(results, 0, true, false);
 349   }
 350
 351   /**
 352    * Scroll the view to show the position of the highlighted region in results
 353    * (if any)
 354    *
 355    * @param searchResults
 356    * @param redrawOverview
 357    * @return
 358    */
 359   public boolean scrollToPosition(SearchResultsI searchResults,
 360           boolean redrawOverview)
 361   {
 362     return scrollToPosition(searchResults, 0, redrawOverview, false);
 363   }
 364
 365   /**
 366    * Scroll the view to show the position of the highlighted region in results
 367    * (if any)
 368    *
 369    * @param results
 370    * @param verticalOffset
 371    *          if greater than zero, allows scrolling to a position below the
 372    *          first displayed sequence
 373    * @param redrawOverview
 374    *          - when set, the overview will be recalculated (takes longer)
 375    * @param centre
 376    *          if true, try to centre the search results horizontally in the view
 377    * @return false if results were not found
 378    */
 379   public boolean scrollToPosition(SearchResultsI results,
 380           int verticalOffset, boolean redrawOverview, boolean centre)
 381   {
 382     int startv, endv, starts, ends;
 383     // TODO: properly locate search results in view when large numbers of hidden
 384     // columns exist before highlighted region
 385     // do we need to scroll the panel?
 386     // TODO: tons of nullpointerexceptions raised here.
 387     if (results != null && results.getSize() > 0 && av != null
 388             && av.getAlignment() != null)
 389     {
 390       int seqIndex = av.getAlignment().findIndex(results);
 391       if (seqIndex == -1)
 392       {
 393         return false;
 394       }
 395       SequenceI seq = av.getAlignment().getSequenceAt(seqIndex);
 396
 397       int[] r = results.getResults(seq, 0, av.getAlignment().getWidth());
 398       if (r == null)
 399       {
 400         return false;
 401       }
 402       int start = r[0];
 403       int end = r[1];
 404       // DEBUG
 405       // System.err.println(this.av.viewName + " Seq : " + seqIndex
 406       // + " Scroll to " + start + "," + end);
 407
 408       /*
 409        * To centre results, scroll to positions half the visible width
 410        * left/right of the start/end positions
 411        */
 412       if (centre)
 413       {
 414         int offset = (vpRanges.getEndRes() - vpRanges.getStartRes() + 1) / 2 - 1;
 415         start = Math.max(start - offset, 0);
 416         end = end + offset - 1;
 417       }
 418       if (start < 0)
 419       {
 420         return false;
 421       }
 422       if (end == seq.getEnd())
 423       {
 424         return false;
 425       }
 426       if (av.hasHiddenColumns())
 427       {
 428         start = av.getColumnSelection().findColumnPosition(start);
 429         end = av.getColumnSelection().findColumnPosition(end);
 430         if (start == end)
 431         {
 432           if (!av.getColumnSelection().isVisible(r[0]))
 433           {
 434             // don't scroll - position isn't visible
 435             return false;
 436           }
 437         }
 438       }
 439
 440       /*
 441        * allow for offset of target sequence (actually scroll to one above it)
 442        */
 443       seqIndex = Math.max(0, seqIndex - verticalOffset);
 444
 445       // System.out.println("start=" + start + ", end=" + end + ", startv="
 446       // + av.getStartRes() + ", endv=" + av.getEndRes() + ", starts="
 447       // + av.getStartSeq() + ", ends=" + av.getEndSeq());
 448       if (!av.getWrapAlignment())
 449       {
 450         if ((startv = vpRanges.getStartRes()) >= start)
 451         {
 452           /*
 453            * Scroll left to make start of search results visible
 454            */
 455           // setScrollValues(start - 1, seqIndex); // plus one residue
 456           setScrollValues(start, seqIndex);
 457         }
 458         else if ((endv = vpRanges.getEndRes()) <= end)
 459         {
 460           /*
 461            * Scroll right to make end of search results visible
 462            */
 463           // setScrollValues(startv + 1 + end - endv, seqIndex); // plus one
 464           setScrollValues(startv + end - endv, seqIndex);
 465         }
 466         else if ((starts = vpRanges.getStartSeq()) > seqIndex)
 467         {
 468           /*
 469            * Scroll up to make start of search results visible
 470            */
 471           setScrollValues(vpRanges.getStartRes(), seqIndex);
 472         }
 473         else if ((ends = vpRanges.getEndSeq()) <= seqIndex)
 474         {
 475           /*
 476            * Scroll down to make end of search results visible
 477            */
 478           setScrollValues(vpRanges.getStartRes(), starts + seqIndex - ends
 479                   + 1);
 480         }
 481         /*
 482          * Else results are already visible - no need to scroll
 483          */
 484       }
 485       else
 486       {
 487         vpRanges.scrollToWrappedVisible(start);
 488       }
 489     }
 490
 491     paintAlignment(redrawOverview);
 492     return true;
 493   }
 494
 495   /**
 496    * DOCUMENT ME!
 497    *
 498    * @return DOCUMENT ME!
 499    */
 500   public OverviewPanel getOverviewPanel()
 501   {
 502     return overviewPanel;
 503   }
 504
 505   /**
 506    * DOCUMENT ME!
 507    *
 508    * @param op
 509    *          DOCUMENT ME!
 510    */
 511   public void setOverviewPanel(OverviewPanel op)
 512   {
 513     overviewPanel = op;
 514   }
 515
 516   /**
 517    *
 518    * @param b
 519    *          Hide or show annotation panel
 520    *
 521    */
 522   public void setAnnotationVisible(boolean b)
 523   {
 524     if (!av.getWrapAlignment())
 525     {
 526       annotationSpaceFillerHolder.setVisible(b);
 527       annotationScroller.setVisible(b);
 528     }
 529     repaint();
 530   }
 531
 532   /**
 533    * automatically adjust annotation panel height for new annotation whilst
 534    * ensuring the alignment is still visible.
 535    */
 536   @Override
 537   public void adjustAnnotationHeight()
 538   {
 539     // TODO: display vertical annotation scrollbar if necessary
 540     // this is called after loading new annotation onto alignment
 541     if (alignFrame.getHeight() == 0)
 542     {
 543       System.out.println("NEEDS FIXING");
 544     }
 545     validateAnnotationDimensions(true);
 546     addNotify();
 547     paintAlignment(true);
 548   }
 549
 550   /**
 551    * calculate the annotation dimensions and refresh slider values accordingly.
 552    * need to do repaints/notifys afterwards.
 553    */
 554   protected void validateAnnotationDimensions(boolean adjustPanelHeight)
 555   {
 556     int annotationHeight = getAnnotationPanel().adjustPanelHeight();
 557
 558     if (adjustPanelHeight)
 559     {
 560       int rowHeight = av.getCharHeight();
 561       int alignmentHeight = rowHeight * av.getAlignment().getHeight();
 562
 563       /*
 564        * Estimate available height in the AlignFrame for alignment +
 565        * annotations. Deduct an estimate for title bar, menu bar, scale panel,
 566        * hscroll, status bar (as these are not laid out we can't inspect their
 567        * actual heights). Insets gives frame borders.
 568        */
 569       int stuff = Platform.isAMac() ? 80 : 100;
 570       Insets insets = alignFrame.getInsets();
 571       int availableHeight = alignFrame.getHeight() - stuff - insets.top
 572               - insets.bottom;
 573
 574       /*
 575        * If not enough vertical space, maximize annotation height while keeping
 576        * at least two rows of alignment visible
 577        */
 578       if (annotationHeight + alignmentHeight > availableHeight)
 579       {
 580         annotationHeight = Math.min(annotationHeight, availableHeight - 2
 581                 * rowHeight);
 582       }
 583     }
 584     else
 585     {
 586       // maintain same window layout whilst updating sliders
 587       annotationHeight = annotationScroller.getSize().height;
 588     }
 589     hscroll.addNotify();
 590
 591     annotationScroller.setPreferredSize(new Dimension(annotationScroller
 592             .getWidth(), annotationHeight));
 593
 594     Dimension e = idPanel.getSize();
 595     alabels.setSize(new Dimension(e.width, annotationHeight));
 596
 597     annotationSpaceFillerHolder.setPreferredSize(new Dimension(
 598             annotationSpaceFillerHolder.getWidth(), annotationHeight));
 599     annotationScroller.validate();
 600     annotationScroller.addNotify();
 601   }
 602
 603   /**
 604    * update alignment layout for viewport settings
 605    *
 606    * @param wrap
 607    *          DOCUMENT ME!
 608    */
 609   public void updateLayout()
 610   {
 611     fontChanged();
 612     setAnnotationVisible(av.isShowAnnotation());
 613     boolean wrap = av.getWrapAlignment();
 614     vpRanges.setStartSeq(0);
 615     scalePanelHolder.setVisible(!wrap);
 616     hscroll.setVisible(!wrap);
 617     idwidthAdjuster.setVisible(!wrap);
 618
 619     if (wrap)
 620     {
 621       annotationScroller.setVisible(false);
 622       annotationSpaceFillerHolder.setVisible(false);
 623     }
 624     else if (av.isShowAnnotation())
 625     {
 626       annotationScroller.setVisible(true);
 627       annotationSpaceFillerHolder.setVisible(true);
 628     }
 629
 630     if (wrap)
 631     {
 632       int widthInRes = getSeqPanel().seqCanvas
 633               .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
 634       vpRanges.setViewportWidth(widthInRes);
 635     }
 636     else
 637     {
 638       int widthInRes = (getSeqPanel().seqCanvas.getWidth() / av
 639               .getCharWidth()) - 1;
 640       int heightInSeq = (getSeqPanel().seqCanvas.getHeight() / av
 641               .getCharHeight()) - 1;
 642
 643       vpRanges.setViewportWidth(widthInRes);
 644       vpRanges.setViewportHeight(heightInSeq);
 645     }
 646
 647     idSpaceFillerPanel1.setVisible(!wrap);
 648
 649     repaint();
 650   }
 651
 652
 653   /**
 654    * Adjust row/column scrollers to show a visible position in the alignment.
 655    *
 656    * @param x
 657    *          visible column to scroll to
 658    * @param y
 659    *          visible row to scroll to
 660    *
 661    */
 662   public void setScrollValues(int x, int y)
 663   {
 664     if (av == null || av.getAlignment() == null)
 665     {
 666       return;
 667     }
 668
 669     if (av.getWrapAlignment())
 670     {
 671       setScrollingForWrappedPanel(x);
 672     }
 673     else
 674     {
 675
 676       int width = av.getAlignment().getWidth();
 677       int height = av.getAlignment().getHeight();
 678
 679       if (av.hasHiddenColumns())
 680       {
 681         // reset the width to exclude hidden columns
 682         width = av.getColumnSelection().findColumnPosition(width);
 683       }
 684
 685       hextent = getSeqPanel().seqCanvas.getWidth() / av.getCharWidth();
 686       vextent = getSeqPanel().seqCanvas.getHeight() / av.getCharHeight();
 687
 688       if (hextent > width)
 689       {
 690         hextent = width;
 691       }
 692
 693       if (vextent > height)
 694       {
 695         vextent = height;
 696       }
 697
 698       if ((hextent + x) > width)
 699       {
 700         x = width - hextent;
 701       }
 702
 703       if ((vextent + y) > height)
 704       {
 705         y = height - vextent;
 706       }
 707
 708       if (y < 0)
 709       {
 710         y = 0;
 711       }
 712
 713       if (x < 0)
 714       {
 715         x = 0;
 716       }
 717
 718       // update the scroll values
 719       hscroll.setValues(x, hextent, 0, width);
 720       vscroll.setValues(y, vextent, 0, height);
 721     }
 722   }
 723
 724   /**
 725    * DOCUMENT ME!
 726    *
 727    * @param evt
 728    *          DOCUMENT ME!
 729    */
 730   @Override
 731   public void adjustmentValueChanged(AdjustmentEvent evt)
 732   {
 733     int oldX = vpRanges.getStartRes();
 734     int oldwidth = vpRanges.getViewportWidth();
 735     int oldY = vpRanges.getStartSeq();
 736     int oldheight = vpRanges.getViewportHeight();
 737
 738     if (av.getWrapAlignment())
 739     {
 740       if (evt.getSource() == hscroll)
 741       {
 742         return; // no horizontal scroll when wrapped
 743       }
 744       else if (evt.getSource() == vscroll)
 745       {
 746         int offy = vscroll.getValue();
 747         int rowSize = getSeqPanel().seqCanvas
 748                 .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
 749
 750         // if we're scrolling to the position we're already at, stop
 751         // this prevents infinite recursion of events when the scroll/viewport
 752         // ranges values are the same
 753         if ((offy * rowSize == oldX) && (oldwidth == rowSize))
 754         {
 755           return;
 756         }
 757         else if (offy > -1)
 758         {
 759           vpRanges.setViewportStartAndWidth(offy * rowSize, rowSize);
 760         }
 761         else
 762         {
 763           // This is only called if file loaded is a jar file that
 764           // was wrapped when saved and user has wrap alignment true
 765           // as preference setting
 766           SwingUtilities.invokeLater(new Runnable()
 767           {
 768             @Override
 769             public void run()
 770             {
 771               setScrollValues(vpRanges.getStartRes(),
 772                       vpRanges.getStartSeq());
 773             }
 774           });
 775         }
 776       }
 777       repaint();
 778     }
 779     else
 780     {
 781       // horizontal scroll
 782       if (evt.getSource() == hscroll)
 783       {
 784         int x = hscroll.getValue();
 785         int width = getSeqPanel().seqCanvas.getWidth() / av.getCharWidth();
 786
 787         // if we're scrolling to the position we're already at, stop
 788         // this prevents infinite recursion of events when the scroll/viewport
 789         // ranges values are the same
 790         if ((x == oldX) && (width == oldwidth))
 791         {
 792           return;
 793         }
 794         vpRanges.setViewportStartAndWidth(x, width);
 795       }
 796       else if (evt.getSource() == vscroll)
 797       {
 798         int y = vscroll.getValue();
 799         int height = getSeqPanel().seqCanvas.getHeight()
 800                 / av.getCharHeight();
 801
 802         // if we're scrolling to the position we're already at, stop
 803         // this prevents infinite recursion of events when the scroll/viewport
 804         // ranges values are the same
 805         if ((y == oldY) && (height == oldheight))
 806         {
 807           return;
 808         }
 809         vpRanges.setViewportStartAndHeight(y, height);
 810       }
 811       if (!fastPaint)
 812       {
 813         repaint();
 814       }
 815     }
 816   }
 817
 818   /**
 819    * Repaint the alignment including the annotations and overview panels (if
 820    * shown).
 821    */
 822   @Override
 823   public void paintAlignment(boolean updateOverview)
 824   {
 825     final AnnotationSorter sorter = new AnnotationSorter(getAlignment(),
 826             av.isShowAutocalculatedAbove());
 827     sorter.sort(getAlignment().getAlignmentAnnotation(),
 828             av.getSortAnnotationsBy());
 829     repaint();
 830
 831     if (updateOverview)
 832     {
 833       // TODO: determine if this paintAlignment changed structure colours
 834       av.getStructureSelectionManager().sequenceColoursChanged(this);
 835
 836       if (overviewPanel != null)
 837       {
 838         overviewPanel.updateOverviewImage();
 839       }
 840     }
 841   }
 842
 843   /**
 844    * DOCUMENT ME!
 845    *
 846    * @param g
 847    *          DOCUMENT ME!
 848    */
 849   @Override
 850   public void paintComponent(Graphics g)
 851   {
 852     invalidate();
 853
 854     Dimension d = getIdPanel().getIdCanvas().getPreferredSize();
 855     idPanelHolder.setPreferredSize(d);
 856     hscrollFillerPanel.setPreferredSize(new Dimension(d.width, 12));
 857     validate();
 858
 859     /*
 860      * set scroll bar positions
 861      */
 862     setScrollValues(vpRanges.getStartRes(), vpRanges.getStartSeq());
 863   }
 864
 865   /*
 866    * Set vertical scroll bar parameters for wrapped panel
 867    * @param res
 868    *    the residue to scroll to
 869    */
 870   private void setScrollingForWrappedPanel(int res)
 871   {
 872     // get the width of the alignment in residues
 873     int maxwidth = av.getAlignment().getWidth();
 874     if (av.hasHiddenColumns())
 875     {
 876       maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
 877     }
 878
 879     // get the width of the canvas in residues
 880     int canvasWidth = getSeqPanel().seqCanvas
 881             .getWrappedCanvasWidth(getSeqPanel().seqCanvas.getWidth());
 882     if (canvasWidth > 0)
 883     {
 884       // position we want to scroll to is number of canvasWidth's to get there
 885       int current = res / canvasWidth;
 886
 887       // max scroll position: add one because extent is 1 and scrollbar value
 888       // can only be set to at most max - extent
 889       int max = maxwidth / canvasWidth + 1;
 890       vscroll.setUnitIncrement(1);
 891       vscroll.setValues(current, 1, 0, max);
 892     }
 893   }
 894
 895   /**
 896    * DOCUMENT ME!
 897    *
 898    * @param pg
 899    *          DOCUMENT ME!
 900    * @param pf
 901    *          DOCUMENT ME!
 902    * @param pi
 903    *          DOCUMENT ME!
 904    *
 905    * @return DOCUMENT ME!
 906    *
 907    * @throws PrinterException
 908    *           DOCUMENT ME!
 909    */
 910   @Override
 911   public int print(Graphics pg, PageFormat pf, int pi)
 912           throws PrinterException
 913   {
 914     pg.translate((int) pf.getImageableX(), (int) pf.getImageableY());
 915
 916     int pwidth = (int) pf.getImageableWidth();
 917     int pheight = (int) pf.getImageableHeight();
 918
 919     if (av.getWrapAlignment())
 920     {
 921       return printWrappedAlignment(pwidth, pheight, pi, pg);
 922     }
 923     else
 924     {
 925       return printUnwrapped(pwidth, pheight, pi, pg, pg);
 926     }
 927   }
 928
 929   /**
 930    * DOCUMENT ME!
 931    *
 932    * @param pg
 933    *          DOCUMENT ME!
 934    * @param pwidth
 935    *          DOCUMENT ME!
 936    * @param pheight
 937    *          DOCUMENT ME!
 938    * @param pi
 939    *          DOCUMENT ME!
 940    *
 941    * @return DOCUMENT ME!
 942    *
 943    * @throws PrinterException
 944    *           DOCUMENT ME!
 945    */
 946   /**
 947    * Draws the alignment image, including sequence ids, sequences, and
 948    * annotation labels and annotations if shown, on either one or two Graphics
 949    * context.
 950    *
 951    * @param pageWidth
 952    * @param pageHeight
 953    * @param pi
 954    * @param idGraphics
 955    *          the graphics context for sequence ids and annotation labels
 956    * @param alignmentGraphics
 957    *          the graphics context for sequences and annotations (may or may not
 958    *          be the same context as idGraphics)
 959    * @return
 960    * @throws PrinterException
 961    */
 962   public int printUnwrapped(int pageWidth, int pageHeight, int pi,
 963           Graphics idGraphics, Graphics alignmentGraphics)
 964           throws PrinterException
 965   {
 966     final int idWidth = getVisibleIdWidth(false);
 967
 968     /*
 969      * Get the horizontal offset to where we draw the sequences.
 970      * This is idWidth if using a single Graphics context, else zero.
 971      */
 972     final int alignmentGraphicsOffset = idGraphics != alignmentGraphics ? 0 : idWidth;
 973
 974     FontMetrics fm = getFontMetrics(av.getFont());
 975     int charHeight = av.getCharHeight();
 976     int scaleHeight = charHeight + fm.getDescent();
 977
 978     idGraphics.setColor(Color.white);
 979     idGraphics.fillRect(0, 0, pageWidth, pageHeight);
 980     idGraphics.setFont(av.getFont());
 981
 982     /*
 983      * How many sequences and residues can we fit on a printable page?
 984      */
 985     int totalRes = (pageWidth - idWidth) / av.getCharWidth();
 986
 987     int totalSeq = (pageHeight - scaleHeight) / charHeight - 1;
 988
 989     int alignmentWidth = av.getAlignment().getWidth();
 990     int pagesWide = (alignmentWidth / totalRes) + 1;
 991
 992     final int startRes = (pi % pagesWide) * totalRes;
 993     int endRes = (startRes + totalRes) - 1;
 994
 995     if (endRes > (alignmentWidth - 1))
 996     {
 997       endRes = alignmentWidth - 1;
 998     }
 999
1000     final int startSeq = (pi / pagesWide) * totalSeq;
1001     int endSeq = startSeq + totalSeq;
1002
1003     int alignmentHeight = av.getAlignment().getHeight();
1004     if (endSeq > alignmentHeight)
1005     {
1006       endSeq = alignmentHeight;
1007     }
1008
1009     int pagesHigh = ((alignmentHeight / totalSeq) + 1)
1010             * pageHeight;
1011
1012     if (av.isShowAnnotation())
1013     {
1014       pagesHigh += getAnnotationPanel().adjustPanelHeight() + 3;
1015     }
1016
1017     pagesHigh /= pageHeight;
1018
1019     if (pi >= (pagesWide * pagesHigh))
1020     {
1021       return Printable.NO_SUCH_PAGE;
1022     }
1023     final int alignmentDrawnHeight = (endSeq - startSeq) * charHeight
1024             + 3;
1025
1026     /*
1027      * draw the Scale at horizontal offset, then reset to top left (0, 0)
1028      */
1029     alignmentGraphics.translate(alignmentGraphicsOffset, 0);
1030     getScalePanel().drawScale(alignmentGraphics, startRes, endRes,
1031             pageWidth - idWidth, scaleHeight);
1032     alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
1033
1034     /*
1035      * Draw the sequence ids, offset for scale height,
1036      * then reset to top left (0, 0)
1037      */
1038     idGraphics.translate(0, scaleHeight);
1039     idGraphics.setFont(getIdPanel().getIdCanvas().getIdfont());
1040     Color currentColor = null;
1041     Color currentTextColor = null;
1042
1043     SequenceI seq;
1044     for (int i = startSeq; i < endSeq; i++)
1045     {
1046       seq = av.getAlignment().getSequenceAt(i);
1047       if ((av.getSelectionGroup() != null)
1048               && av.getSelectionGroup().getSequences(null).contains(seq))
1049       {
1050         /*
1051          * gray out ids of sequences in selection group (if any)
1052          */
1053         currentColor = Color.gray;
1054         currentTextColor = Color.black;
1055       }
1056       else
1057       {
1058         currentColor = av.getSequenceColour(seq);
1059         currentTextColor = Color.black;
1060       }
1061
1062       idGraphics.setColor(currentColor);
1063       idGraphics.fillRect(0, (i - startSeq) * charHeight, idWidth,
1064               charHeight);
1065
1066       idGraphics.setColor(currentTextColor);
1067
1068       int xPos = 0;
1069       String displayId = seq.getDisplayId(av.getShowJVSuffix());
1070       if (av.isRightAlignIds())
1071       {
1072         fm = idGraphics.getFontMetrics();
1073         xPos = idWidth
1074                 - fm.stringWidth(displayId)
1075                 - 4;
1076       }
1077
1078       idGraphics.drawString(displayId, xPos,
1079               (((i - startSeq) * charHeight) + charHeight)
1080                       - (charHeight / 5));
1081     }
1082     idGraphics.setFont(av.getFont());
1083     idGraphics.translate(0, -scaleHeight);
1084
1085     /*
1086      * draw the sequences, offset for scale height, and id width (if using a
1087      * single graphics context), then reset to (0, scale height)
1088      */
1089     alignmentGraphics.translate(alignmentGraphicsOffset, scaleHeight);
1090     getSeqPanel().seqCanvas.drawPanel(alignmentGraphics, startRes, endRes,
1091             startSeq, endSeq, 0);
1092     alignmentGraphics.translate(-alignmentGraphicsOffset, 0);
1093
1094     if (av.isShowAnnotation() && (endSeq == alignmentHeight))
1095     {
1096       /*
1097        * draw annotation labels; drawComponent() translates by
1098        * getScrollOffset(), so compensate for that first;
1099        * then reset to (0, scale height)
1100        */
1101       int offset = getAlabels().getScrollOffset();
1102       idGraphics.translate(0, -offset);
1103       idGraphics.translate(0, alignmentDrawnHeight);
1104       getAlabels().drawComponent(idGraphics, idWidth);
1105       idGraphics.translate(0, -alignmentDrawnHeight);
1106
1107       /*
1108        * draw the annotations starting at
1109        * (idOffset, alignmentHeight) from (0, scaleHeight)
1110        */
1111       alignmentGraphics.translate(alignmentGraphicsOffset, alignmentDrawnHeight);
1112       getAnnotationPanel().renderer.drawComponent(getAnnotationPanel(), av,
1113               alignmentGraphics, -1, startRes, endRes + 1);
1114     }
1115
1116     return Printable.PAGE_EXISTS;
1117   }
1118
1119   /**
1120    * DOCUMENT ME!
1121    *
1122    * @param pg
1123    *          DOCUMENT ME!
1124    * @param pwidth
1125    *          DOCUMENT ME!
1126    * @param pheight
1127    *          DOCUMENT ME!
1128    * @param pi
1129    *          DOCUMENT ME!
1130    *
1131    * @return DOCUMENT ME!
1132    *
1133    * @throws PrinterException
1134    *           DOCUMENT ME!
1135    */
1136   public int printWrappedAlignment(int pwidth, int pheight, int pi,
1137           Graphics pg) throws PrinterException
1138   {
1139     int annotationHeight = 0;
1140     AnnotationLabels labels = null;
1141     if (av.isShowAnnotation())
1142     {
1143       annotationHeight = getAnnotationPanel().adjustPanelHeight();
1144       labels = new AnnotationLabels(av);
1145     }
1146
1147     int hgap = av.getCharHeight();
1148     if (av.getScaleAboveWrapped())
1149     {
1150       hgap += av.getCharHeight();
1151     }
1152
1153     int cHeight = av.getAlignment().getHeight() * av.getCharHeight() + hgap
1154             + annotationHeight;
1155
1156     int idWidth = getVisibleIdWidth(false);
1157
1158     int maxwidth = av.getAlignment().getWidth();
1159     if (av.hasHiddenColumns())
1160     {
1161       maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
1162     }
1163
1164     int resWidth = getSeqPanel().seqCanvas.getWrappedCanvasWidth(pwidth
1165             - idWidth);
1166
1167     int totalHeight = cHeight * (maxwidth / resWidth + 1);
1168
1169     pg.setColor(Color.white);
1170     pg.fillRect(0, 0, pwidth, pheight);
1171     pg.setFont(av.getFont());
1172
1173     // //////////////
1174     // Draw the ids
1175     pg.setColor(Color.black);
1176
1177     pg.translate(0, -pi * pheight);
1178
1179     pg.setClip(0, pi * pheight, pwidth, pheight);
1180
1181     int ypos = hgap;
1182
1183     do
1184     {
1185       for (int i = 0; i < av.getAlignment().getHeight(); i++)
1186       {
1187         pg.setFont(getIdPanel().getIdCanvas().getIdfont());
1188         SequenceI s = av.getAlignment().getSequenceAt(i);
1189         String string = s.getDisplayId(av.getShowJVSuffix());
1190         int xPos = 0;
1191         if (av.isRightAlignIds())
1192         {
1193           FontMetrics fm = pg.getFontMetrics();
1194           xPos = idWidth - fm.stringWidth(string) - 4;
1195         }
1196         pg.drawString(string, xPos,
1197                 ((i * av.getCharHeight()) + ypos + av.getCharHeight())
1198                         - (av.getCharHeight() / 5));
1199       }
1200       if (labels != null)
1201       {
1202         pg.translate(-3,
1203                 ypos + (av.getAlignment().getHeight() * av.getCharHeight()));
1204
1205         pg.setFont(av.getFont());
1206         labels.drawComponent(pg, idWidth);
1207         pg.translate(
1208                 +3,
1209                 -ypos
1210                         - (av.getAlignment().getHeight() * av
1211                                 .getCharHeight()));
1212       }
1213
1214       ypos += cHeight;
1215     } while (ypos < totalHeight);
1216
1217     pg.translate(idWidth, 0);
1218
1219     getSeqPanel().seqCanvas.drawWrappedPanel(pg, pwidth - idWidth,
1220             totalHeight, 0);
1221
1222     if ((pi * pheight) < totalHeight)
1223     {
1224       return Printable.PAGE_EXISTS;
1225
1226     }
1227     else
1228     {
1229       return Printable.NO_SUCH_PAGE;
1230     }
1231   }
1232
1233   /**
1234    * get current sequence ID panel width, or nominal value if panel were to be
1235    * displayed using default settings
1236    *
1237    * @return
1238    */
1239   public int getVisibleIdWidth()
1240   {
1241     return getVisibleIdWidth(true);
1242   }
1243
1244   /**
1245    * get current sequence ID panel width, or nominal value if panel were to be
1246    * displayed using default settings
1247    *
1248    * @param onscreen
1249    *          indicate if the Id width for onscreen or offscreen display should
1250    *          be returned
1251    * @return
1252    */
1253   public int getVisibleIdWidth(boolean onscreen)
1254   {
1255     // see if rendering offscreen - check preferences and calc width accordingly
1256     if (!onscreen && Cache.getDefault("FIGURE_AUTOIDWIDTH", false))
1257     {
1258       return calculateIdWidth(-1).width + 4;
1259     }
1260     Integer idwidth = null;
1261     if (onscreen
1262             || (idwidth = Cache.getIntegerProperty("FIGURE_FIXEDIDWIDTH")) == null)
1263     {
1264       int w = getIdPanel().getWidth();
1265       return (w > 0 ? w : calculateIdWidth().width + 4);
1266     }
1267     return idwidth.intValue() + 4;
1268   }
1269
1270   void makeAlignmentImage(jalview.util.ImageMaker.TYPE type, File file)
1271   {
1272     int boarderBottomOffset = 5;
1273     long pSessionId = System.currentTimeMillis();
1274     headless = (System.getProperty("java.awt.headless") != null && System
1275             .getProperty("java.awt.headless").equals("true"));
1276     if (alignFrame != null && !headless)
1277     {
1278       if (file != null)
1279       {
1280         alignFrame.setProgressBar(MessageManager.formatMessage(
1281                 "status.saving_file", new Object[] { type.getLabel() }),
1282                 pSessionId);
1283       }
1284     }
1285     try
1286     {
1287       AlignmentDimension aDimension = getAlignmentDimension();
1288       try
1289       {
1290         jalview.util.ImageMaker im;
1291         final String imageAction, imageTitle;
1292         if (type == jalview.util.ImageMaker.TYPE.PNG)
1293         {
1294           imageAction = "Create PNG image from alignment";
1295           imageTitle = null;
1296         }
1297         else if (type == jalview.util.ImageMaker.TYPE.EPS)
1298         {
1299           imageAction = "Create EPS file from alignment";
1300           imageTitle = alignFrame.getTitle();
1301         }
1302         else
1303         {
1304           imageAction = "Create SVG file from alignment";
1305           imageTitle = alignFrame.getTitle();
1306         }
1307
1308         im = new jalview.util.ImageMaker(this, type, imageAction,
1309                 aDimension.getWidth(), aDimension.getHeight()
1310                         + boarderBottomOffset, file, imageTitle,
1311                 alignFrame, pSessionId, headless);
1312         Graphics graphics = im.getGraphics();
1313         if (av.getWrapAlignment())
1314         {
1315           if (graphics != null)
1316           {
1317             printWrappedAlignment(aDimension.getWidth(),
1318                     aDimension.getHeight() + boarderBottomOffset, 0,
1319                     graphics);
1320             im.writeImage();
1321           }
1322         }
1323         else
1324         {
1325           if (graphics != null)
1326           {
1327             printUnwrapped(aDimension.getWidth(), aDimension.getHeight(),
1328                     0, graphics, graphics);
1329             im.writeImage();
1330           }
1331         }
1332
1333       } catch (OutOfMemoryError err)
1334       {
1335         // Be noisy here.
1336         System.out.println("########################\n" + "OUT OF MEMORY "
1337                 + file + "\n" + "########################");
1338         new OOMWarning("Creating Image for " + file, err);
1339         // System.out.println("Create IMAGE: " + err);
1340       } catch (Exception ex)
1341       {
1342         ex.printStackTrace();
1343       }
1344     } finally
1345     {
1346
1347     }
1348   }
1349
1350   public AlignmentDimension getAlignmentDimension()
1351   {
1352     int maxwidth = av.getAlignment().getWidth();
1353     if (av.hasHiddenColumns())
1354     {
1355       maxwidth = av.getColumnSelection().findColumnPosition(maxwidth);
1356     }
1357
1358     int height = ((av.getAlignment().getHeight() + 1) * av.getCharHeight())
1359             + getScalePanel().getHeight();
1360     int width = getVisibleIdWidth(false) + (maxwidth * av.getCharWidth());
1361
1362     if (av.getWrapAlignment())
1363     {
1364       height = getWrappedHeight();
1365       if (headless)
1366       {
1367         // need to obtain default alignment width and then add in any
1368         // additional allowance for id margin
1369         // this duplicates the calculation in getWrappedHeight but adjusts for
1370         // offscreen idWith
1371         width = alignFrame.getWidth() - vscroll.getPreferredSize().width
1372                 - alignFrame.getInsets().left
1373                 - alignFrame.getInsets().right - getVisibleIdWidth()
1374                 + getVisibleIdWidth(false);
1375       }
1376       else
1377       {
1378         width = getSeqPanel().getWidth() + getVisibleIdWidth(false);
1379       }
1380
1381     }
1382     else if (av.isShowAnnotation())
1383     {
1384       height += getAnnotationPanel().adjustPanelHeight() + 3;
1385     }
1386     return new AlignmentDimension(width, height);
1387
1388   }
1389
1390   /**
1391    * DOCUMENT ME!
1392    */
1393   public void makeEPS(File epsFile)
1394   {
1395     makeAlignmentImage(jalview.util.ImageMaker.TYPE.EPS, epsFile);
1396   }
1397
1398   /**
1399    * DOCUMENT ME!
1400    */
1401   public void makePNG(File pngFile)
1402   {
1403     makeAlignmentImage(jalview.util.ImageMaker.TYPE.PNG, pngFile);
1404   }
1405
1406   public void makeSVG(File svgFile)
1407   {
1408     makeAlignmentImage(jalview.util.ImageMaker.TYPE.SVG, svgFile);
1409   }
1410
1411   public void makePNGImageMap(File imgMapFile, String imageName)
1412   {
1413     // /////ONLY WORKS WITH NON WRAPPED ALIGNMENTS
1414     // ////////////////////////////////////////////
1415     int idWidth = getVisibleIdWidth(false);
1416     FontMetrics fm = getFontMetrics(av.getFont());
1417     int scaleHeight = av.getCharHeight() + fm.getDescent();
1418
1419     // Gen image map
1420     // ////////////////////////////////
1421     if (imgMapFile != null)
1422     {
1423       try
1424       {
1425         int s, sSize = av.getAlignment().getHeight(), res, alwidth = av
1426                 .getAlignment().getWidth(), g, gSize, f, fSize, sy;
1427         PrintWriter out = new PrintWriter(new FileWriter(imgMapFile));
1428         out.println(jalview.io.HTMLOutput.getImageMapHTML());
1429         out.println("<img src=\"" + imageName
1430                 + "\" border=\"0\" usemap=\"#Map\" >"
1431                 + "<map name=\"Map\">");
1432
1433         for (s = 0; s < sSize; s++)
1434         {
1435           sy = s * av.getCharHeight() + scaleHeight;
1436
1437           SequenceI seq = av.getAlignment().getSequenceAt(s);
1438           SequenceFeature[] features = seq.getSequenceFeatures();
1439           SequenceGroup[] groups = av.getAlignment().findAllGroups(seq);
1440           for (res = 0; res < alwidth; res++)
1441           {
1442             StringBuilder text = new StringBuilder();
1443             String triplet = null;
1444             if (av.getAlignment().isNucleotide())
1445             {
1446               triplet = ResidueProperties.nucleotideName.get(seq
1447                       .getCharAt(res) + "");
1448             }
1449             else
1450             {
1451               triplet = ResidueProperties.aa2Triplet.get(seq.getCharAt(res)
1452                       + "");
1453             }
1454
1455             if (triplet == null)
1456             {
1457               continue;
1458             }
1459
1460             int alIndex = seq.findPosition(res);
1461             gSize = groups.length;
1462             for (g = 0; g < gSize; g++)
1463             {
1464               if (text.length() < 1)
1465               {
1466                 text.append("<area shape=\"rect\" coords=\"")
1467                         .append((idWidth + res * av.getCharWidth()))
1468                         .append(",").append(sy).append(",")
1469                         .append((idWidth + (res + 1) * av.getCharWidth()))
1470                         .append(",").append((av.getCharHeight() + sy))
1471                         .append("\"").append(" onMouseOver=\"toolTip('")
1472                         .append(alIndex).append(" ").append(triplet);
1473               }
1474
1475               if (groups[g].getStartRes() < res
1476                       && groups[g].getEndRes() > res)
1477               {
1478                 text.append("<br><em>").append(groups[g].getName())
1479                         .append("</em>");
1480               }
1481             }
1482
1483             if (features != null)
1484             {
1485               if (text.length() < 1)
1486               {
1487                 text.append("<area shape=\"rect\" coords=\"")
1488                         .append((idWidth + res * av.getCharWidth()))
1489                         .append(",").append(sy).append(",")
1490                         .append((idWidth + (res + 1) * av.getCharWidth()))
1491                         .append(",").append((av.getCharHeight() + sy))
1492                         .append("\"").append(" onMouseOver=\"toolTip('")
1493                         .append(alIndex).append(" ").append(triplet);
1494               }
1495               fSize = features.length;
1496               for (f = 0; f < fSize; f++)
1497               {
1498
1499                 if ((features[f].getBegin() <= seq.findPosition(res))
1500                         && (features[f].getEnd() >= seq.findPosition(res)))
1501                 {
1502                   if (features[f].isContactFeature())
1503                   {
1504                     if (features[f].getBegin() == seq.findPosition(res)
1505                             || features[f].getEnd() == seq
1506                                     .findPosition(res))
1507                     {
1508                       text.append("<br>").append(features[f].getType())
1509                               .append(" ").append(features[f].getBegin())
1510                               .append(":").append(features[f].getEnd());
1511                     }
1512                   }
1513                   else
1514                   {
1515                     text.append("<br>");
1516                     text.append(features[f].getType());
1517                     if (features[f].getDescription() != null
1518                             && !features[f].getType().equals(
1519                                     features[f].getDescription()))
1520                     {
1521                       text.append(" ").append(features[f].getDescription());
1522                     }
1523
1524                     if (features[f].getValue("status") != null)
1525                     {
1526                       text.append(" (").append(features[f].getValue("status"))
1527                               .append(")");
1528                     }
1529                   }
1530                 }
1531
1532               }
1533             }
1534             if (text.length() > 1)
1535             {
1536               text.append("')\"; onMouseOut=\"toolTip()\";  href=\"#\">");
1537               out.println(text.toString());
1538             }
1539           }
1540         }
1541         out.println("</map></body></html>");
1542         out.close();
1543
1544       } catch (Exception ex)
1545       {
1546         ex.printStackTrace();
1547       }
1548     } // /////////END OF IMAGE MAP
1549
1550   }
1551
1552   int getWrappedHeight()
1553   {
1554     int seqPanelWidth = getSeqPanel().seqCanvas.getWidth();
1555
1556     if (System.getProperty("java.awt.headless") != null
1557             && System.getProperty("java.awt.headless").equals("true"))
1558     {
1559       seqPanelWidth = alignFrame.getWidth() - getVisibleIdWidth()
1560               - vscroll.getPreferredSize().width
1561               - alignFrame.getInsets().left - alignFrame.getInsets().right;
1562     }
1563
1564     int chunkWidth = getSeqPanel().seqCanvas
1565             .getWrappedCanvasWidth(seqPanelWidth);
1566
1567     int hgap = av.getCharHeight();
1568     if (av.getScaleAboveWrapped())
1569     {
1570       hgap += av.getCharHeight();
1571     }
1572
1573     int annotationHeight = 0;
1574     if (av.isShowAnnotation())
1575     {
1576       annotationHeight = getAnnotationPanel().adjustPanelHeight();
1577     }
1578
1579     int cHeight = av.getAlignment().getHeight() * av.getCharHeight() + hgap
1580             + annotationHeight;
1581
1582     int maxwidth = av.getAlignment().getWidth();
1583     if (av.hasHiddenColumns())
1584     {
1585       maxwidth = av.getColumnSelection().findColumnPosition(maxwidth) - 1;
1586     }
1587
1588     int height = ((maxwidth / chunkWidth) + 1) * cHeight;
1589
1590     return height;
1591   }
1592
1593   /**
1594    * close the panel - deregisters all listeners and nulls any references to
1595    * alignment data.
1596    */
1597   public void closePanel()
1598   {
1599     PaintRefresher.RemoveComponent(getSeqPanel().seqCanvas);
1600     PaintRefresher.RemoveComponent(getIdPanel().getIdCanvas());
1601     PaintRefresher.RemoveComponent(this);
1602
1603     /*
1604      * try to ensure references are nulled
1605      */
1606     if (annotationPanel != null)
1607     {
1608       annotationPanel.dispose();
1609     }
1610
1611     if (av != null)
1612     {
1613       av.removePropertyChangeListener(propertyChangeListener);
1614       jalview.structure.StructureSelectionManager ssm = av
1615               .getStructureSelectionManager();
1616       ssm.removeStructureViewerListener(getSeqPanel(), null);
1617       ssm.removeSelectionListener(getSeqPanel());
1618       ssm.removeCommandListener(av);
1619       ssm.removeStructureViewerListener(getSeqPanel(), null);
1620       ssm.removeSelectionListener(getSeqPanel());
1621       av.dispose();
1622       av = null;
1623     }
1624     else
1625     {
1626       if (Cache.log.isDebugEnabled())
1627       {
1628         Cache.log.warn("Closing alignment panel which is already closed.");
1629       }
1630     }
1631   }
1632
1633   /**
1634    * hides or shows dynamic annotation rows based on groups and av state flags
1635    */
1636   public void updateAnnotation()
1637   {
1638     updateAnnotation(false, false);
1639   }
1640
1641   public void updateAnnotation(boolean applyGlobalSettings)
1642   {
1643     updateAnnotation(applyGlobalSettings, false);
1644   }
1645
1646   public void updateAnnotation(boolean applyGlobalSettings,
1647           boolean preserveNewGroupSettings)
1648   {
1649     av.updateGroupAnnotationSettings(applyGlobalSettings,
1650             preserveNewGroupSettings);
1651     adjustAnnotationHeight();
1652   }
1653
1654   @Override
1655   public AlignmentI getAlignment()
1656   {
1657     return av == null ? null : av.getAlignment();
1658   }
1659
1660   @Override
1661   public String getViewName()
1662   {
1663     return av.viewName;
1664   }
1665
1666   /**
1667    * Make/Unmake this alignment panel the current input focus
1668    *
1669    * @param b
1670    */
1671   public void setSelected(boolean b)
1672   {
1673     try
1674     {
1675       if (alignFrame.getSplitViewContainer() != null)
1676       {
1677         /*
1678          * bring enclosing SplitFrame to front first if there is one
1679          */
1680         ((SplitFrame) alignFrame.getSplitViewContainer()).setSelected(b);
1681       }
1682       alignFrame.setSelected(b);
1683     } catch (Exception ex)
1684     {
1685     }
1686
1687     if (b)
1688     {
1689       alignFrame.setDisplayedView(this);
1690     }
1691   }
1692
1693   @Override
1694   public StructureSelectionManager getStructureSelectionManager()
1695   {
1696     return av.getStructureSelectionManager();
1697   }
1698
1699   @Override
1700   public void raiseOOMWarning(String string, OutOfMemoryError error)
1701   {
1702     new OOMWarning(string, error, this);
1703   }
1704
1705   @Override
1706   public jalview.api.FeatureRenderer cloneFeatureRenderer()
1707   {
1708
1709     return new FeatureRenderer(this);
1710   }
1711
1712   @Override
1713   public jalview.api.FeatureRenderer getFeatureRenderer()
1714   {
1715     return seqPanel.seqCanvas.getFeatureRenderer();
1716   }
1717
1718   public void updateFeatureRenderer(
1719           jalview.renderer.seqfeatures.FeatureRenderer fr)
1720   {
1721     fr.transferSettings(getSeqPanel().seqCanvas.getFeatureRenderer());
1722   }
1723
1724   public void updateFeatureRendererFrom(jalview.api.FeatureRenderer fr)
1725   {
1726     if (getSeqPanel().seqCanvas.getFeatureRenderer() != null)
1727     {
1728       getSeqPanel().seqCanvas.getFeatureRenderer().transferSettings(fr);
1729     }
1730   }
1731
1732   public ScalePanel getScalePanel()
1733   {
1734     return scalePanel;
1735   }
1736
1737   public void setScalePanel(ScalePanel scalePanel)
1738   {
1739     this.scalePanel = scalePanel;
1740   }
1741
1742   public SeqPanel getSeqPanel()
1743   {
1744     return seqPanel;
1745   }
1746
1747   public void setSeqPanel(SeqPanel seqPanel)
1748   {
1749     this.seqPanel = seqPanel;
1750   }
1751
1752   public AnnotationPanel getAnnotationPanel()
1753   {
1754     return annotationPanel;
1755   }
1756
1757   public void setAnnotationPanel(AnnotationPanel annotationPanel)
1758   {
1759     this.annotationPanel = annotationPanel;
1760   }
1761
1762   public AnnotationLabels getAlabels()
1763   {
1764     return alabels;
1765   }
1766
1767   public void setAlabels(AnnotationLabels alabels)
1768   {
1769     this.alabels = alabels;
1770   }
1771
1772   public IdPanel getIdPanel()
1773   {
1774     return idPanel;
1775   }
1776
1777   public void setIdPanel(IdPanel idPanel)
1778   {
1779     this.idPanel = idPanel;
1780   }
1781
1782   /**
1783    * Follow a scrolling change in the (cDNA/Protein) complementary alignment.
1784    * The aim is to keep the two alignments 'lined up' on their centre columns.
1785    *
1786    * @param sr
1787    *          holds mapped region(s) of this alignment that we are scrolling
1788    *          'to'; may be modified for sequence offset by this method
1789    * @param verticalOffset
1790    *          the number of visible sequences to show above the mapped region
1791    */
1792   public void scrollToCentre(SearchResultsI sr, int verticalOffset)
1793   {
1794     /*
1795      * To avoid jumpy vertical scrolling (if some sequences are gapped or not
1796      * mapped), we can make the scroll-to location a sequence above the one
1797      * actually mapped.
1798      */
1799     SequenceI mappedTo = sr.getResults().get(0).getSequence();
1800     List<SequenceI> seqs = av.getAlignment().getSequences();
1801
1802     /*
1803      * This is like AlignmentI.findIndex(seq) but here we are matching the
1804      * dataset sequence not the aligned sequence
1805      */
1806     boolean matched = false;
1807     for (SequenceI seq : seqs)
1808     {
1809       if (mappedTo == seq.getDatasetSequence())
1810       {
1811         matched = true;
1812         break;
1813       }
1814     }
1815     if (!matched)
1816     {
1817       return; // failsafe, shouldn't happen
1818     }
1819
1820     /*
1821      * Scroll to position but centring the target residue.
1822      */
1823     scrollToPosition(sr, verticalOffset, true, true);
1824   }
1825
1826   /**
1827    * Set a flag to say do not scroll any (cDNA/protein) complement.
1828    *
1829    * @param b
1830    */
1831   protected void setDontScrollComplement(boolean b)
1832   {
1833     this.dontScrollComplement = b;
1834   }
1835
1836   protected boolean isDontScrollComplement()
1837   {
1838     return this.dontScrollComplement;
1839   }
1840
1841   /**
1842    * Redraw sensibly.
1843    *
1844    * @adjustHeight if true, try to recalculate panel height for visible
1845    *               annotations
1846    */
1847   protected void refresh(boolean adjustHeight)
1848   {
1849     validateAnnotationDimensions(adjustHeight);
1850     addNotify();
1851     if (adjustHeight)
1852     {
1853       // sort, repaint, update overview
1854       paintAlignment(true);
1855     }
1856     else
1857     {
1858       // lightweight repaint
1859       repaint();
1860     }
1861   }
1862
1863   @Override
1864   /**
1865    * Property change event fired when a change is made to the viewport ranges
1866    * object associated with this alignment panel's viewport
1867    */
1868   public void propertyChange(PropertyChangeEvent evt)
1869   {
1870     // update this panel's scroll values based on the new viewport ranges values
1871     int x = vpRanges.getStartRes();
1872     int y = vpRanges.getStartSeq();
1873     setScrollValues(x, y);
1874
1875     // now update any complementary alignment (its viewport ranges object
1876     // is different so does not get automatically updated)
1877     if (!isDontScrollComplement())
1878     {
1879       setDontScrollComplement(true);
1880       av.scrollComplementaryAlignment();
1881       setDontScrollComplement(false);
1882     }
1883   }
1884 }