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