X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FAlignmentPanel.java;h=1a48af6fbe1471e03fd96d4fbbb6dc0825674cb5;hb=2fa86d263d7bd66fb270a5d26878df37b96a61f4;hp=df0459fdda52a9b2bba7c671d8aa5432eaf0b369;hpb=0365a951ffb7cdab64e2f0872b4b719c910527ad;p=jalview.git

diff --git a/src/jalview/gui/AlignmentPanel.java b/src/jalview/gui/AlignmentPanel.java
index df0459f..1a48af6 100755
--- a/src/jalview/gui/AlignmentPanel.java
+++ b/src/jalview/gui/AlignmentPanel.java
@@ -1,175 +1,821 @@
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer
+ * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
 package jalview.gui;
 
-import jalview.jbgui.GAlignmentPanel;
-import java.awt.*;
-import java.awt.event.*;
 import java.io.*;
+import javax.imageio.*;
 
-public class AlignmentPanel extends GAlignmentPanel implements AdjustmentListener
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.*;
+import java.awt.print.*;
+import javax.swing.*;
+
+import org.jibble.epsgraphics.*;
+import jalview.analysis.*;
+import jalview.datamodel.*;
+import jalview.jbgui.*;
+import jalview.schemes.*;
+
+public class AlignmentPanel
+    extends GAlignmentPanel implements AdjustmentListener, Printable
 {
-
-  AlignViewport     av;
+  AlignViewport av;
   OverviewPanel overviewPanel;
-  public SeqPanel   seqPanel;
-  public IdPanel    idPanel;
+  SeqPanel seqPanel;
+  IdPanel idPanel;
+  IdwidthAdjuster idwidthAdjuster;
   public AlignFrame alignFrame;
-  public ScalePanel scalePanel;
-  public ScorePanel scorePanel;
+  ScalePanel scalePanel;
+  AnnotationPanel annotationPanel;
+  AnnotationLabels alabels;
 
-  public boolean    groupEdit = false;
+  // this value is set false when selection area being dragged
+  boolean fastPaint = true;
+  int hextent = 0;
+  int vextent = 0;
 
-  public AlignmentPanel(AlignFrame af, AlignViewport av)
+  public AlignmentPanel(AlignFrame af, final AlignViewport av)
   {
     alignFrame = af;
-    this.av         = av;
-    seqPanel        = new SeqPanel  (av, this);
-    idPanel         = new IdPanel   (av, this);
-    scalePanel = new ScalePanel(av);
-    scorePanel = new ScorePanel(av);
+    this.av = av;
+    seqPanel = new SeqPanel(av, this);
+    idPanel = new IdPanel(av, this);
 
+    scalePanel = new ScalePanel(av, this);
 
     idPanelHolder.add(idPanel, BorderLayout.CENTER);
-    idPanel.addNotify();
+    idwidthAdjuster = new IdwidthAdjuster(this);
+    idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);
+
+    annotationPanel = new AnnotationPanel(this);
+    alabels = new AnnotationLabels(this);
+
+    annotationSpaceFillerHolder.setPreferredSize(annotationPanel.
+                                                 getPreferredSize());
+    annotationScroller.setPreferredSize(annotationPanel.getPreferredSize());
+    annotationScroller.setViewportView(annotationPanel);
+    annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);
+
+    fontChanged();
+
     scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
-    scorePanelHolder.add(scorePanel, BorderLayout.CENTER);
     seqPanelHolder.add(seqPanel, BorderLayout.CENTER);
-    setScrollValues(0,0);
+
+    setScrollValues(0, 0);
 
     hscroll.addAdjustmentListener(this);
     vscroll.addAdjustmentListener(this);
-    selectAll(false);
 
