Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.swing.impl;

import java.awt.Toolkit;

import java.awt.datatransfer.Clipboard;

import java.awt.datatransfer.ClipboardOwner;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.FlavorEvent;

import java.awt.datatransfer.FlavorListener;

import java.awt.datatransfer.StringSelection;

import java.awt.datatransfer.Transferable;

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import java.util.Observable;

import java.util.Observer;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings(value = {"UseSpecificCatch"})

public class ClipboardMonitor extends Observable implements ClipboardOwner {

    // log4j.logger.org.gvsig.tools.swing.impl.ClipboardMonitor=DEBUG

    private static final Logger LOGGER = LoggerFactory.getLogger(ClipboardMonitor.class);

    private static ClipboardMonitor monitor = null;

    private final Map<Observer,FlavorListener> listeners = new HashMap<>();

    public ClipboardMonitor() {

        gainOwnership();

    }

    public Clipboard getClipboard() {

        Clipboard clip = Toolkit.getDefaultToolkit().getSystemClipboard();

        return clip;

    }

    private void gainOwnership() {

        LOGGER.debug("gainOwnership");

        Clipboard clip = getClipboard();

        try {

            Transferable content = clip.getContents(null);

            clip.setContents(content, this);

            setChanged();

            notifyObservers(content);

        } catch (Exception ex) {

            LOGGER.debug("Can't gain clipboard ownership",ex);

        }

    }

    @Override

    public void lostOwnership(Clipboard clipboard, Transferable contents) {

        LOGGER.debug("lostOwnership");

        new Thread(() -> {

            try {

                Thread.sleep(200);

                gainOwnership();

            } catch (Exception e) {

                LOGGER.debug("Retry gain clipboard ownership failed",e);

            }

        }).start();

    }

    public static final ClipboardMonitor getMonitor() {

        if (monitor == null) {

            monitor = new ClipboardMonitor();

        }

        return monitor;

    }

    public void put(String data) {

        LOGGER.debug("put "+StringUtils.abbreviate(data, 30));

        StringSelection ss = new StringSelection(data);

        Clipboard clip = getClipboard();

        ClipboardOwner owner = ss; // use this as owner don't fire events to observers ??

        clip.setContents(ss, owner);

    }

    public String getString() {

        LOGGER.debug("getString");

        try {

            Clipboard clip = getClipboard();

            Transferable t = clip.getContents(null);

            if(t.isDataFlavorSupported(DataFlavor.stringFlavor)) {

                return (String) (t.getTransferData(DataFlavor.stringFlavor));

            }

        } catch (Exception ex) {

            LOGGER.debug("getString return null",ex);

            return null;

        }

        LOGGER.debug("getString return null");

        return null;

    }

    public boolean hasString() {

        LOGGER.debug("hasString");

        try {

            Clipboard clip = getClipboard();

            boolean available = clip.isDataFlavorAvailable(DataFlavor.stringFlavor);

            return !available;

        } catch (Exception ex) {

            LOGGER.debug("hasString error, return true",ex);

            return true;

        }

    }

    @Override

    public synchronized void addObserver(Observer o) {

        LOGGER.debug("addObserver "+Objects.toString(o));

        if( o==null || listeners.containsKey(o) ) {

            return;

        }

        Clipboard clip = getClipboard();

        FlavorListener listener = (FlavorEvent e) -> { o.update(monitor, null); };

        super.addObserver(o); 

        clip.addFlavorListener(listener);

        listeners.put(o, listener);

    }

    @Override

    public synchronized void deleteObserver(Observer o) {

        LOGGER.debug("deleteObserver"+Objects.toString(o));

        if( o==null ) {

            return;

        }

        Clipboard clip = getClipboard();

        FlavorListener listener = listeners.get(o);

        super.deleteObserver(o); 

        listeners.remove(o);

        if( listener==null ) {

            return;

        }

        clip.removeFlavorListener(listener);

    }

}