source: trunk/src/org/expeditee/gio/swing/SwingClipboardManager.java@ 1436

package org.expeditee.gio.swing;

import java.awt.Toolkit;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.File;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;

import org.expeditee.core.Image;
import org.expeditee.core.Point;
import org.expeditee.gio.ClipboardManager;
import org.expeditee.gio.DragAndDropManager;
import org.expeditee.gio.EcosystemManager;
import org.expeditee.gui.DisplayController;

/** TODO: Comment. cts16 */
public class SwingClipboardManager extends ClipboardManager {

        public static final DataFlavor expediteeDataFlavour = new DataFlavor(Object.class, "expediteeDataFlavour");
        
        // The return flavour of data in preferential order
        public static final DataFlavor[] flavours = {
                        SwingClipboardManager.expediteeDataFlavour,
                        DataFlavor.imageFlavor,
                        DataFlavor.stringFlavor, 
                        DataFlavor.javaFileListFlavor
        };
        
        private static SwingClipboardManager _instance;
        
        public static SwingClipboardManager getInstance()
        {
                if (_instance == null) {
                        _instance = new SwingClipboardManager();
                }
                
                return _instance;
        }
        
        @Override
        public void set(ClipboardData data)
        {
                if (data == null) return;
                
                SwingClipboardGeneralTransferable t = new SwingClipboardGeneralTransferable(data.data);
                t.addImageRepresentation(SwingMiscManager.getIfUsingSwingImageManager().getBufferedImageForImage(data.imageRepresentation));
                t.addStringRepresentation(data.stringRepresentation);
                
                Toolkit.getDefaultToolkit().getSystemClipboard().setContents(t, null);
        }

        @Override
        public ClipboardData get()
        {
                Transferable content = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);
                
                // No clipboard contents
                if (content == null) return null;
                
                ClipboardData ret = new ClipboardData();
                
                // Try each flavour
                for (DataFlavor flavour : flavours) {
                        if (content.isDataFlavorSupported(flavour)) {
                                try {
                                        handleGet(flavour, content, ret);
                                } catch (IOException e) {
                                        // Data stale, just move on to next flavour
                                } catch (UnsupportedFlavorException e) {
                                        // Shouldn't get here because we just checked, but just move on anyway
                                }
                        }
                }
                
                // No supported content
                return ret;
        }
        
        private void handleGet(DataFlavor flavour, Transferable content, ClipboardData out) throws IOException, UnsupportedFlavorException
        {
                if (expediteeDataFlavour.equals(flavour)) {
                        out.data = content.getTransferData(flavour);
                } else if (DataFlavor.imageFlavor.equals(flavour)) {
                        out.imageRepresentation = handleGetImage(content);
                } else if (DataFlavor.stringFlavor.equals(flavour)) {
                        out.stringRepresentation = (String) content.getTransferData(flavour);
                } else if (DataFlavor.javaFileListFlavor.equals(flavour)) {
                        @SuppressWarnings("unchecked")
                        List<File> transferData = (List<File>) content.getTransferData(flavour);
                        out.fileRepresentation = transferData;
                }
        }
        
        private Image handleGetImage(Transferable content) throws IOException, UnsupportedFlavorException
        {
                Object o = content.getTransferData(DataFlavor.imageFlavor);
                
                SwingImageManager manager = SwingMiscManager.getIfUsingSwingImageManager();
                
                if (manager == null) return null;
                
                return manager.createImage((java.awt.Image) o);
        }

        /** TODO: Comment. cts16 */
        private class SwingClipboardGeneralTransferable implements Transferable
        {
                Object _data;
                java.awt.Image _imageRep;
                String _stringRep;
                
                private List<DataFlavor> _flavours;
                
                @SuppressWarnings("unused")
                public SwingClipboardGeneralTransferable()
                {
                        this(null);
                }
                
                public SwingClipboardGeneralTransferable(Object data)
                {
                        _flavours = new LinkedList<DataFlavor>();
                        
                        addGenericRepresentation(data);
                }
                
                public void addGenericRepresentation(Object data)
                {
                        if (data == null) return;
                        
                        _data = data;
                        addDataFlavour(SwingClipboardManager.expediteeDataFlavour);
                }
                
                public void addImageRepresentation(java.awt.Image image)
                {
                        if (image == null) return;
                        
                        _imageRep = image;
                        addDataFlavour(DataFlavor.imageFlavor);
                }
                
                public void addStringRepresentation(String string)
                {
                        if (string == null) return;
                        
                        _stringRep = string;
                        addDataFlavour(DataFlavor.stringFlavor);
                }

                public void addDataFlavour(DataFlavor flavour)
                {
                        _flavours.add(flavour);
                }
                
                @Override
                public DataFlavor[] getTransferDataFlavors()
                {
                        DataFlavor[] ret = new DataFlavor[_flavours.size()];
                        int i = 0;
                        for (DataFlavor flavour : _flavours) {
                                ret[i] = flavour;
                                i++;
                        }
                        return ret;
                }

                @Override
                public boolean isDataFlavorSupported(DataFlavor flavor)
                {
                        for (DataFlavor flavour : _flavours) {
                                if (flavour.equals(flavor)) return true;
                        }
                        return false;
                }

                @Override
                public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException
                {
                        if (isDataFlavorSupported(flavor)) {
                                if (flavor.equals(DataFlavor.imageFlavor)) {
                                        return _imageRep;
                                } else if (flavor.equals(DataFlavor.stringFlavor)) {
                                        return _stringRep;
                                } else {
                                        return _data;
                                }
                        } else {
                                throw new UnsupportedFlavorException(flavor);
                        }
                }
                
        }
        
        
}