-    addComponentListener(new ComponentAdapter()
-   {
-       public void componentResized(ComponentEvent evt)
-     {
-     //  if(!initialising)
-     RefreshPanels();
-     }
-   });
+    setFocusable(true);
+    addKeyListener(new KeyAdapter()
+    {
+      public void keyPressed(KeyEvent evt)
+      {
+        switch (evt.getKeyCode())
+        {
+          case 27: // escape key
+            av.setSelectionGroup(null);
+            repaint();
+
+            break;
+
+          case KeyEvent.VK_DOWN:
+            alignFrame.moveSelectedSequences(false);
+
+            break;
+
+          case KeyEvent.VK_UP:
+            alignFrame.moveSelectedSequences(true);
 
+            break;
+        }
+      }
+    });
   }
 
-  public int countSelected()
+  public void fontChanged()
   {
-    return av.getSelection().size();
+    // set idCanvas bufferedImage to null
+    // to prevent drawing old image
+    FontMetrics fm = getFontMetrics(av.getFont());
+
+    scalePanelHolder.setPreferredSize(new Dimension(10,
+        av.charHeight + fm.getDescent()));
+    idSpaceFillerPanel1.setPreferredSize(new Dimension(10,
+        av.charHeight + fm.getDescent()));
+
+    idPanel.idCanvas.gg = null;
+    annotationPanel.adjustPanelHeight();
+
+    Dimension d = calculateIdWidth();
+    d.setSize(d.width + 4, d.height);
+    idPanel.idCanvas.setPreferredSize(d);
+    hscrollFillerPanel.setPreferredSize(d);
+    repaint();
   }
 
