// This example is from _Java Examples in a Nutshell_. (http://www.oreilly.com)
// Copyright (c) 1997 by David Flanagan
// This example is provided WITHOUT ANY WARRANTY either expressed or implied.
// You may study, use, modify, and distribute it for non-commercial purposes.
// For any commercial use, see http://www.davidflanagan.com/javaexamples

import java.awt.*;               
import java.awt.event.*;
import java.awt.datatransfer.*;  // Clipboard, Transferable, DataFlavor, etc.
import java.util.Vector;         // To store the scribble in

/** 
 * This class demonstrates how to implement cut-and-paste of data 
 * other than strings.  It is a variant of the Scribble program we've
 * seen so much.  Only about a third of this code is directly cut-and-paste
 * code.  The rest is support code to make this an interesting example
 **/
public class ScribbleCutAndPaste extends Frame {
  /** A very simple main() method for our program. */
  public static void main(String[] args) { new ScribbleCutAndPaste(); }

  /** 
   * Remember # of open windows so we can quit when the last one is closed 
   * We support multiple windows so that we can cut-and-paste among them.
   **/
  protected static int num_windows = 0;

  /** Create a Frame, Menu, and ScrollPane for the scribble component */
  public ScribbleCutAndPaste() {
    super("ScribbleCutAndPaste");            // Create the window
    num_windows++;                           // Count it

    // Create scribble area and add to the frame
    ScribblePanel scribble = new ScribblePanel(this, 400, 300); 
    this.add(scribble, "Center");

    // Set up a menubar
    MenuBar menubar = new MenuBar();         // Create menubar
    this.setMenuBar(menubar);                // Add it to the frame
    Menu file = new Menu("File");            // Create a File menu
    menubar.add(file);                       // Add to menubar

    // Create three menu items, with menu shortcuts, and add to the menu
    MenuItem n, c, q;
    file.add(n = new MenuItem("New Window", new MenuShortcut(KeyEvent.VK_N)));
    file.add(c = new MenuItem("Close Window",new MenuShortcut(KeyEvent.VK_W)));
    file.addSeparator();
    file.add(q = new MenuItem("Quit", new MenuShortcut(KeyEvent.VK_Q)));

    // Create and register action listener objects for the three menu items
    n.addActionListener(new ActionListener() {     // Open a new window
      public void actionPerformed(ActionEvent e) { new ScribbleCutAndPaste(); }
    });
    c.addActionListener(new ActionListener() {     // Close this window
      public void actionPerformed(ActionEvent e) { close(); }
    });
    q.addActionListener(new ActionListener() {     // Quit the program
      public void actionPerformed(ActionEvent e) { System.exit(0); }
    });

    // Another event listener, this one to handle window close requests
    this.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) { close(); }
    });

    // Set the window size and pop it up
    this.pack();
    this.show();
  }

  /** Close a window.  If this is the last open window, just quit. */
  void close() {
    if (--num_windows == 0) System.exit(0);
    else this.dispose();
  }

  /**
   * This class is a custom component that supports scribbling.  It also has
   * a popup menu that provides access to cut-and-paste facilities.
   **/
  static class ScribblePanel extends Canvas implements ActionListener {
    protected short last_x, last_y;                // Coordinates of last click
    protected Vector lines = new Vector(256,256);  // Store the scribbles
    protected int width, height;                   // The preferred size
    protected PopupMenu popup;                     // The popup menu
    protected Frame frame;                         // The frame we are within
    
    /** This constructor requires a Frame and a desired size */
    public ScribblePanel(Frame frame, int width, int height) {
      this.frame = frame;
      this.width = width;
      this.height = height;
      
      // We handle scribbling with low-level events, so we must specify
      // which events we are interested in.
      this.enableEvents(AWTEvent.MOUSE_EVENT_MASK);
      this.enableEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);

      // Create the popup menu.
      String[] labels = new String[] {   "Clear", "Cut", "Copy", "Paste" };
      String[] commands = new String[] { "clear", "cut", "copy", "paste" };
      popup = new PopupMenu();                   // Create the menu
      for(int i = 0; i < labels.length; i++) {
        MenuItem mi = new MenuItem(labels[i]);   // Create a menu item 
        mi.setActionCommand(commands[i]);        // Set its action command
        mi.addActionListener(this);              // And its action listener
        popup.add(mi);                           // Add item to the popup menu
      }
      // Finally, register the popup menu with the component it appears over
      this.add(popup);
    }
    
    /** 
     * Specifies how big the component would like to be.  It always returns the
     * preferred size passed to the ScribblePanel() constructor 
     **/
    public Dimension getPreferredSize() {return new Dimension(width, height);}
    
    /** This is the ActionListener method invoked by the popup menu items */
    public void actionPerformed(ActionEvent event) {
      String command = event.getActionCommand();
      if (command.equals("clear")) clear();
      else if (command.equals("cut")) cut();
      else if (command.equals("copy")) copy();
      else if (command.equals("paste")) paste();
    }
    
    /** Draw all the saved lines of the scribble */
    public void paint(Graphics g) {
      for(int i = 0; i < lines.size(); i++) {
        Line l = (Line)lines.elementAt(i);
        g.drawLine(l.x1, l.y1, l.x2, l.y2);
      }
    }
    
    /** 
     * This is the low-level event-handling method called on mouse events 
     * that do not involve mouse motion.  It handles posting the popup menu
     * and also initiates scribbles
     **/
    public void processMouseEvent(MouseEvent e) {
      if (e.isPopupTrigger())                               // If popup trigger,
        popup.show(this, e.getX(), e.getY());               // Pop up the menu
      else if (e.getID() == MouseEvent.MOUSE_PRESSED) {     // Otherwise
        last_x = (short)e.getX(); last_y = (short)e.getY(); // Save position
      }
      else super.processMouseEvent(e);  // Pass other event types on
    }
    
    /**
     * This method is called for mouse motion events.  It adds a line to the
     * scribble, both on the screen and in the saved representation
     **/
    public void processMouseMotionEvent(MouseEvent e) {
      if (e.getID() == MouseEvent.MOUSE_DRAGGED) {
        Graphics g = getGraphics();                      // Object to draw with
        g.drawLine(last_x, last_y, e.getX(), e.getY());  // Draw this line
        lines.addElement(new Line(last_x, last_y,        // And save it, too.
                                  (short) e.getX(), (short)e.getY()));
        last_x = (short) e.getX();  // Remember current mouse coordinates
        last_y = (short) e.getY(); 
      }
      else super.processMouseMotionEvent(e);  // Important!
    }
    
    /** Clear the scribble.  Invoked by popup menu */
    void clear() {
      lines.removeAllElements();   // Throw out the saved scribble
      repaint();                   // And redraw everything.
    }
    
    /** 
     * The DataFlavor used for our particular type of cut-and-paste data.
     * This one will transfer data in the form of a serialized Vector object.
     * Note that in Java 1.1.1, this works intra-application, but not between
     * applications.  Java 1.1.1 inter-application data transfer is limited to
     * the pre-defined string and text data flavors.
     **/
    public static final DataFlavor dataFlavor =
        new DataFlavor(Vector.class, "ScribbleVectorOfLines");
    
    /** 
     * Copy the current scribble and store it in a SimpleSelection object
     * (defined below).  Then put that object on the clipboard for pasting.
     **/
    public void copy() {
      // Get system clipboard
      Clipboard c = this.getToolkit().getSystemClipboard();
      // Copy and save the scribble in a Transferable object
      SimpleSelection s = new SimpleSelection(lines.clone(), dataFlavor);
      // Put that object on the clipboard
      c.setContents(s, s);
    }
    
    /** Cut is just like a copy, except we erase the scribble afterwards */
    public void cut() { copy(); clear();  }
    
    /** 
     * Ask for the Transferable contents of the system clipboard.
     * Then ask that Transferable object for the scribble data it represents.  
     * If either step fails, beep!
     **/
    public void paste() {
      Clipboard c = this.getToolkit().getSystemClipboard(); // Get clipboard
      Transferable t = c.getContents(this);                 // Get its contents
      if (t == null) {              // If there is nothing to paste, beep
        this.getToolkit().beep();
        return;
      }
      try { 
        // Ask for clipboard contents to be converted to our data flavor.
        // This will throw an exception if our flavor is not supported.
        Vector newlines = (Vector) t.getTransferData(dataFlavor); 
        // Add all those pasted lines to our scribble.
        for(int i = 0; i < newlines.size(); i++)
          lines.addElement(newlines.elementAt(i));
        // And redraw the whole thing
        repaint();  
      }
      catch (UnsupportedFlavorException e) { 
        this.getToolkit().beep();   // If clipboard has some other type of data
      }
      catch (Exception e) {          
        this.getToolkit().beep();   // Or if anything else goes wrong...
      }
    }
    
    /**
     * This nested class implements the Transferable and ClipboardOwner 
     * interfaces used in data transfer.  It is a simple class that remembers
     * a selected object and makes it available in only one specified flavor.
     * It would be useful for transferring other types of data, too.
     **/
    static class SimpleSelection implements Transferable, ClipboardOwner {
      protected Object selection;    // The data to be transferred
      protected DataFlavor flavor;   // The one data flavor supported

      /** The constructor.  Just initialize some fields */
      public SimpleSelection(Object selection, DataFlavor flavor) { 
        this.selection = selection;  // Specify data
        this.flavor = flavor;        // Specify flavor
      }
      
      /** Return the list of supported flavors.  Just one in this case */
      public DataFlavor[] getTransferDataFlavors() { 
        return new DataFlavor[] { flavor };
      }

      /** Check whether we support a specified flavor */
      public boolean isDataFlavorSupported(DataFlavor f) {
        return f.equals(flavor);
      }

      /** If the flavor is right, transfer the data (i.e. return it) */
      public Object getTransferData(DataFlavor f) 
           throws UnsupportedFlavorException {
             if (f.equals(flavor)) return selection;
             else throw new UnsupportedFlavorException(f);
      }
      
      /** 
       * This is the ClipboardOwner method.  Called when the data is no
       * longer on the clipboard.  In this case, we don't need to do much. 
       **/
      public void lostOwnership(Clipboard c, Transferable t) { 
        selection = null; 
      }
    }
    
    /** 
     * A class to store the coordinates of one scribbled line. 
     * The complete scribble is stored as a Vector of these objects 
     **/
    static class Line {
      public short x1, y1, x2, y2;
      public Line(short x1, short y1, short x2, short y2) {
        this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2;
      }
    }
  }
}