package atlantis.gui;
 
 import java.awt.Color;
 import java.awt.Graphics;
 import java.awt.GridLayout;
 import java.awt.Image;
 import java.awt.Rectangle;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.image.BufferedImage;
 import java.awt.image.RasterFormatException;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.io.BufferedOutputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 
 import javax.swing.BorderFactory;
 import javax.swing.ButtonGroup;
 import javax.swing.JFileChooser;
 import javax.swing.JMenuBar;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.JRadioButton;
 import javax.swing.JRootPane;
 import javax.swing.filechooser.FileFilter;
 
 import atlantis.Atlantis;
 import atlantis.event.AEvent;
 import atlantis.canvas.ACanvas;
 import atlantis.canvas.ALayout;
 import atlantis.canvas.AWindow;
 import atlantis.graphics.APSGraphics2D;
 import atlantis.graphics.encoders.GifEncoder;
 import atlantis.graphics.encoders.PngEncoder;
 import atlantis.interactions.AZMRInteraction;
 import atlantis.utils.AAtlantisException;
 import atlantis.utils.AUtilities;
 import atlantis.config.ADefaultValues;
 
 
 /**
  * Dialog window for saving a picture of the current canvas. This dialog allows
  * the user to pick the resolution and file type. It also takes care of writing
  * the actual file.
  *
  * @author Eric Jansen
  */
 public class ASaveCanvasFileChooser extends JFileChooser implements PropertyChangeListener {
 
     /** GUI componont that contains the resolution selection panel. */
     private AResolutionChooser resolutionChooser;
 
     /** Possible image widths shown to user. Heights are fixed by layout restrictions. */
     private static int[] IMAGE_WIDTHS = {512, 800, 1024};
 
     /** Default selected image width. Also the (fixed) width of the EPS images. */
     private static int IMAGE_WIDTH_DEFAULT = 2;
 
     /** Active instance of the dialog. */
     private static ASaveCanvasFileChooser instance = null;
 
     /** String holding the default file name, need to be reset after change of file type. */
     private static String defaultFileName = null;
 
     /**
      * Pops up the "Save Canvas" dialog.
      */
     public static void showDialog()
     {
         getInstance();
         String ext = ((AFileFilter) instance.getFileFilter()).getExtension();
         instance.setSelectedFile(new File(defaultFileName + "." + ext));
         instance.showSaveDialog(AGUI.getGUI());
     }
 
 
     public static String getDefaultFileName()
     {
         return defaultFileName;
     }
 
 
     /**
      * Methods returns a singleton instance of this class and creates
      * default name for the target file.
      * @return ASaveCanvasFileChooser
      */
     public static ASaveCanvasFileChooser getInstance()
     {
         if(instance == null)
         {
             instance = new ASaveCanvasFileChooser();
         }
         else
         {
             instance.resolutionChooser.updateResolutions();
         }
 
         defaultFileName = makeEventFileName() + "-" + AUtilities.getDateTimeString();
 
         return instance;
 
     } // getInstance() ------------------------------------------------------
 
 
     /**
      * Constructor. Instead of this, showDialog() should be used to initiate a
      * saving operation. That way there will be only one instance and all user
      * settings will be remembered in a very straightforward way.
      * Hence this constructor is private.
      */
     private ASaveCanvasFileChooser()
     {
         super(ADefaultValues.get("LastCanvasPlotSaveDir"));
 
         addChoosableFileFilter(new AFileFilter("eps", "Encapsulated Postscript (*.eps)"));
         addChoosableFileFilter(new AFileFilter("gif", "Graphics Interchange Format (*.gif)"));
         addChoosableFileFilter(new AFileFilter("png", "Portable Network Graphics (*.png)"));
 
         setAcceptAllFileFilterUsed(false);
         addPropertyChangeListener(this);
         resolutionChooser = new AResolutionChooser();
         setAccessory(resolutionChooser);
         setDialogTitle("Save Canvas");
     }
 
 
 
     /**
      * Grabs canvas and encodes the data in GIF format.
      * @return byte[]
      * @throws IOException
      */
     public byte[] getGIFData() throws IOException
     {
         // Draw image.
         int imageWidth = resolutionChooser.getImageWidth();
         int imageHeight = resolutionChooser.getImageHeight();
         Image image = new BufferedImage(imageWidth, imageHeight,
                 BufferedImage.TYPE_INT_ARGB);
         drawScaledCanvas(image.getGraphics(), imageWidth, imageHeight, "gif");
         ByteArrayOutputStream bs = new ByteArrayOutputStream(102400);
         // Encode as GIF.
         GifEncoder encoder = new GifEncoder(image, bs, true);
         encoder.encode();
         bs.flush();
         return bs.toByteArray();
 
     } // getGIFData() -------------------------------------------------------
 
     /**
      * Grabs canvas and encodes the data in PNG format.
      * @return byte[]
      */
     public byte[] getPNGData()
     {
         // Draw image.
         int imageWidth = resolutionChooser.getImageWidth();
         int imageHeight = resolutionChooser.getImageHeight();
         Image image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB);
         drawScaledCanvas(image.getGraphics(), imageWidth, imageHeight, "png");
 
         // Encode as PNG.
         PngEncoder encoder = new PngEncoder(image, true, PngEncoder.FILTER_NONE, 9);
         byte[] data = encoder.pngEncode();
         return data;
         
     } // getPNGData() -------------------------------------------------------
 
 
     /**
      * Get the currently selected image width.
      * @return selected image width
      */
     public int getImageWidth()
     {
         return resolutionChooser.getImageWidth();
     }
 
 
 
     /**
      * Gets the image height on this button.
      * @return image height
      */
     public int getImageHeight()
     {
         return resolutionChooser.getImageHeight();
     }
 
 
 
     /**
      * Called when the user has selected a file and pushes the save button. This function will only
      * approve the selection when the actual saving was successful.
      */
     public void approveSelection()
     {
         File file = new File(getSelectedFile().getAbsolutePath());
 
         // If the file exists and the user does not want to overwrite it, cancel the save operation.
         // The dialog is still on screen and the user can pick another file.
         if (file.exists() && JOptionPane.showConfirmDialog(AGUI.getGUI(), "File exists, overwrite?",
                 "File exists", JOptionPane.YES_NO_OPTION) != JOptionPane.YES_OPTION)
             return;
 
         // All exceptions are handled equally: the user is sent back to the save canvas dialog.
         try {
             String type = ((AFileFilter)getFileFilter()).getExtension();
             byte[] data;
 
             // Generate the canvas image in memory.
             if (type.equals("eps"))
             {
                 // Since vector images are scalable, the image size only determines the relative size of
                 // the data objects. To make the generated EPS independent of the canvas size, we always
                 // rescale the image to the default size.
                 int imageWidth = IMAGE_WIDTHS[IMAGE_WIDTH_DEFAULT];
                 int imageHeight = resolutionChooser.getImageHeight(imageWidth);
 
                 StringBuffer sb = new StringBuffer(512 * 1024);
                 Rectangle bounds = new Rectangle(0, 0, imageWidth, imageHeight);
                 APSGraphics2D g = new APSGraphics2D(bounds, Color.lightGray, sb);
                 drawScaledCanvas(g, imageWidth, imageHeight, type);
                 g.close();
                 data = sb.toString().getBytes();
 
                 /* experiments with jibble EPS library
                   - requires minor changes in AGraphics and here
                   - search for occurences of APSGraphics
                   - last three calls in this method saving data has to be
                     skipped for jibble EPS as it saved the stream directly
                   - (this) drawScaledCanvas to call window.paint(g) for
                     EpsGraphics2D as well
                 FileOutputStream fos =  new FileOutputStream(file.getAbsolutePath());
                 EpsGraphics2D epsg = new EpsGraphics2D(null, fos, 0, 0, imageWidth, imageHeight);
                 drawScaledCanvas(epsg, imageWidth, imageHeight, type);
                 fos.close();
                 */
             }
             else if (type.equals("gif"))
             {
                 data = getGIFData();
             }
             else if (type.equals("png"))
             {
                 data = getPNGData();
             }
 
             else
             {
                 throw new AAtlantisException("Unknown image type: '" + type + "'");
             }
 
             // And finally write the image to the selected file.
             OutputStream stream = new BufferedOutputStream(new FileOutputStream(file.getAbsolutePath()));
             stream.write(data);
             stream.close();
 
         }
         catch(RasterFormatException e)
         {
             JOptionPane.showMessageDialog(AGUI.getGUI(),
                     "The chosen resolution for canvas is too high, try a lower option!",
                     "Error saving canvas", JOptionPane.INFORMATION_MESSAGE);
             Atlantis.restoreDefaults();
             this.cancelSelection();
         } catch(Exception e)
         {
             // Show a dialog with the error message.
             JOptionPane.showMessageDialog(AGUI.getGUI(), e.getMessage(),
                     "Error saving canvas", JOptionPane.ERROR_MESSAGE);
 
             // The selection is not approved, the user has to select another file or type.
             return;
         }
 
         // This approves the selection and ends the saving processs.
         super.approveSelection();
         ADefaultValues.set("LastCanvasPlotSaveDir", file.getParent() + Atlantis.fileSep);
 
     }
 
     /**
      * Mimics the behavior of a normal canvas paint, but with the canvas scaled to a predefined size.
      * @param g Graphics object to draw on
      * @param imageWidth width of the image
      * @param imageHeight height of the image
      * @param type extension of image
      */
     private static void drawScaledCanvas(Graphics g, int imageWidth, int imageHeight, String type)
     {
         //hide red ZMR center dot
         AZMRInteraction.setPaintCenterDot(false);
         //Auto switch on anti aliasing (too many colors for gif)
         boolean origAlias = APreferencesControl.getAliasMenuItem();
         if(!type.equals("gif") && !origAlias)
             APreferencesControl.setAliasMenuItem(true);
         else if(type.equals("gif") && origAlias)
             APreferencesControl.setAliasMenuItem(false);
         //TODO temporary fix for gif printing
         boolean origFishEye = APreferencesControl.getFisheyeIndicatorMenuItem();
         if(type.equals("gif"))
             APreferencesControl.setFisheyeIndicatorMenuItem(false);
         ACanvas canvas = ACanvas.getCanvas();
         ALayout layout = canvas.getCurrentLayout();
         String[] windows = layout.getWindowNames();
         JRootPane rootPane = canvas.getRootPane();
 
         // Calculate the scale factor.
         double factor = ((double)imageWidth) / rootPane.getWidth();
 
         // Add the title bar, if required.
         JMenuBar title = canvas.getJMenuBar();
         if (title != null)
         {
             int titleWidth = title.getWidth();
             int titleHeight = title.getHeight();
 
             title.setSize(imageWidth, titleHeight);
             title.paint(g);
             title.setSize(titleWidth, titleHeight);
             g.translate(0, titleHeight);
         }
 
         // Loop over all windows.
         for (int i=0; i<windows.length; i++)
         {
             AWindow window = canvas.getWindow(windows[i]);
             int x = window.getX();
             int y = window.getY();
             int width = window.getWidth();
             int height = window.getHeight();
 
             // If the window is visible resize it temporarily and then draw it.
             if (canvas.isReallyOnScreen(window))
             {
                 g.translate((int)(factor*x), (int)(factor*y));
                 
                 // Perhaps I should override window.setSize to automatically validate
                 // This is because AWindow is now a container with a view inside
                 // - Adam
                 window.setSize((int)(factor*width), (int)(factor*height));
                 window.validate();
                 
                 if (g instanceof APSGraphics2D)
                 {
                     window.print(g);
                 }
                 else
                 {
                     window.paint(g);
                 }
                 window.setSize(width, height);
                 window.validate();
                 g.translate(-(int)(factor*x), -(int)(factor*y));
             }
         }
         //TODO temp fix for gif printing
         if(type.equals("gif"))
             APreferencesControl.setFisheyeIndicatorMenuItem(origFishEye);
         //reset alias
         if(!type.equals("gif") && !origAlias)
             APreferencesControl.setAliasMenuItem(origAlias);
         //reset red ZMR center dot
         AZMRInteraction.setPaintCenterDot(true);
     }
 
     /**
      * Property change listener for the JFileChooser
      * @param e property change event sent by JFileChooser
      */
     public void propertyChange(PropertyChangeEvent e)
     {
         if (e.getPropertyName().equals(JFileChooser.FILE_FILTER_CHANGED_PROPERTY))
         {
             String oldExt = ((AFileFilter)e.getOldValue()).getExtension();
             String newExt = ((AFileFilter)e.getNewValue()).getExtension();
 
             if (oldExt.equals("eps") && !newExt.equals("eps"))
             {
                 for (int i=0; i<resolutionChooser.getComponentCount(); i++)
                 {
                     resolutionChooser.getComponent(i).setEnabled(true);
                 }
             }
             else if (!oldExt.equals("eps") && newExt.equals("eps"))
             {
                 for (int i=0; i<resolutionChooser.getComponentCount(); i++)
                     resolutionChooser.getComponent(i).setEnabled(false);
             }
 
             // The behaviour of the JFileChooser is somewhat strange. Regardless of what the user has entered,
             // the input text field will be emptied when the user selects another file type. It is impossible
             // to retrieve the text that was in this field, so we just reset the default file name.
             if (getSelectedFile() == null)
             {
                 // Reset our default with the new extension
                 setSelectedFile(new File(defaultFileName + "." + newExt));
                 updateUI();
             }
         }
     }
 
 
 
     /**
      * Generates a file name based on the current event name and the visible projections.
      * @return auto generated image file name
      */
     private static String makeEventFileName()
     {
         String name = "Untitled";
         AEvent ev = Atlantis.getEventManager().getCurrentEvent();
         if(ev != null)
         {
             name = ev.getName();
             if(name.toLowerCase().endsWith(".xml"))
             {
                 // current event comes from XML file, run and event number
                 // are probably already part of the current filename
                 name = name.substring(0, name.length() - 4);
             }
             else
             {
                 // current event was probably retrieved online, add run and
                 // event numbers into the file name of the canvas plot
                 if(! ("n/a".equals(ev.getRunNumber()) &&
                       "n/a".equals(ev.getEventNumber())))
                 {
                     name += "_" + ev.getRunNumber() + "_" + ev.getEventNumber();
                 }
             }
         }
 
         ACanvas canvas = ACanvas.getCanvas();
         String[] windows = canvas.getCurrentLayout().getWindowNames();
         for(int i = 0; i < windows.length; i++)
         {
             if(canvas.isReallyOnScreen(canvas.getWindow(windows[i])))
             {
                 name += "-" + canvas.getWindow(windows[i]).getProjection().getName();
             }
         }
 
         return name;
     }
 
 
 
     /**
      * GUI component for the resolution selection panel.
      */
     class AResolutionChooser extends JPanel implements ActionListener
     {
         /** Currently selected button. */
         private AResolutionButton selectedButton;
 
         /**
          * Constructor.
          */
         public AResolutionChooser()
         {
             super(new GridLayout(IMAGE_WIDTHS.length+1, 1));
             setBorder(BorderFactory.createTitledBorder(" Resolution: "));
 
             ButtonGroup group = new ButtonGroup();
             for (int i=0; i<IMAGE_WIDTHS.length; i++)
             {
                 int width = IMAGE_WIDTHS[i];
                 int height = getImageHeight(IMAGE_WIDTHS[i]);
 
                 AResolutionButton button = new AResolutionButton(width, height);
                 button.addActionListener(this);
                 if(i == IMAGE_WIDTH_DEFAULT)
                 {
                     selectedButton = button;
                     button.setSelected(true);
                 }
                 group.add(button);
                 add(button);
             }
         }
 
         /**
          * Get the currently selected image width.
          * @return selected image width
          */
         public int getImageWidth()
         {
             return selectedButton.getImageWidth();
         }
 
         /**
          * Gets the currently selected image height.
          * @return selected image height
          */
         public int getImageHeight()
         {
             return selectedButton.getImageHeight();
         }
 
         public void updateResolutions()
         {
             for (int i=0; i<getComponentCount(); i++)
             {
                 if (getComponent(i) instanceof AResolutionButton)
                 {
                     AResolutionButton button = (AResolutionButton)getComponent(i);
                     button.setImageHeight(getImageHeight(button.getImageWidth()));
                 }
             }
         }
 
         /**
          * Calculates the image height that will result if one resizes the current canvas to the given width.
          * @param width canvas width
          * @return corresponding height
          */
         private int getImageHeight(int width)
         {
             ACanvas canvas = ACanvas.getCanvas();
             JRootPane rootPane = canvas.getRootPane();
 
             int canvasWidth = rootPane.getWidth();
             int canvasHeight = rootPane.getHeight();
 
             double factor = ((double)width) / canvasWidth;
 
             JMenuBar title = canvas.getJMenuBar();
             if (canvas.getJMenuBar() != null)
             {
                 int height = title.getHeight();
                 return (int)(factor*(canvasHeight-height)) + height;
             } else {
                 return (int)(factor*canvasHeight);
             }
         }
 
         /**
          * Action listener for the resolution panel.
          * @param e performed action
          */
         public void actionPerformed(ActionEvent e)
         {
             selectedButton = (AResolutionButton)e.getSource();
         }
 
         /**
          * Radio button for the resolution chooser.
          */
         public class AResolutionButton extends JRadioButton
         {
             /** Image width for this button. */
             int imageWidth;
             /** Image height for this button. */
             int imageHeight;
 
             /**
              * Constructor.
              * @param imageWidth image width this button corresponds to
              * @param imageHeight image height this button corresponds to
              */
             public AResolutionButton(int imageWidth, int imageHeight)
             {
                 super(imageWidth + "x" + imageHeight);
                 this.imageWidth = imageWidth;
                 this.imageHeight = imageHeight;
             }
 
             /**
              * Gets the image width on this button.
              * @return image width
              */
             public int getImageWidth()
             {
                 return imageWidth;
             }
 
             /**
              * Gets the image height on this button.
              * @return image height
              */
             public int getImageHeight()
             {
                 return imageHeight;
             }
 
             public void setImageHeight(int imageHeight)
             {
                 this.imageHeight = imageHeight;
                 setText(imageWidth + "x" + imageHeight);
             }
         }
     }
 
     /**
      * Simple filter class that filters files by extension.
      */
     private class AFileFilter extends FileFilter
     {
         /** File extension. */
         private String extension;
         /** Description of the file type this filter shows. */
         private String description;
 
         /**
          * Constructs a file filter.
          * @param extension file extension that passes the filter
          * @param description description of the file type this filter selects
          */
         public AFileFilter(String extension, String description)
         {
             super();
             this.extension = extension;
             this.description = description;
         }
 
         /**
          * Decides if the filter allows a file to pass or not
          * @param f file under consideration
          * @return decision of the filter
          */
         public boolean accept(File f)
         {
             if (f.isDirectory())
             {
                 return true;
             } else if (f.getName().toLowerCase().endsWith(extension))
             {
                 return true;
             } else {
                 return false;
             }
         }
 
         /**
          * Get the extension this filter filters on.
          * @return file extension
          */
         public String getExtension()
         {
             return extension;
         }
 
         /**
          * Get description of the filter.
          * @return description
          */
         public String getDescription()
         {
             return description;
         }
     }
 
 }

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.