/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the Java Umplificator!*/

namespace org.jhotdraw.draw.io ;

class SerializationInputOutputFormat 
{
depend org.jhotdraw.draw.*;
depend java.awt.datatransfer.DataFlavor;
depend java.awt.datatransfer.Transferable;
depend java.awt.datatransfer.UnsupportedFlavorException;
depend java.io.BufferedInputStream;
depend java.io.BufferedOutputStream;
depend java.io.File;
depend java.io.FileInputStream;
depend java.io.FileOutputStream;
depend java.io.IOException;
depend java.io.InputStream;
depend java.io.ObjectInputStream;
depend java.io.ObjectOutputStream;
depend java.io.OutputStream;
depend java.net.URI;
depend java.util.ArrayList;
depend java.util.HashMap;
depend java.util.List;
depend java.util.Map;
depend javax.swing.JComponent;
depend javax.swing.filechooser.FileFilter;
depend org.jhotdraw.gui.datatransfer.AbstractTransferable;
depend org.jhotdraw.gui.filechooser.ExtensionFileFilter;

  /**
     * Format description used for the file filter.
     */
    private String description;
/**
     * File name extension used for the file filter.
     */
    private String fileExtension;
/**
     * Image IO image format name.
     */
    private String formatName;
/**
     * The mime type is used for clipboard access.
     */
    private String mimeType;
/**
     * The data flavor constructed from the mime type.
     */
    private DataFlavor dataFlavor;
private Drawing prototype;
@Override
    public FileFilter getFileFilter() {
        return new ExtensionFileFilter(description, fileExtension);
    }
@Override
    public JComponent getInputFormatAccessory() {
        return null;
    }
@Override
    public void read(URI uri, Drawing drawing) throws IOException {
        read(new File(uri), drawing);
    }
@Override
    public void read(URI uri, Drawing drawing, boolean replace) throws IOException {
        read(new File(uri), drawing, replace);
    }
public void read(File file, Drawing drawing) throws IOException {
        read(file, drawing, true);
    }
public void read(File file, Drawing drawing, boolean replace) throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
        try {
            read(in, drawing, replace);
        } finally {
            in.close();
        }
    }
@SuppressWarnings("unchecked")
    @Override
    public void read(InputStream in, Drawing drawing, boolean replace) throws IOException {
        try {
            ObjectInputStream oin = new ObjectInputStream(in);
            Drawing d = (Drawing) oin.readObject();
            if (replace) {
                for (Map.Entry<AttributeKey, Object> e : d.getAttributes().entrySet()) {
                    drawing.set(e.getKey(), e.getValue());
                }
            }
            for (Figure f : d.getChildren()) {
                drawing.add(f);
            }
        } catch (ClassNotFoundException ex) {
            IOException ioe = new IOException("Couldn't read drawing.");
            ioe.initCause(ex);
            throw ioe;
        }
    }
@Override
    public boolean isDataFlavorSupported(DataFlavor flavor) {
        return flavor.equals(dataFlavor);
    }
@SuppressWarnings("unchecked")
    @Override
    public void read(Transferable t, Drawing drawing, boolean replace) throws UnsupportedFlavorException, IOException {
        try {
            Drawing d = (Drawing) t.getTransferData(dataFlavor);

            if (replace) {
                for (Map.Entry<AttributeKey, Object> e : d.getAttributes().entrySet()) {
                    drawing.set(e.getKey(), e.getValue());
                }
            }
            for (Figure f : d.getChildren()) {
                drawing.add(f);
            }
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }
@Override
    public String getFileExtension() {
        return fileExtension;
    }
@Override
    public JComponent getOutputFormatAccessory() {
        return null;
    }
@Override
    public void write(URI uri, Drawing drawing) throws IOException {
        write(new File(uri),drawing);
    }
public void write(File file, Drawing drawing) throws IOException {
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));
        try {
            write(out, drawing);
        } finally {
            out.close();
        }
    }
@Override
    public void write(OutputStream out, Drawing drawing) throws IOException {
        ObjectOutputStream oout = new ObjectOutputStream(out);
        oout.writeObject(drawing);
        oout.flush();
    }
@SuppressWarnings("unchecked")
    @Override
    public Transferable createTransferable(Drawing drawing, List<Figure> figures, double scaleFactor) throws IOException {
        final Drawing d = (Drawing) prototype.clone();

        HashMap<Figure, Figure> originalToDuplicateMap = new HashMap<Figure, Figure>(figures.size());
        final ArrayList<Figure> duplicates = new ArrayList<Figure>(figures.size());
        for (Figure f : figures) {
            Figure df = (Figure) f.clone();
            d.add(df);
            duplicates.add(df);
            originalToDuplicateMap.put(f, df);
        }
        for (Figure f : duplicates) {
            f.remap(originalToDuplicateMap, true);
        }


        return new AbstractTransferable(dataFlavor) {

            @Override
            public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
                if (isDataFlavorSupported(flavor)) {
                    return d;
                } else {
                    throw new UnsupportedFlavorException(flavor);
                }
            }
        };
    }

}