/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans-Common is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components.util;
  
  import java.awt.datatransfer.DataFlavor;
  import java.awt.datatransfer.Transferable;
  import java.awt.datatransfer.UnsupportedFlavorException;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseMotionListener;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import javax.swing.JComponent;
  import javax.swing.TransferHandler;
  
  /**
   * <code>CosyTransferHandler</code> is a common TransferHandler for cosy
   * displyers.  
   * 
   * @author Jaka Bobnar, Cosylab
   *
   */
  public abstract class CosyTransferHandler extends TransferHandler implements MouseMotionListener, Transferable {
  
  	public static final void registerTransferHandler(JComponent parent, TransferHandler newT, JComponent... comps) {
  		TransferHandler oldT= parent.getTransferHandler();
      	if (oldT instanceof CosyTransferHandler) {
      		((CosyTransferHandler)oldT).unhookTransferHandler(parent);
      	}
  		for (JComponent comp : comps) {
  	    	if (oldT instanceof CosyTransferHandler) {
  	    		((CosyTransferHandler)oldT).unhookTransferHandler(comp);
  	    	}
  	    	if (newT instanceof CosyTransferHandler) {
  	    		((CosyTransferHandler)newT).hookTransferHandler(comp);
  	    	}
  		}
  	}
  	
  	/**
  	 * <code>MouseFilter</code> can notify if certain MouseEvent can trigger the 
  	 * DnD event.
  	 * 
  	 * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
  	 * @version $Id: CosyTransferHandler.java,v 1.9 2008-04-22 12:28:40 jbobnar Exp $
  	 *
  	 */
  	public static interface MouseFilter {
  		/**
  		 * If the event happened in the area where drag is enabled, this method
  		 * should return true.
  		 * 
  		 * @param e
  		 * @return true if drag is enabled
  		 */
  		public boolean isDragArea(MouseEvent e);
  	}
  	
  	private boolean receiveEnabled=true;
  	private boolean exportEnabled=true;
  	protected boolean isDragging = false;
  	private Set<JComponent> hooked= new HashSet<JComponent>();
  	private List<MouseFilter> filters= new ArrayList<MouseFilter>();	
  	
  	/**
  	 * Creates new instance of CosyTransferHandler.
  	 * @param property
  	 * @param reciveEnabled
  	 * @param exportEnabled
  	 */
  	public CosyTransferHandler(boolean receiveEnabled, boolean exportEnabled) {
  		this.receiveEnabled = receiveEnabled;
  		this.exportEnabled = exportEnabled;
  	}
  	
  	/**
  	 * Hooks transfer handler to the given component, using the exising
  	 * import/export enables flags.
  	 * 
 	 * @param comp
 	 */
 	public void hookTransferHandler(JComponent comp) {
 		hookTransferHandler(comp,receiveEnabled,exportEnabled);
 	}
 	
 	/**
 	 * Unhook transfer handler from the given component.
 	 * @param comp
 	 */
 	public void unhookTransferHandler(JComponent comp) {
 		comp.removeMouseMotionListener(this);
 		hooked.remove(comp);
 	}
 
 	/**
 	 * Hooks transfer handler to the given component. TransferHandler will
 	 * handler only the specified action.
 	 * 
 	 * @param comp component to hook
 	 * @param canReceive true if drop should be enabled
 	 * @param canExport true if drag should be enabled
 	 */
 	public void hookTransferHandler(JComponent comp, boolean canReceive, boolean canExport) {
 		if (hooked.contains(comp)) {
 			return;
 		}
 		if (canExport || canReceive) {
 			hooked.add(comp);
 			comp.setTransferHandler(this);
 		} 
 		if (canExport) {
 			comp.addMouseMotionListener(this);
 		} 		
 	}
 	
 	/**
 	 * Yop may override this method to implement own transferable or override just methods, which are 
 	 * perscribed by transferable.
 	 */
 	@Override
 	protected Transferable createTransferable(final JComponent c) {
 		return this;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.datatransfer.Transferable#getTransferData(java.awt.datatransfer.DataFlavor)
 	 */
 	public abstract Object getTransferData(DataFlavor flavor)
 					throws UnsupportedFlavorException, IOException;
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.datatransfer.Transferable#isDataFlavorSupported(java.awt.datatransfer.DataFlavor)
 	 */
 	public boolean isDataFlavorSupported(DataFlavor flavor) {
 		DataFlavor[] flavors= getTransferDataFlavors();
 		
 		for (DataFlavor f : flavors) {
 			if (f.equals(flavor)) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.datatransfer.Transferable#getTransferDataFlavors()
 	 */
 	public abstract DataFlavor[] getTransferDataFlavors();
 
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.TransferHandler#canImport(javax.swing.JComponent, java.awt.datatransfer.DataFlavor[])
 	 */
 	@Override
 	public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
 		if (!receiveEnabled) return false;
 		for (DataFlavor flavor : transferFlavors) {
 			if (isDataFlavorSupported(flavor)) {
 				return true;
 			}
 		}
 		return false;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.TransferHandler#getSourceActions(javax.swing.JComponent)
 	 */
 	@Override
 	public int getSourceActions(JComponent c) {
 		return TransferHandler.COPY;
 	}
 	
 	protected boolean isMouseDragGesture(MouseEvent e) {
 		return (e.getModifiers()&MouseEvent.BUTTON1)!=MouseEvent.BUTTON1;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
 	 */
 	public void mouseDragged(MouseEvent e) {
 		if (!exportEnabled || !isMouseDragGesture(e)) {
 			return;
 		}
 		
 		for (MouseFilter f : filters) {
 			if (!f.isDragArea(e)) {
 				return;
 			}
 		}
 		//if another MouseMotionListener already exists on that component we have
 		//overriden its previous function. restore.
 		JComponent c = (JComponent)e.getComponent();
 		if (canDrag(c)) {
 			exportAsDrag(c,e,TransferHandler.COPY);
 			isDragging = true;
 		}
     }
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.TransferHandler#exportDone(javax.swing.JComponent, java.awt.datatransfer.Transferable, int)
 	 */
 	@Override
 	protected void exportDone(JComponent source, Transferable data, int action) {
 		super.exportDone(source, data, action);
 		isDragging = false;
 	}
 	
 	/**
 	 * Return true if this component can start drag gesture for provided component.
 	 * Default value is same as dragEnabled;
 	 * @param comp
 	 * @return true if this component can start drag gesture
 	 */
 	protected boolean canDrag(JComponent comp) {
 		return exportEnabled;
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)
 	 */
 	public void mouseMoved(MouseEvent e) {
 	    //
     }
 
 	
 	/**
 	 * Returns true if drag is enabled.
 	 * 
 	 * @return the exportEnabled.
 	 */
 	public boolean isExportEnabled() {
 		return exportEnabled;
 	}
 
 	
 	/**
 	 * Returns true if drop is enabled.
 	 * 
 	 * @return the reciveEnabled.
 	 */
 	public boolean isReceiveEnabled() {
 		return receiveEnabled;
 	}
 	
 	
 	/**
 	 * Enables/disables the drag.
 	 * 
 	 * @param exportEnabled true if drag is enabled
 	 * @param comp component on which the drag should be enabled/disabled
 	 */
 	public void setExportEnabled(boolean exportEnabled, JComponent comp) {
 		if (this.exportEnabled != exportEnabled) {
 			this.exportEnabled = exportEnabled;
 			unhookTransferHandler(comp);
 			hookTransferHandler(comp);
 		}
 	}
 
 	
 	/**
 	 * Enables/disables the drop on the given component
 	 * 
 	 * @param reciveEnabled true if drop should be enabled
 	 * @param comp component on which the drop should be enabled/disabled
 	 */
 	public void setReceiveEnabled(boolean receiveEnabled, JComponent comp) {
 		if (this.receiveEnabled != receiveEnabled) {
 			this.receiveEnabled = receiveEnabled;
 			unhookTransferHandler(comp);
 			hookTransferHandler(comp);
 		}
 	}
 	
 	/**
 	 * Adds a mouse filter to this handler.
 	 * 
 	 * @param f
 	 */
 	public void addMouseFilter(MouseFilter f) {
 		filters.add(f);
 	}
 	
 	/**
 	 * Removes a mouse filter from this handler.
 	 * 
 	 * @param f
 	 */
 	public void removeMouseFilter(MouseFilter f) {
 		filters.remove(f);
 	}
 	
 	/**
 	 * Returns all mouse filters assigned to this handler
 	 * 
 	 * @return
 	 */
 	public MouseFilter[] getMouseFilters() {
 		return filters.toArray(new MouseFilter[filters.size()]);
 	}
 
 }
 
 
 /* __oOo__ */