/*
 * 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.datamodel.*;

import jalview.jbgui.*;

import jalview.schemes.*;

import org.jibble.epsgraphics.*;

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.print.*;

import java.io.*;

import javax.imageio.*;

import javax.swing.*;


/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
public class AlignmentPanel extends GAlignmentPanel
    implements AdjustmentListener, Printable
{
    public AlignViewport av;
    OverviewPanel overviewPanel;
    SeqPanel seqPanel;
    IdPanel idPanel;
    IdwidthAdjuster idwidthAdjuster;

    /** DOCUMENT ME!! */
    public AlignFrame alignFrame;
    ScalePanel scalePanel;
    AnnotationPanel annotationPanel;
    AnnotationLabels alabels;

    // this value is set false when selection area being dragged
    boolean fastPaint = true;
    int hextent = 0;
    int vextent = 0;

    /**
     * Creates a new AlignmentPanel object.
     *
     * @param af DOCUMENT ME!
     * @param av DOCUMENT ME!
     */
    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, this);

        idPanelHolder.add(idPanel, BorderLayout.CENTER);
        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);
        seqPanelHolder.add(seqPanel, BorderLayout.CENTER);

        setScrollValues(0, 0);

        hscroll.addAdjustmentListener(this);
        vscroll.addAdjustmentListener(this);

        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;

                    case KeyEvent.VK_BACK_SPACE:
                    case KeyEvent.VK_DELETE:
                      alignFrame.cut_actionPerformed(null);
                      break;

                    case KeyEvent.VK_P:
                      seqPanel.seqCanvas.increaseAARatio();
                      break;
                    case KeyEvent.VK_L:
                      seqPanel.seqCanvas.decreaseAARation();
                      break;
                    }

                }
            });
    }


    /**
     * DOCUMENT ME!
     */
    public void fontChanged()
    {
        // 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;
        seqPanel.seqCanvas.img = null;
        annotationPanel.adjustPanelHeight();

        Dimension d = calculateIdWidth();
        d.setSize(d.width + 4, d.height);
        idPanel.idCanvas.setPreferredSize(d);
        hscrollFillerPanel.setPreferredSize(d);

        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());
        }

        if(overviewPanel!=null)
          overviewPanel.setBoxPosition();

        repaint();
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public Dimension calculateIdWidth()
    {
      Container c = new Container();

        FontMetrics fm = c.getFontMetrics(av.font);
        AlignmentI al = av.getAlignment();

        int i = 0;
        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 = c.getFontMetrics(alabels.getFont());

            while (i < al.getAlignmentAnnotation().length)
            {
                String label = al.getAlignmentAnnotation()[i].label;

                if (fm.stringWidth(label) > idWidth)
                {
                    idWidth = fm.stringWidth(label);
                }

                i++;
            }
        }

        return new Dimension(idWidth, 12);
    }

    /**
     * DOCUMENT ME!
     *
     * @param results DOCUMENT ME!
     */
    public void highlightSearchResults(int[] results)
    {
        seqPanel.seqCanvas.highlightSearchResults(results);

        // 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]);
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public OverviewPanel getOverviewPanel()
    {
        return overviewPanel;
    }

    /**
     * DOCUMENT ME!
     *
     * @param op DOCUMENT ME!
     */
    public void setOverviewPanel(OverviewPanel op)
    {
        overviewPanel = op;
    }

    /**
     * DOCUMENT ME!
     *
     * @param b DOCUMENT ME!
     */
    public void setAnnotationVisible(boolean b)
    {
      if (!av.wrapAlignment)
      {
        annotationSpaceFillerHolder.setVisible(b);
        annotationScroller.setVisible(b);
      }
      repaint();
    }

    /**
     * DOCUMENT ME!
     *
     * @param wrap DOCUMENT ME!
     */
    public void setWrapAlignment(boolean wrap)
    {
        av.startSeq = 0;
        scalePanelHolder.setVisible(!wrap);
        hscroll.setVisible(!wrap);
        idwidthAdjuster.setVisible(!wrap);

       if(wrap)
       {
         annotationScroller.setVisible(false);
         annotationSpaceFillerHolder.setVisible(false);
       }
       else if(av.showAnnotation)
       {
         annotationScroller.setVisible(true);
         annotationSpaceFillerHolder.setVisible(true);
       }

       idSpaceFillerPanel1.setVisible(!wrap);

        repaint();
    }


    // 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;
    }

    /**
     * DOCUMENT ME!
     *
     * @param right DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    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;
    }

    /**
     * DOCUMENT ME!
     *
     * @param x DOCUMENT ME!
     * @param y DOCUMENT ME!
     */
    public void setScrollValues(int x, int y)
    {
        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 ((vextent + y) > av.getAlignment().getHeight())
        {
            y = av.getAlignment().getHeight() - vextent;
        }

        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());
    }


    /**
     * DOCUMENT ME!
     *
     * @param evt DOCUMENT ME!
     */
    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 +
                (seqPanel.seqCanvas.getWidth() / av.getCharWidth())) - 1);
        }

        if (evt.getSource() == vscroll)
        {
            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()));
            }
        }

        if (overviewPanel != null)
        {
            overviewPanel.setBoxPosition();
        }

        int xShift = av.getStartRes() - oldX;
        int yShift = av.getStartSeq() - oldY;

        if ( (xShift != 0 && yShift != 0) ||
            (Math.abs(xShift) > av.getEndRes() - av.getStartRes()
             || Math.abs(yShift) > av.getEndSeq() - av.getStartSeq())
             || av.getWrapAlignment()
             || !fastPaint)
        {
          // Either no shift at all, or shift greater than visible amount
          repaint();
        }
        else
        {
            idPanel.idCanvas.fastPaint(yShift);
            seqPanel.seqCanvas.fastPaint(xShift, yShift);

            scalePanel.repaint();

            if (av.getShowAnnotation())
            {
                annotationPanel.fastPaint(xShift);
            }
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     */
    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());
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param pg DOCUMENT ME!
     * @param pf DOCUMENT ME!
     * @param pi DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     *
     * @throws PrinterException DOCUMENT ME!
     */
    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);
        }
    }

    /**
     * DOCUMENT ME!
     *
     * @param pg DOCUMENT ME!
     * @param pwidth DOCUMENT ME!
     * @param pheight DOCUMENT ME!
     * @param pi DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     *
     * @throws PrinterException DOCUMENT ME!
     */
    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.adjustPanelHeight()+3;
        }

        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, (i-startSeq) * av.charHeight, 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,
                (((i-startSeq) * av.charHeight) + 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 +3);
            alabels.drawComponent((Graphics2D) pg, idWidth);
            pg.translate(idWidth, 0);
            annotationPanel.drawComponent((Graphics2D) pg, startRes, endRes +
                1);
        }

        return Printable.PAGE_EXISTS;
    }

    /**
     * DOCUMENT ME!
     *
     * @param pg DOCUMENT ME!
     * @param pwidth DOCUMENT ME!
     * @param pheight DOCUMENT ME!
     * @param pi DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     *
     * @throws PrinterException DOCUMENT ME!
     */
    public int printWrappedAlignment(Graphics pg, int pwidth, int pheight,
        int pi) throws PrinterException
    {

      int annotationHeight = 0;
      AnnotationLabels labels = null;
      if (av.showAnnotation)
      {
        annotationHeight = annotationPanel.adjustPanelHeight();
        labels = new AnnotationLabels(av);
      }

      int hgap = av.charHeight;
      if (av.scaleAboveWrapped)
        hgap += av.charHeight;

      int cHeight = av.getAlignment().getHeight() * av.charHeight
          + hgap
          + annotationHeight;


      int idWidth = calculateIdWidth().width + 4;

        int resWidth = seqPanel.seqCanvas.getWrappedCanvasWidth(pwidth -
                idWidth);

        int totalHeight = cHeight * (av.alignment.getWidth() / resWidth +1);

        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 = hgap;
        Font italic = new Font(av.getFont().getName(), Font.ITALIC,
                             av.getFont().getSize());
        pg.setFont(italic);


        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,
                          ( (i * av.charHeight) + ypos + av.charHeight) -
                          (av.charHeight / 5));
          }
            if (labels != null)
            {
              pg.translate(0,
                           ypos +
                           (av.getAlignment().getHeight() * av.charHeight));

              pg.setFont(av.getFont());
              labels.drawComponent( pg, idWidth );
              pg.setFont(italic);
              pg.translate(0,
                           -ypos -
                           (av.getAlignment().getHeight() * av.charHeight));
            }

            ypos += cHeight;
        }
        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;
        }
    }

    /**
     * DOCUMENT ME!
     */
    public void makeEPS(File epsFile)
    {
      boolean accurateText = true;

      String renderStyle = jalview.bin.Cache.getDefault("EPS_RENDERING",
          "Prompt each time");

      // If we need to prompt, and if the GUI is visible then
      // Prompt for EPS rendering style
      if (renderStyle.equalsIgnoreCase("Prompt each time")
          && !
          (System.getProperty("java.awt.headless") != null
           && System.getProperty("java.awt.headless").equals("true")))
      {
        EPSOptions eps = new EPSOptions();
        renderStyle = eps.getValue();

        if(eps.cancelled || renderStyle==null)
          return;

        renderStyle = eps.getValue();
      }

      if (renderStyle.equalsIgnoreCase("text"))
      {
        accurateText = false;
      }


        if(epsFile == null)
        {
          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;
          }

          epsFile = chooser.getSelectedFile();

          jalview.bin.Cache.setProperty("LAST_DIRECTORY",
                                        chooser.getSelectedFile().getParent());
        }


        int height = ( (av.alignment.getHeight() + 1) * av.charHeight) + 30;
        int width = idPanel.getWidth() + (av.alignment.getWidth() * av.charWidth);


        if (av.getWrapAlignment())
        {
          height = getWrappedHeight();
          width = seqPanel.getWidth() + idPanel.getWidth();
        }
        else if (av.getShowAnnotation())
        {
          height += annotationPanel.adjustPanelHeight()+3;
        }


        try
         {
           FileOutputStream out = new FileOutputStream(epsFile);
           EpsGraphics2D pg = new EpsGraphics2D("Example", out, 0, 0, width,
                                                height);

           pg.setAccurateTextMode(accurateText);

           if (av.getWrapAlignment())
           {
                printWrappedAlignment(pg, width, height, 0);
            }
            else
            {
                printUnwrapped(pg, width, height, 0);
            }

            pg.flush();
            pg.close();
          }
          catch (OutOfMemoryError err)
          {
            System.out.println("########################\n"
                               + "OUT OF MEMORY " + epsFile + "\n"
                               + "########################");

            JOptionPane.showInternalMessageDialog(Desktop.desktop,
                                                  "Out of memory creating EPS file!!"
                                                  +
                                                  "\nSee help files for increasing Java Virtual Machine memory."
                                                  , "Out of memory",
                                                  JOptionPane.WARNING_MESSAGE);
            System.out.println("Create EPS: " + err);
            System.gc();
          }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }


    public void makePNGImageMap(File imgMapFile, String imageName)
    {
      ///////ONLY WORKS WITH NONE WRAPPED ALIGNMENTS
      //////////////////////////////////////////////
      int idWidth = calculateIdWidth().width + 4;
      FontMetrics fm = getFontMetrics(av.getFont());
      int scaleHeight = av.charHeight + fm.getDescent();

        // Gen image map
         //////////////////////////////////
         if(imgMapFile!=null)
         {
           try
           {
             PrintWriter out = new PrintWriter(new FileWriter(imgMapFile));
             out.println(jalview.io.HTMLOutput.getImageMapHTML());
             out.println("<img src=\"" + imageName +
                       "\" border=\"0\" usemap=\"#Map\" >"
                       +"<map name=\"Map\">");

             for (int s = 0; s < av.alignment.getHeight(); s++)
             {
               SequenceI seq = av.alignment.getSequenceAt(s);
               SequenceGroup[] groups = av.alignment.findAllGroups(seq);
               for (int i = 0; i < groups.length; i++)
               {
                 int sy = s * av.charHeight + scaleHeight;
                 for (int res = groups[i].getStartRes();
                      res < groups[i].getEndRes() + 1; res++)
                 {
                   int alIndex = seq.findPosition(res);
                   Object obj = ResidueProperties.aa2Triplet.get(
                       seq.getCharAt(res) + "");
                   if (obj == null)
                     continue;

                   String triplet = obj.toString();

                   out.println(
                       "<area shape=\"rect\" coords=\""
                       + (idWidth + res * av.charWidth) + ","
                       + sy + ","
                       + (idWidth + (res + 1) * av.charWidth) + ","
                       + (av.charHeight + sy) + "\""
                       + " onMouseOver=\"toolTip('"
                       + alIndex + " " + triplet +
                       "<br><em>" + groups[i].getName() +
                       "</em>')\"; onMouseOut=\"toolTip()\"; "
                       + " href=\"#\">");
                 }
               }
             }

             out.println("</map></body></html>");
             out.close();

           }
           catch (Exception ex)
           {
             ex.printStackTrace();
           }
         }///////////END OF IMAGE MAP

    }

    int getWrappedHeight()
    {

      int chunkWidth = seqPanel.seqCanvas.getWrappedCanvasWidth(
        seqPanel.seqCanvas.getWidth());

      int hgap = av.charHeight;
      if (av.scaleAboveWrapped)
        hgap += av.charHeight;

      int annotationHeight = 0;
      if (av.showAnnotation)
      {
        annotationHeight = annotationPanel.adjustPanelHeight();
      }

      int cHeight = av.getAlignment().getHeight() * av.charHeight
          + hgap
          + annotationHeight;


      int height =  ( (av.alignment.getWidth() / chunkWidth) + 1) * cHeight;

      return height;
    }

    /**
     * DOCUMENT ME!
     */
    public void makePNG(File pngFile)
    {
      if(pngFile==null)
      {
        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;
        }

        pngFile = chooser.getSelectedFile();

        jalview.bin.Cache.setProperty("LAST_DIRECTORY",
                                      chooser.getSelectedFile().getParent());
      }



      int height = ( (av.alignment.getHeight() + 1) * av.charHeight) + 30;
      int width = idPanel.getWidth() + (av.alignment.getWidth() * av.charWidth);

      if (av.getWrapAlignment())
      {
        height = getWrappedHeight();
        width = seqPanel.getWidth() + idPanel.getWidth();
      }
      else if (av.getShowAnnotation())
        {
            height += annotationPanel.adjustPanelHeight()+3;
        }

        try
        {

            FileOutputStream out = new FileOutputStream(pngFile);

            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 (OutOfMemoryError err)
        {
          System.out.println("########################\n"
                             + "OUT OF MEMORY " + pngFile + "\n"
                             + "########################");

          JOptionPane.showInternalMessageDialog(Desktop.desktop,
                                                "Out of memory creating PNG!!"
                                                +
                                                "\nSee help files for increasing Java Virtual Machine memory."
                                                , "Out of memory",
                                                JOptionPane.WARNING_MESSAGE);
          System.out.println("Create PNG: " + err);
          System.gc();

        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}


/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
class Preview extends JFrame
{
    /**
     * Creates a new Preview object.
     *
     * @param image DOCUMENT ME!
     */
    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();
    }
}


/**
 * DOCUMENT ME!
 *
 * @author $author$
 * @version $Revision$
 */
class PreviewPanel extends JPanel
{
    Image image;

    /**
     * Creates a new PreviewPanel object.
     *
     * @param image DOCUMENT ME!
     */
    public PreviewPanel(Image image)
    {
        this.image = image;
    }

    /**
     * DOCUMENT ME!
     *
     * @param g DOCUMENT ME!
     */
    public void paintComponent(Graphics g)
    {
        if (image != null)
        {
            g.drawImage(image, 0, 0, this);
        }
        else
        {
            System.out.println("DEBUG:image is null");
        }
    }
}