-  public void selectAll(boolean flag) {
+  Dimension calculateIdWidth()
+  {
+    Graphics g = this.getGraphics();
+
+    if (g == null)
+    {
+      javax.swing.JFrame f = new javax.swing.JFrame();
+      f.addNotify();
+      g = f.getGraphics();
+    }
+
+    FontMetrics fm = g.getFontMetrics(av.font);
+    AlignmentI al = av.getAlignment();
+
     int i = 0;
-    if (flag) {
-      while (i < seqPanel.align.getHeight()) {
-        if (! av.getSelection().contains(av.getAlignment().getSequenceAt(i))) {
-          av.getSelection().addElement(av.getAlignment().getSequenceAt(i));
+    int idWidth = 0;
+    String id;
+
+    while ( (i < al.getHeight()) && (al.getSequenceAt(i) != null))
+    {
+      SequenceI s = al.getSequenceAt(i);
+
+      if (av.getShowFullId())
+      {
+        id = s.getDisplayId();
+      }
+      else
+      {
+        id = s.getName();
+      }
+
+      if (fm.stringWidth(id) > idWidth)
+      {
+        idWidth = fm.stringWidth(id);
+      }
+
+      i++;
+    }
+
+    // Also check annotation label widths
+    i = 0;
+
+    if (al.getAlignmentAnnotation() != null)
+    {
+      fm = g.getFontMetrics(alabels.getFont());
+
+      while (i < al.getAlignmentAnnotation().length)
+      {
+        String label = al.getAlignmentAnnotation()[i].label;
+
+        if (fm.stringWidth(label) > idWidth)
+        {
+          idWidth = fm.stringWidth(label);
         }
+
         i++;
       }
-    } else {
-      av.getSelection().clear();
     }
+
+    return new Dimension(idWidth, 12);
   }
 
- public OverviewPanel getOverviewPanel()
- {
-   return overviewPanel;
- }
+  public void highlightSearchResults(int[] results)
+  {
+    seqPanel.seqCanvas.highlightSearchResults(results);
 
- public void setOverviewPanel(OverviewPanel op)
- {
-   overviewPanel = op;
- }
+    // do we need to scroll the panel?
+    if (results != null)
+    {
+      SequenceI seq = av.alignment.getSequenceAt(results[0]);
+      int start = seq.findIndex(results[1]) - 1;
+      int end = seq.findIndex(results[2]) - 1;
+
+      if ( (av.getStartRes() > start) || (av.getEndRes() < end) ||
+          ( (av.getStartSeq() > results[0]) ||
+           (av.getEndSeq() < results[0])))
+      {
+        setScrollValues(start, results[0]);
+      }
+    }
+  }
 
+  public OverviewPanel getOverviewPanel()
+  {
+    return overviewPanel;
+  }
 
-  public void setGraphPanelVisible(boolean b)
+  public void setOverviewPanel(OverviewPanel op)
   {
-    scorePanelHolder.setVisible(b);
-    idSpaceFillerPanel.setVisible(b);
-    RefreshPanels();
+    overviewPanel = op;
   }
 
-  public void setColourScheme(jalview.schemes.ColourSchemeI cs)
+  public void setAnnotationVisible(boolean b)
   {
-    seqPanel.setColourScheme(cs);
-    if(overviewPanel!=null)
-      overviewPanel.updateOverviewImage();
+    annotationSpaceFillerHolder.setVisible(b);
+    annotationScroller.setVisible(b);
   }
 
+  public void setWrapAlignment(boolean wrap)
+  {
+    scalePanelHolder.setVisible(!wrap);
+    hscroll.setVisible(!wrap);
+    idwidthAdjuster.setVisible(!wrap);
 
-  public void RefreshPanels()
+    av.setShowAnnotation(!wrap);
+    annotationScroller.setVisible(!wrap);
+    annotationSpaceFillerHolder.setVisible(!wrap);
+    idSpaceFillerPanel1.setVisible(!wrap);
+
+    repaint();
+  }
+
+  public void setColourScheme()
   {
+    ColourSchemeI cs = av.getGlobalColourScheme();
 
-  /*  try{
-      ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("dump.dat"));
-      out.writeObject( (jalview.datamodel.Alignment)av.getAlignment() );
-    }catch(IOException ex){ex.printStackTrace();}*/
+    if (av.getConservationSelected())
+    {
+      Alignment al = (Alignment) av.getAlignment();
+      Conservation c = new Conservation("All",
+                                        ResidueProperties.propHash, 3,
+                                        al.getSequences(), 0,
+                                        al.getWidth());
+
+      c.calculate();
+      c.verdict(false, av.ConsPercGaps);
+
+      ConservationColourScheme ccs = new ConservationColourScheme(c, cs);
+
+      av.setGlobalColourScheme(ccs);
+    }
 
-    invalidate();
-    validate();
-    idPanel.idCanvas.paintFlag = true;
-    idPanelHolder.setPreferredSize( idPanel.idCanvas.getPreferredSize() );
-    seqPanel.seqCanvas.paintFlag = true;
-    setScrollValues(av.getStartRes(), av.getStartSeq());
-    av.getConsensus(true);
     repaint();
+  }
 
-    if(overviewPanel!=null)
-      overviewPanel.updateOverviewImage();
+  // return value is true if the scroll is valid
+  public boolean scrollUp(boolean up)
+  {
+    if (up)
+    {
+      if (vscroll.getValue() < 1)
+      {
+        return false;
+      }
 
+      fastPaint = false;
+      vscroll.setValue(vscroll.getValue() - 1);
+    }
+    else
+    {
+      if ( (vextent + vscroll.getValue()) >= av.getAlignment().getHeight())
+      {
+        return false;
+      }
+
+      fastPaint = false;
+      vscroll.setValue(vscroll.getValue() + 1);
+    }
+
+    fastPaint = true;
+
+    return true;
   }
 
-  int hextent = 0;
-  int vextent = 0;
+  public boolean scrollRight(boolean right)
+  {
+    if (right)
+    {
+      if (hscroll.getValue() < 1)
+      {
+        return false;
+      }
+
+      fastPaint = false;
+      hscroll.setValue(hscroll.getValue() - 1);
+    }
+    else
+    {
+      if ( (hextent + hscroll.getValue()) >= av.getAlignment().getWidth())
+      {
+        return false;
+      }
+
+      fastPaint = false;
+      hscroll.setValue(hscroll.getValue() + 1);
+    }
+
+    fastPaint = true;
+
+    return true;
+  }
 
   public void setScrollValues(int x, int y)
   {
-    hextent = (int)(seqPanel.seqCanvas.getWidth()/av.getCharWidth());
-    vextent = seqPanel.seqCanvas.getHeight()/av.getCharHeight();
+    av.setEndRes( (x + (seqPanel.seqCanvas.getWidth() / av.getCharWidth())) -
+                 1);
+
+    hextent = seqPanel.seqCanvas.getWidth() / av.charWidth;
+    vextent = seqPanel.seqCanvas.getHeight() / av.charHeight;
+
+    if (hextent > av.alignment.getWidth())
+    {
+      hextent = av.alignment.getWidth();
+    }
+
+    if (vextent > av.alignment.getHeight())
+    {
+      vextent = av.alignment.getHeight();
+    }
 
-    if(hextent+x  >  av.getAlignment().getWidth())
-      x =  av.getAlignment().getWidth()- hextent;
+    if ( (hextent + x) > av.getAlignment().getWidth())
+    {
+      x = av.getAlignment().getWidth() - hextent;
+    }
 
-    if(vextent+y > av.getAlignment().getHeight())
+    if ( (vextent + y) > av.getAlignment().getHeight())
+    {
       y = av.getAlignment().getHeight() - vextent;
+    }
 
-    if(y<0)
+    if (y < 0)
+    {
       y = 0;
+    }
 
-    if(x<0)
-      x=0;
-
-    hscroll.setValues(x,hextent,0,av.getAlignment().getWidth());
-    vscroll.setValues(y,vextent,0,av.getAlignment().getHeight() );
-    seqPanel.seqCanvas.paintFlag = true;
-    repaint();
+    if (x < 0)
+    {
+      x = 0;
+    }
 
+    hscroll.setValues(x, hextent, 0, av.getAlignment().getWidth());
+    vscroll.setValues(y, vextent, 0, av.getAlignment().getHeight());
   }
 
-
   public void adjustmentValueChanged(AdjustmentEvent evt)
   {
+    int oldX = av.getStartRes();
+    int oldY = av.getStartSeq();
 
     if (evt.getSource() == hscroll)
     {
       int x = hscroll.getValue();
       av.setStartRes(x);
-      av.setEndRes(x + (int)(seqPanel.seqCanvas.getWidth()/av.getCharWidth()-1));
+      av.setEndRes( (x +
+                     (seqPanel.seqCanvas.getWidth() / av.getCharWidth())) - 1);
     }
 
     if (evt.getSource() == vscroll)
     {
-        int offy = vscroll.getValue();
+      int offy = vscroll.getValue();
+
+      if (av.getWrapAlignment())
+      {
+        int rowSize = seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.
+            seqCanvas.getWidth());
+        av.setStartRes(vscroll.getValue() * rowSize);
+        av.setEndRes( (vscroll.getValue() + 1) * rowSize);
+      }
+      else
+      {
         av.setStartSeq(offy);
-        av.setEndSeq(offy + seqPanel.seqCanvas.getHeight()/av.getCharHeight());
+        av.setEndSeq(offy +
+                     (seqPanel.seqCanvas.getHeight() / av.getCharHeight()));
+      }
     }
 
-
-    if(overviewPanel!=null)
+    if (overviewPanel != null)
+    {
       overviewPanel.setBoxPosition();
+    }
+
+    if (av.getWrapAlignment() || !fastPaint)
+    {
+      repaint();
+    }
+    else
+    {
+      idPanel.idCanvas.fastPaint(av.getStartSeq() - oldY);
+      seqPanel.seqCanvas.fastPaint(av.getStartRes() - oldX,
+                                   av.getStartSeq() - oldY);
+
+      scalePanel.repaint();
+
+      if (av.getShowAnnotation())
+      {
+        annotationPanel.fastPaint(av.getStartRes() - oldX);
+      }
+    }
+  }
+
+  public void paintComponent(Graphics g)
+  {
+    invalidate();
+
+    Dimension d = idPanel.idCanvas.getPreferredSize();
+    idPanelHolder.setPreferredSize(d);
+    hscrollFillerPanel.setPreferredSize(new Dimension(d.width, 12));
+    validate();
+
+    if (av.getWrapAlignment())
+    {
+      int max = av.alignment.getWidth() /
+          seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.seqCanvas.getWidth());
+      vscroll.setMaximum(max);
+      vscroll.setUnitIncrement(1);
+      vscroll.setVisibleAmount(1);
+    }
+    else
+    {
+      setScrollValues(av.getStartRes(), av.getStartSeq());
+    }
+  }
+
+  public int print(Graphics pg, PageFormat pf, int pi)
+      throws PrinterException
+  {
+    pg.translate( (int) pf.getImageableX(), (int) pf.getImageableY());
 
+    int pwidth = (int) pf.getImageableWidth();
+    int pheight = (int) pf.getImageableHeight();
 
+    if (av.getWrapAlignment())
+    {
+      return printWrappedAlignment(pg, pwidth, pheight, pi);
+    }
+    else
+    {
+      return printUnwrapped(pg, pwidth, pheight, pi);
+    }
+  }
+
+  public int printUnwrapped(Graphics pg, int pwidth, int pheight, int pi)
+      throws PrinterException
+  {
+    int idWidth = calculateIdWidth().width + 4;
+    FontMetrics fm = getFontMetrics(av.getFont());
+    int scaleHeight = av.charHeight + fm.getDescent();
+
+    pg.setColor(Color.white);
+    pg.fillRect(0, 0, pwidth, pheight);
+    pg.setFont(av.getFont());
+
+    ////////////////////////////////////
+    /// How many sequences and residues can we fit on a printable page?
+    int totalRes = (pwidth - idWidth) / av.getCharWidth();
+
+    int totalSeq = (int) ( (pheight - scaleHeight) / av.getCharHeight()) -
+        1;
+
+    int pagesWide = (av.getAlignment().getWidth() / totalRes) + 1;
+
+    /////////////////////////////
+    /// Only print these sequences and residues on this page
+    int startRes;
+
+    /////////////////////////////
+    /// Only print these sequences and residues on this page
+    int endRes;
+
+    /////////////////////////////
+    /// Only print these sequences and residues on this page
+    int startSeq;
+
+    /////////////////////////////
+    /// Only print these sequences and residues on this page
+    int endSeq;
+    startRes = (pi % pagesWide) * totalRes;
+    endRes = (startRes + totalRes) - 1;
+
+    if (endRes > (av.getAlignment().getWidth() - 1))
+    {
+      endRes = av.getAlignment().getWidth() - 1;
+    }
+
+    startSeq = (pi / pagesWide) * totalSeq;
+    endSeq = startSeq + totalSeq;
+
+    if (endSeq > av.getAlignment().getHeight())
+    {
+      endSeq = av.getAlignment().getHeight();
+    }
+
+    int pagesHigh = ( (av.alignment.getHeight() / totalSeq) + 1) * pheight;
+
+    if (av.showAnnotation)
+    {
+      pagesHigh += annotationPanel.getHeight();
+    }
+
+    pagesHigh /= pheight;
+
+    if (pi >= (pagesWide * pagesHigh))
+    {
+      return Printable.NO_SUCH_PAGE;
+    }
+
+    //draw Scale
+    pg.translate(idWidth, 0);
+    scalePanel.drawScale(pg, startRes, endRes, pwidth - idWidth, scaleHeight);
+    pg.translate( -idWidth, scaleHeight);
+
+    ////////////////
+    // Draw the ids
+    Color currentColor = null;
+    Color currentTextColor = null;
+
+    for (int i = startSeq; i < endSeq; i++)
+    {
+      if ( (av.getSelectionGroup() != null) &&
+          av.getSelectionGroup().sequences.contains(
+              av.getAlignment().getSequenceAt(i)))
+      {
+        currentColor = Color.gray;
+        currentTextColor = Color.black;
+      }
+      else
+      {
+        currentColor = av.getAlignment().getSequenceAt(i).getColor();
+        currentTextColor = Color.black;
+      }
+
+      pg.setColor(currentColor);
+      pg.fillRect(0,
+                  jalview.analysis.AlignmentUtil.getPixelHeight(startSeq, i,
+          av.getCharHeight()), idWidth, av.getCharHeight());
+
+      pg.setColor(currentTextColor);
+
+      String string = av.getAlignment().getSequenceAt(i).getName();
+
+      if (av.getShowFullId())
+      {
+        string = av.getAlignment().getSequenceAt(i).getDisplayId();
+      }
+
+      pg.drawString(string, 0,
+                    (jalview.analysis.AlignmentUtil.getPixelHeight(startSeq, i,
+          av.getCharHeight()) + av.getCharHeight()) -
+                    (av.getCharHeight() / 5));
+    }
+
+    // draw main sequence panel
+    pg.translate(idWidth, 0);
+    seqPanel.seqCanvas.drawPanel(pg, startRes, endRes, startSeq, endSeq,
+                                 startRes, startSeq, 0);
+
+    if (av.showAnnotation && (endSeq == av.alignment.getHeight()))
+    {
+      pg.translate( -idWidth, (endSeq - startSeq) * av.charHeight);
+      alabels.drawComponent( (Graphics2D) pg);
+      pg.translate(idWidth, 0);
+      annotationPanel.drawComponent( (Graphics2D) pg, startRes, endRes +
+                                    1);
+    }
+
+    return Printable.PAGE_EXISTS;
+  }
+
+  public int printWrappedAlignment(Graphics pg, int pwidth, int pheight,
+                                   int pi)
+      throws PrinterException
+  {
+    int idWidth = calculateIdWidth().width + 4;
+
+    int resWidth = seqPanel.seqCanvas.getWrappedCanvasWidth(pwidth -
+        idWidth);
+    int totalHeight = totalHeight = (av.alignment.getHeight() + 2) *
+        ( (av.alignment.getWidth() / resWidth) +
+         1) * av.charHeight;
+
+    pg.setColor(Color.white);
+    pg.fillRect(0, 0, pwidth, pheight);
+    pg.setFont(av.getFont());
+
+    ////////////////
+    // Draw the ids
+    pg.setColor(Color.black);
+
+    pg.translate(0, -pi * pheight);
+
+    pg.setClip(0, pi * pheight, pwidth, pheight);
+
+    int ypos = 2 * av.charHeight;
+
+    do
+    {
+      for (int i = 0; i < av.alignment.getHeight(); i++)
+      {
+        SequenceI s = av.alignment.getSequenceAt(i);
+        String string = s.getName();
+
+        if (av.getShowFullId())
+        {
+          string = s.getDisplayId();
+        }
+
+        pg.drawString(string, 0,
+                      (AlignmentUtil.getPixelHeight(0, i, av.charHeight) + ypos +
+                       av.charHeight) - (av.charHeight / 5));
+      }
+
+      ypos += ( (av.alignment.getHeight() + 2) * av.charHeight);
+    }
+    while (ypos < totalHeight);
+
+    pg.translate(idWidth, 0);
+
+    seqPanel.seqCanvas.drawWrappedPanel(pg, pwidth - idWidth, totalHeight, 0);
+
+    if ( (pi * pheight) < totalHeight)
+    {
+      return Printable.PAGE_EXISTS;
+    }
+    else
+    {
+      return Printable.NO_SUCH_PAGE;
+    }
+  }
+
+  public void makeEPS()
+  {
+    int height = ( (av.alignment.getWidth() / av.getChunkWidth()) + 1) *
+        av.chunkHeight;
+    int width = seqPanel.getWidth() + idPanel.getWidth();
+
+    if (!av.getWrapAlignment())
+    {
+      height = ( (av.alignment.getHeight() + 1) * av.charHeight) + 30;
+      width = idPanel.getWidth() +
+          (av.alignment.getWidth() * av.charWidth);
+    }
+
+    if (av.getShowAnnotation())
+    {
+      height += annotationPanel.getPreferredSize().height;
+    }
+
+    try
+    {
+      jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(
+          jalview.bin.Cache.getProperty(
+              "LAST_DIRECTORY"), new String[]
+          {"eps"},
+          new String[]
+          {"Encapsulated Postscript"},
+          "Encapsulated Postscript");
+      chooser.setFileView(new jalview.io.JalviewFileView());
+      chooser.setDialogTitle("Create EPS file from alignment");
+      chooser.setToolTipText("Save");
+
+      int value = chooser.showSaveDialog(this);
+
+      if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
+      {
+        return;
+      }
+
+      jalview.bin.Cache.setProperty("LAST_DIRECTORY",
+                                    chooser.getSelectedFile().getParent());
+
+      FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());
+      EpsGraphics2D pg = new EpsGraphics2D("Example", out, 0, 0, width,
+                                           height);
+
+      if (av.getWrapAlignment())
+      {
+        printWrappedAlignment(pg, width, height, 0);
+      }
+      else
+      {
+        printUnwrapped(pg, width, height, 0);
+      }
+
+      pg.flush();
+      pg.close();
+    }
+    catch (Exception ex)
+    {
+      ex.printStackTrace();
+    }
+  }
+
+  public void makePNG()
+  {
+    int height = ( (av.alignment.getWidth() / av.getChunkWidth()) + 1) *
+        av.chunkHeight;
+    int width = seqPanel.getWidth() + idPanel.getWidth();
+
+    if (!av.getWrapAlignment())
+    {
+      height = ( (av.alignment.getHeight() + 1) * av.charHeight) + 30;
+      width = idPanel.getWidth() +
+          (av.alignment.getWidth() * av.charWidth);
+    }
+
+    if (av.getShowAnnotation())
+    {
+      height += annotationPanel.getPreferredSize().height;
+    }
+
+    try
+    {
+      jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(
+          jalview.bin.Cache.getProperty(
+              "LAST_DIRECTORY"), new String[]
+          {"png"},
+          new String[]
+          {"Portable network graphics"},
+          "Portable network graphics");
+      chooser.setFileView(new jalview.io.JalviewFileView());
+      chooser.setDialogTitle("Create EPS file from alignment");
+      chooser.setToolTipText("Save");
+
+      int value = chooser.showSaveDialog(this);
+
+      if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
+      {
+        return;
+      }
+
+      jalview.bin.Cache.setProperty("LAST_DIRECTORY",
+                                    chooser.getSelectedFile().getParent());
+
+      FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());
+
+      BufferedImage bi = new BufferedImage(width, height,
+                                           BufferedImage.TYPE_INT_RGB);
+      Graphics2D png = (Graphics2D) bi.getGraphics();
+
+      png.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                           RenderingHints.VALUE_ANTIALIAS_ON);
+
+      if (av.getWrapAlignment())
+      {
+        printWrappedAlignment(png, width, height, 0);
+      }
+      else
+      {
+        printUnwrapped(png, width, height, 0);
+      }
+
+      ImageIO.write(bi, "png", out);
+      out.close();
+    }
+    catch (Exception ex)
+    {
+      ex.printStackTrace();
+    }
+  }
+}
+
+class Preview
+    extends JFrame
+{
+  public Preview(Image image)
+  {
+    setResizable(true);
+    setSize(image.getWidth(this), image.getHeight(this));
+    setVisible(true);
+    getContentPane().setLayout(new BorderLayout());
+    getContentPane().add(new PreviewPanel(image), BorderLayout.CENTER);
+    validate();
     repaint();
   }
+}
 
+class PreviewPanel
+    extends JPanel
+{
+  Image image;
 
+  public PreviewPanel(Image image)
+  {
+    this.image = image;
+  }
 
+  public void paintComponent(Graphics g)
+  {
+    if (image != null)
+    {
+      g.drawImage(image, 0, 0, this);
+    }
+    else
+    {
+      System.out.println("DEBUG:image is null");
+    }
+  }
 }