/* $Id: SaveGraphicsManager.java 17881 2010-01-12 21:09:28Z linus $

  *****************************************************************************

  * Copyright (c) 2009 Contributors - see below

  * All rights reserved. This program and the accompanying materials

  * are made available under the terms of the Eclipse Public License v1.0

  * which accompanies this distribution, and is available at

  * http://www.eclipse.org/legal/epl-v10.html

  *

  * Contributors:

  *    bobtarling

  *****************************************************************************

  *

  * Some portions of this file was previously release using the BSD License:

  */

 // Copyright (c) 2005-2008 The Regents of the University of California. All

 // Rights Reserved. Permission to use, copy, modify, and distribute this

 // software and its documentation without fee, and without a written

 // agreement is hereby granted, provided that the above copyright notice

 // and this paragraph appear in all copies.  This software program and

 // documentation are copyrighted by The Regents of the University of

 // California. The software program and documentation are supplied "AS

 // IS", without any accompanying services from The Regents. The Regents

 // does not warrant that the operation of the program will be

 // uninterrupted or error-free. The end-user understands that the program

 // was developed for research purposes and is advised not to rely

 // exclusively on the program for any reason.  IN NO EVENT SHALL THE

 // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

 // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,

 // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF

 // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF

 // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY

 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF

 // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,

 // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 package org.argouml.uml.ui;

 import java.awt.Rectangle;

 import java.awt.event.ActionEvent;

 import java.awt.image.BufferedImage;

 import java.awt.image.RenderedImage;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyChangeListener;

 import java.io.File;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.Iterator;

 import java.util.List;

 import javax.imageio.ImageIO;

 import javax.swing.Icon;

 import javax.swing.JFileChooser;

 import javax.swing.SwingUtilities;

 import javax.xml.parsers.ParserConfigurationException;

 import org.apache.log4j.Logger;

 import org.argouml.configuration.Configuration;

 import org.argouml.configuration.ConfigurationKey;

 import org.argouml.gefext.DeferredBufferedImage;

 import org.argouml.i18n.Translator;

 import org.argouml.model.Model;

 import org.argouml.util.FileFilters;

 import org.argouml.util.SuffixFilter;

 import org.tigris.gef.base.Editor;

 import org.tigris.gef.base.Globals;

 import org.tigris.gef.base.Layer;

 import org.tigris.gef.base.SaveEPSAction;

 import org.tigris.gef.base.SaveGIFAction;

 import org.tigris.gef.base.SaveGraphicsAction;

 import org.tigris.gef.base.SavePNGAction;

 import org.tigris.gef.base.SavePSAction;

 import org.tigris.gef.base.SaveSVGAction;

 import org.tigris.gef.persistence.SvgWriter2D;

 import org.tigris.gef.persistence.export.PostscriptWriter;

 import org.tigris.gef.presentation.Fig;

 import org.tigris.gef.util.Localizer;

 /**

  * This class has some similar functions like PersistenceManager. <p>

  *

  * It centralizes all knowledge about the different graphical formats.

  * This class is the only one that is supposed to know

  * the complete list of supported graphics formats.

  *

  * @author mvw@tigris.org

  */

 public final class SaveGraphicsManager {

     private static final int MIN_MARGIN = 15;

     /**

      * The configuration key for the preferred graphics format.

      */

     public static final ConfigurationKey KEY_DEFAULT_GRAPHICS_FILTER =

         Configuration.makeKey("graphics", "default", "filter");

     /**

      * The configuration key for the "save graphics" file location.

      */

     public static final ConfigurationKey KEY_SAVE_GRAPHICS_PATH =

         Configuration.makeKey("graphics", "save", "path");

     /**

      * The configuration key for the "save all graphics" file location.

      */

     public static final ConfigurationKey KEY_SAVEALL_GRAPHICS_PATH =

         Configuration.makeKey("graphics", "save-all", "path");

     /**

      * The configuration key for the export graphics resolution.

      */

     public static final ConfigurationKey KEY_GRAPHICS_RESOLUTION =

         Configuration.makeKey("graphics", "export", "resolution");

     /**

      * The default file format.

      */

     private SuffixFilter defaultFilter;

     /**

      * The list of other file formats.

      */

     private List<SuffixFilter> otherFilters = new ArrayList<SuffixFilter>();

     /**

      * The singleton instance.

      */

     private static SaveGraphicsManager instance;

     /**

      * The constructor.

      */

     private SaveGraphicsManager() {

         defaultFilter = FileFilters.PNG_FILTER;

         otherFilters.add(FileFilters.GIF_FILTER);

         otherFilters.add(FileFilters.SVG_FILTER);

         otherFilters.add(FileFilters.PS_FILTER);

         otherFilters.add(FileFilters.EPS_FILTER);

         setDefaultFilterBySuffix(Configuration.getString(

                 KEY_DEFAULT_GRAPHICS_FILTER,

                 defaultFilter.getSuffix()));

     }

     /**

      * @param suffix the extension of the new default file-format

      */

     public void setDefaultFilterBySuffix(String suffix) {

         for (SuffixFilter sf : otherFilters) {

             if (sf.getSuffix().equalsIgnoreCase(suffix)) {

                 setDefaultFilter(sf);

                 break;

             }

         }

     }

     /**

      * @param f the new default file-format

      */

     public void setDefaultFilter(SuffixFilter f) {

         otherFilters.remove(f);

         if (!otherFilters.contains(defaultFilter)) {

             otherFilters.add(defaultFilter);

         }

         defaultFilter = f;

         Configuration.setString(

                 KEY_DEFAULT_GRAPHICS_FILTER,

                 f.getSuffix());

         Collections.sort(otherFilters, new Comparator<SuffixFilter>() {

             public int compare(SuffixFilter arg0, SuffixFilter arg1) {

                 return arg0.getSuffix().compareToIgnoreCase(

                         arg1.getSuffix());

             }

         });

     }

     /**

      * @return returns the singleton

      */

     public static SaveGraphicsManager getInstance() {

         if (instance == null) {

             instance  = new SaveGraphicsManager();

         }

         return instance;

     }

     /**

      * This function allows to add new filters. This can be done e.g.

      * by modules.<p>

      *

      * @param f the filter

      */

     public void register(SuffixFilter f) {

         otherFilters.add(f);

     }

     /**

      * @param chooser the filechooser of which the filters will be set

      * @param defaultName default filename to show when chooser is displayed

      */

     public void setFileChooserFilters(

             JFileChooser chooser, String defaultName) {

         chooser.addChoosableFileFilter(defaultFilter);

         Iterator iter = otherFilters.iterator();

         while (iter.hasNext()) {

             chooser.addChoosableFileFilter((SuffixFilter) iter.next());

         }

         chooser.setFileFilter(defaultFilter);

         String fileName = defaultName + "." + defaultFilter.getSuffix();

         chooser.setSelectedFile(new File(fileName));

         chooser.addPropertyChangeListener(

                 JFileChooser.FILE_FILTER_CHANGED_PROPERTY,

                 new FileFilterChangedListener(chooser, defaultName));

     }

     /**

      * This class listens to changes in the selected filefilter.

      * If the user changes the filefilter

      * (e.g. he changes from *.gif to *.png),

      * then the filename field got emptied before I introduced this class.

      * Now, a new filename is made up, based on

      * the diagram name + the new extension (suffix).

      *

      * @author mvw@tigris.org

      */

     static class FileFilterChangedListener implements PropertyChangeListener {

         private JFileChooser chooser;

         private String defaultName;

         /**

          * Constructor.

          * @param c

          * @param name

          */

         public FileFilterChangedListener(JFileChooser c, String name) {

             chooser = c;

             defaultName = name;

         }

         /*

          * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent)

          */

         public void propertyChange(PropertyChangeEvent evt) {

             SuffixFilter filter = (SuffixFilter) evt.getNewValue();

             String fileName = defaultName + "." + filter.getSuffix();

             /* The next line does not work: */

             // chooser.setSelectedFile(new File(fileName));

             /* So, let's do it the hard way: */

             SwingUtilities.invokeLater(new Anonymous1(fileName));

         }

         class Anonymous1 implements Runnable {

             private String fileName;

             /**

              * Constructor.

              *

              * @param fn The filename.

              */

             Anonymous1(String fn) {

                 fileName = fn;

             }

             /*

              * @see java.lang.Runnable#run()

              */

             public void run() {

                 chooser.setSelectedFile(new File(fileName));

             }

         }

     }

     /**

      * @param name the filename

      * @return the filter

      */

     public SuffixFilter getFilterFromFileName(String name) {

         if (name.toLowerCase()

             .endsWith("." + defaultFilter.getSuffix())) {

             return defaultFilter;

         }

         Iterator iter = otherFilters.iterator();

         while (iter.hasNext()) {

             SuffixFilter filter = (SuffixFilter) iter.next();

             if (name.toLowerCase().endsWith("." + filter.getSuffix())) {

                 return filter;

             }

         }

         return null;

     }

     /**

      * @return the extension of the default filter

      *         (just the text, not the ".")

      */

     public String getDefaultSuffix() {

         return defaultFilter.getSuffix();

     }

     /**

      * @param in the input file or path name which may or may not

      *           have a recognised extension

      * @return the amended file or pathname, guaranteed to have

      *         a recognised extension

      */

     public String fixExtension(String in) {

         if (getFilterFromFileName(in) == null) {

             in += "." + getDefaultSuffix();

         }

         return in;

     }

     /**

      * @param suffix the suffix (extension) of the filename,

      *               which corresponds to the graphics format to be used

      * @return the action that will do the save

      */

     public SaveGraphicsAction getSaveActionBySuffix(String suffix) {

         SaveGraphicsAction cmd = null;

         if (FileFilters.PS_FILTER.getSuffix().equals(suffix)) {

             cmd = new SavePSAction(Translator.localize("action.save-ps"));

         } else if (FileFilters.EPS_FILTER.getSuffix().equals(suffix)) {

             cmd = new SaveScaledEPSAction(

                     Translator.localize("action.save-eps"));

         } else if (FileFilters.PNG_FILTER.getSuffix().equals(suffix)) {

             cmd = new SavePNGAction2(Translator.localize("action.save-png"));

         } else if (FileFilters.GIF_FILTER.getSuffix().equals(suffix)) {

             cmd = new SaveGIFAction(Translator.localize("action.save-gif"));

             // TODO: The following can be used when we drop Java 5 support or

             // when an ImageIO GIF writer plugin is bundled

 //            cmd = new SaveGIFAction2(Translator.localize("action.save-gif"));

         } else if (FileFilters.SVG_FILTER.getSuffix().equals(suffix)) {

             // TODO: Use the SVGWriter2D implementation

 //            cmd = new SaveSVGAction2(Translator.localize("action.save-svg"));

             cmd = new SaveSVGAction(Translator.localize("action.save-svg"));

         }

         return cmd;

     }

     /**

      * @return the complete collection of SuffixFilters,

      *         the first one is the default one

      */

     public List<SuffixFilter> getSettingsList() {

         List<SuffixFilter> c = new ArrayList<SuffixFilter>();

         c.add(defaultFilter);

         c.addAll(otherFilters);

         return c;

     }

     /**

      * Adjust the drawing area so that instead of a tight bounding box, it

      * includes the canvas origin and some space around the lower and right

      * sides so that the elements will be roughly centered. Elements which are

      * off the top or left side of the canvas may still be clipped (ie if the

      * original drawing area had a negative x or y coordinate).

      * 

      * @param area rectangle representing original drawing area

      * @return an expanded rectangle

      */

     static Rectangle adjustDrawingArea(Rectangle area) {

         int xMargin = area.x;

         if (xMargin < 0) {

             xMargin = 0;

         }

         int yMargin = area.y;

         if (yMargin < 0) {

             yMargin = 0;

         }

         int margin = Math.max(xMargin, yMargin);

         if (margin < MIN_MARGIN) {

             margin = MIN_MARGIN;

         }

         return new Rectangle(0, 0, 

                 area.width + (2 * margin), 

                 area.height + (2 * margin));

     }

 }

 class SaveScaledEPSAction extends SaveEPSAction {

     SaveScaledEPSAction(String name) {

         super(name);

     }

     @Override

     protected void saveGraphics(OutputStream s, Editor ce,

                                 Rectangle drawingArea)

         throws IOException {

         double editorScale = ce.getScale();

         int x = (int) (drawingArea.x * editorScale);

         int y = (int) (drawingArea.y * editorScale);

         int h = (int) (drawingArea.height * editorScale);

         int w = (int) (drawingArea.width * editorScale);

         drawingArea = new Rectangle(x, y, w, h);

         PostscriptWriter ps = new PostscriptWriter(s, drawingArea);

         ps.scale(editorScale, editorScale);

         ce.print(ps);

         ps.dispose();

     }

 }

 /**

  * Write out a PNG image of the current diagram using a more memory efficient

  * scheme than GEF uses.

  * 

  * @author Tom Morris <tfmorris@gmail.com>

  */

 class SavePNGAction2 extends SavePNGAction {

     private static final Logger LOG = Logger.getLogger(SavePNGAction2.class);

     SavePNGAction2(String name) {

         super(name);

     }

     @Override

     public void actionPerformed(ActionEvent ae) {

         Editor ce = Globals.curEditor();

         Rectangle drawingArea = 

             ce.getLayerManager().getActiveLayer().calcDrawingArea();

         // If the diagram is empty, GEF won't write anything, leaving us with

         // an empty (and invalid) file.  Handle this case ourselves to prevent

         // this from happening.

         if (drawingArea.width <= 0 || drawingArea.height <= 0) {

             Rectangle dummyArea = new Rectangle(0, 0, 50, 50);

             try {

                 saveGraphics(outputStream, ce, dummyArea);

             } catch (java.io.IOException e) {

                 LOG.error("Error while exporting Graphics:", e);

             }

             return;

         }

         // Anything else is handled the normal way

         super.actionPerformed(ae);

     }

     /**

      * Write the diagram contained by the current editor into an OutputStream as

      * a PNG image.

      */

     @Override

     protected void saveGraphics(OutputStream s, Editor ce, 

             Rectangle drawingArea)

         throws IOException {

         Rectangle canvasArea = 

             SaveGraphicsManager.adjustDrawingArea(drawingArea);

         // Create an image which will do deferred rendering of the GEF

         // diagram on demand as data is pulled from it 

         RenderedImage i = new DeferredBufferedImage(canvasArea,

                 BufferedImage.TYPE_INT_ARGB, ce, scale);

         LOG.debug("Created DeferredBufferedImage - drawingArea = "

                 + canvasArea + " , scale = " + scale);

         ImageIO.write(i, "png", s);

     }

 }

 /**

  * Action to save a diagram as a GIF image in a supplied OutputStream. 

  * 

  * TODO: This requires Java 6 in its current state, so don't use.

  * 

  * @author Tom Morris <tfmorris@gmail.com>

  */

 class SaveGIFAction2 extends SaveGIFAction {

     /**

      * Creates a new SaveGIFAction

      * 

      * @param name The name of the action

      */

     SaveGIFAction2(String name) {

         super(name);

     }

     /**

      * Write the diagram contained by the current editor into an OutputStream as

      * a GIF image.

      */

     @Override

     protected void saveGraphics(OutputStream s, Editor ce, 

             Rectangle drawingArea) throws IOException {

         Rectangle canvasArea = 

             SaveGraphicsManager.adjustDrawingArea(drawingArea);

         RenderedImage i = new DeferredBufferedImage(canvasArea,

                 BufferedImage.TYPE_INT_ARGB, ce, scale);

         // NOTE: GEF's GIF writer uses Jeff Poskanzer's GIF encoder, but that

         // saves a copy of the entire image in an internal buffer before

         // starting work, defeating the whole purpose of our incremental 

         // rendering.

         // Java SE 6 has a native GIF writer, but it's not in Java 5.  One

         // is available in the JAI-ImageIO library, but we don't currently

         // bundle that and at 6+ MB it seems like a heavyweight solution, but

         // I don't have time to produce a stripped down version right now - tfm

         // https://jai-imageio.dev.java.net/

         ImageIO.write(i, "gif", s);

     }

 }

 class SaveSVGAction2 extends SaveGraphicsAction {

     /**

      * Creates a new SaveSVGAction

      * 

      * @param name

      *                The name of the action

      */

     public SaveSVGAction2(String name) {

         this(name, false);

     }

     /**

      * Creates a new SaveSVGAction

      * 

      * @param name

      *                The name of the action

      * @param icon

      *                The icon of the action

      */

     public SaveSVGAction2(String name, Icon icon) {

         this(name, icon, false);

     }

     /**

      * Creates a new SaveSVGAction

      * 

      * @param name

      *                The name of the action

      * @param localize

      *                Whether to localize the name or not

      */

     public SaveSVGAction2(String name, boolean localize) {

         super(localize ? Localizer.localize("GefBase", name) : name);

     }

     /**

      * Creates a new SaveSVGAction

      * 

      * @param name

      *                The name of the action

      * @param icon

      *                The icon of the action

      * @param localize

      *                Whether to localize the name or not

      */

     public SaveSVGAction2(String name, Icon icon, boolean localize) {

         super(localize ? Localizer.localize("GefBase", name) : name, icon);

     }

     protected void saveGraphics(OutputStream s, Editor ce, 

                     Rectangle drawingArea)

         throws IOException {

 //        LayerPerspective layer = DiagramUtils.getActiveDiagram().getLayer();

         Layer layer = ce.getLayerManager().getActiveLayer();

         Rectangle bounds = new Rectangle();

         for (Fig fig : layer.getContents()) {

             bounds.x = Math.min(bounds.x, fig.getX());

             bounds.y = Math.min(bounds.y, fig.getY());

             // we actually are computing max x & max y, not width & height

             bounds.width = Math.max(bounds.width, fig.getX() + fig.getWidth());

             bounds.height = Math.max(bounds.height, 

                     fig.getY() + fig.getHeight());

         }

         // Convert max x/y to width/height

         bounds.width -= bounds.x;

         bounds.height -= bounds.y;

             SvgWriter2D writer = null;

             try {

             // TODO: Do we want the current view or the entire diagram?

 //                drawingArea.width /= ce.getScale();

 //            drawingArea.height /= ce.getScale();

 //            writer = new SvgWriter2D(s, drawingArea);

             writer = new SvgWriter2D(s, bounds);

         } catch (ParserConfigurationException e) {

 //            LOG.error("Exception creating SVG writer", e);

             // Not really kosher, but we are constrained by the method signature

             throw new IOException("Error creating SVGwriter " + e);

         }

         if (writer != null) {

             // We'll do the equivalent of the following ourselves

 //            ce.print(writer);

             for (Fig f : layer.getContents()) {

                 // ignore clipping

                 String url = null;

                 String clazz = null;

                 Object owner = f.getOwner();

                 if (Model.getFacade().isAUMLElement(owner)) {

                     clazz = Model.getMetaTypes().getName(owner);

                     // TODO: toLower?

                     if (Model.getFacade().isAModelElement(owner)) {

                         String name = Model.getFacade().getName(owner);

                         if (name == null) {

                             name = "";

                         }

                         url = "http://argoeclipse.tigris.org" + "#" + name;

                     }

                 }

                 writer.beginFig(f, clazz, url);

                 f.paint(writer);

                 writer.endFig();

             }

             writer.dispose();

         }

     }

 }