java/3-4-Undo/ValueUndo/Main.java

+// CS 349 Undo Demo
+
+import javax.swing.*;
+import javax.swing.event.UndoableEditEvent;
+import javax.swing.undo.UndoManager;
+
+import java.awt.Dimension;
+import java.awt.GridLayout;
+import java.awt.event.*;
+
+public class Main {
+	
+	Model model;
+
+	public static void main(String[] args) {
+		new Main();
+	}
+
+	public Main() {
+
+		JFrame frame = new JFrame("UndoDemo");
+
+		// create Model and initialize it
+		// (value, min, max in this model)
+		model = new Model(22, 0, 100);
+
+		// create View
+		View view = new View(model);
+		
+		// create Menu View
+		MainMenuView menuView = new MainMenuView(model);
+
+		// add views to the window
+		frame.getContentPane().add(view);
+		frame.setJMenuBar(menuView);
+
+		frame.setPreferredSize(new Dimension(500, 120));
+		frame.pack();
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		frame.setVisible(true);
+
+		// let all the views know that they're connected to the model
+		model.updateViews();
+	}
+}

java/3-4-Undo/ValueUndo/MainMenuView.java

+// CS 349 Undo Demo
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.util.Observable;
+import java.util.Observer;
+
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.KeyStroke;
+
+
+// a main menu view
+public class MainMenuView extends JMenuBar implements Observer {
+	
+	// Undo menu items
+	private JMenuItem undoMenuItem;
+	private JMenuItem redoMenuItem;
+	
+	// the model that this view is showing
+	private Model model;
+	
+	public MainMenuView(Model model_) {
+		
+		// set the model
+		model = model_;
+		model.addObserver(this);
+		
+		// create a menu UI with undo/redo
+		JMenu fileMenu = new JMenu("File");
+		JMenu editMenu = new JMenu("Edit");
+		this.add(fileMenu);
+		this.add(editMenu);
+		
+		// Create a "quit" menu item and add it to the file menu
+		JMenuItem quitMenuItem = new JMenuItem("Quit");
+		fileMenu.add(quitMenuItem);
+
+		// quit menu controller
+		quitMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent event) {
+				System.exit(0);
+			}
+		});
+
+		// create undo and redo menu items
+		undoMenuItem = new JMenuItem("Undo");
+		undoMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z,
+				ActionEvent.CTRL_MASK));
+		redoMenuItem = new JMenuItem("Redo");
+		redoMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Y,
+				ActionEvent.CTRL_MASK));
+		editMenu.add(undoMenuItem);
+		editMenu.add(redoMenuItem);
+		
+		// controllers for undo menu item
+		undoMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent event) {
+				model.undo();
+			}
+		});
+		// controller for redo menu item
+		redoMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent event) {
+				model.redo();
+			}
+		});
+	}
+
+	@Override
+	public void update(Observable arg0, Object arg1) {
+		undoMenuItem.setEnabled(model.canUndo());
+		redoMenuItem.setEnabled(model.canRedo());	
+	}
+
+}

java/3-4-Undo/ValueUndo/Model.java

+// CS 349 Undo Demo
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.lang.reflect.Field;
+import java.util.Observable;
+
+import javax.swing.undo.*;
+
+// A simple model that is undoable
+public class Model extends Observable {
+
+	// Undo manager
+	private UndoManager undoManager;
+
+	// Model data
+	private int value;
+	private int min;
+	private int max;
+
+	Model(int value, int min, int max) {
+		undoManager = new UndoManager();
+		this.value = value;
+		this.min = min;
+		this.max = max;
+	}
+
+	public void updateViews() {
+		setChanged();
+		notifyObservers();
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public void setValue(int v) {
+		System.out.println("Model: set value to " + v);
+
+		// create undoable edit
+		UndoableEdit undoableEdit = new AbstractUndoableEdit() {
+
+			// capture variables for closure
+			final int oldValue = value;
+			final int newValue = v;
+
+			// Method that is called when we must redo the undone action
+			public void redo() throws CannotRedoException {
+				super.redo();
+				value = newValue;
+				System.out.println("Model: redo value to " + value);
+				setChanged();
+				notifyObservers();
+			}
+
+			public void undo() throws CannotUndoException {
+				super.undo();
+				value = oldValue;
+				System.out.println("Model: undo value to " + value);
+				setChanged();
+				notifyObservers();
+			}
+		};
+
+		// Add this undoable edit to the undo manager
+		undoManager.addEdit(undoableEdit);
+
+		// finally, set the value and notify views
+		value = v;
+		setChanged();
+		notifyObservers();
+	}
+
+	public void incrementValue() {
+		System.out.println("Model: increment value ");
+
+		// constrain value to valid range
+		if (value + 1 > max) return;
+
+		// create undoable edit
+		UndoableEdit undoableEdit = new AbstractUndoableEdit() {
+
+			// Method that is called when we must redo the undone action
+			public void redo() throws CannotRedoException {
+				super.redo();
+				value = value + 1;
+				System.out.println("Model: redo value to " + value);
+				setChanged();
+				notifyObservers();
+			}
+
+			public void undo() throws CannotUndoException {
+				super.undo();
+				value = value - 1;
+				System.out.println("Model: undo value to " + value);
+				setChanged();
+				notifyObservers();
+			}
+		};
+
+		// Add this undoable edit to the undo manager
+		undoManager.addEdit(undoableEdit);
+
+		value = value + 1;
+		setChanged();
+		notifyObservers();
+	}
+
+	public void decrementValue() {
+		System.out.println("Model: decrement value ");
+
+		// constrain value to valid range
+		if (value - 1 < min) return;
+
+		// create undoable edit
+		UndoableEdit undoableEdit = new AbstractUndoableEdit() {
+
+			// Method that is called when we must redo the undone action
+			public void redo() throws CannotRedoException {
+				super.redo();
+				value = value - 1;
+				System.out.println("Model: redo value to " + value);
+				setChanged();
+				notifyObservers();
+			}
+
+			public void undo() throws CannotUndoException {
+				super.undo();
+				value = value + 1;
+				System.out.println("Model: undo value to " + value);
+				setChanged();
+				notifyObservers();
+			}
+		};
+
+		// Add this undoable edit to the undo manager
+		undoManager.addEdit(undoableEdit);
+
+		value = value - 1;
+		setChanged();
+		notifyObservers();
+	}
+
+	// could make these settable and undoable too
+	public int getMin() { return min; }
+	public int getMax() { return max; }
+
+
+	// undo and redo methods
+	// - - - - - - - - - - - - - -
+
+	public void undo() {
+		if (canUndo())
+			undoManager.undo();
+	}
+
+	public void redo() {
+		if (canRedo())
+			undoManager.redo();
+	}
+
+	public boolean canUndo() {
+		return undoManager.canUndo();
+	}
+
+	public boolean canRedo() {
+		return undoManager.canRedo();
+	}
+
+}

java/3-4-Undo/ValueUndo/View.java

+// CS 349 Undo Demo
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.undo.AbstractUndoableEdit;
+import javax.swing.undo.UndoableEdit;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Observable;
+import java.util.Observer;
+
+class View extends JPanel implements Observer {
+
+	// the view's main user interface
+	private JSlider slider;
+	private JTextField text;
+	private JButton increment;
+	private JButton decrement;
+
+	// the model that this view is showing
+	private Model model;
+
+	View(Model model_) {
+
+		// set the model
+		model = model_;
+		model.addObserver(this);
+
+		// create the view UI
+		this.setLayout(new FlowLayout());
+
+		// slider to choose exact value
+		slider = new JSlider();
+		this.add(slider);
+				
+		// text boc to change value
+		text = new JTextField("X", 4);
+		this.add(text);
+
+		// increment/decrement buttons
+		decrement = new JButton("-");
+		increment = new JButton("+");
+		this.add(decrement);
+		this.add(increment);
+
+		this.add(new JLabel("shortcut keys: CTRL-Z to undo, CTRL-Y to redo"));
+
+		// change the flag and see what happens
+		final boolean noChunking = false;
+
+		if (noChunking) {
+			slider.addChangeListener(new ChangeListener() {
+
+				@Override
+				public void stateChanged(ChangeEvent arg0) {
+					model.setValue(slider.getValue());
+				}
+			});
+		} else {
+
+			// controller for when a drag event finishes
+			// this is the right undo "chunk"
+			slider.addMouseListener(new MouseAdapter() {
+				@Override
+				public void mouseReleased(MouseEvent e) {
+					model.setValue(slider.getValue());
+				}
+			});
+		}
+		
+		// add a controller for text edits too
+		// (will only fire when enter is pressed after editing ...)
+		text.addActionListener(new ActionListener() {
+			
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				try {
+					model.setValue(Integer.parseInt(text.getText()));				
+				} catch (NumberFormatException ex) {
+					// not a number, just update views to reset it
+					// (need to be careful here not to insert an undo)
+					model.updateViews();
+				}
+			}
+		});
+
+		increment.addActionListener(new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				model.incrementValue();
+			}
+		});
+
+		decrement.addActionListener(new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				model.decrementValue();
+			}
+		});
+	}
+
+	
+	// Observer interface
+	@Override
+	public void update(Observable arg0, Object arg1) {
+		System.out.println("View: update");
+		slider.setValue(model.getValue());
+		slider.setMinimum(model.getMin());
+		slider.setMaximum(model.getMax());
+		text.setText(Integer.toString(model.getValue()));
+	}
+}

java/3-4-Undo/ValueUndo/makefile

+# super simple makefile
+# call it using 'make NAME=name_of_code_file_without_extension'
+# (assumes a .java extension)
+NAME = "Main"
+
+all:
+	@echo "Compiling..."
+	javac *.java
+
+run: all
+	@echo "Running..."
+	java $(NAME)
+
+clean:
+	rm -rf *.class

java/3-5-Clipboard/ClipboardDemo.java

+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.ClipboardOwner;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.IOException;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.JTextArea;
+
+public class ClipboardDemo extends JPanel implements ClipboardOwner {
+
+    private JTextArea textArea;
+    
+    public ClipboardDemo() {
+        
+        this.setLayout(new FlowLayout());
+
+        // Create a text area for copy and paste tests
+        // Note that by default, text widgets will support keyboard shortcuts
+        // for copy/paste
+        textArea = new JTextArea();
+        textArea.setMinimumSize(new Dimension(300, 150));
+        textArea.setPreferredSize(textArea.getMinimumSize());
+        textArea.setLineWrap(true);
+        textArea.setWrapStyleWord(true);
+        this.add(textArea);
+
+        textArea.setText("Lorem ipsum dolor sit amet, semper dissentiet concludaturque an has, " +
+                         "case vivendo vix an. Probo tempor laoreet quo ad.");
+
+        // Create copy/cut/paste buttons to support manual copying and pasting
+        JButton copyButton = new JButton("Copy");
+        JButton cutButton = new JButton("Cut");
+        JButton pasteButton = new JButton("Paste");
+        this.add(copyButton);
+        this.add(cutButton);
+        this.add(pasteButton);
+
+        // Add action listeners to perform the clipboard operations
+        copyButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                doCopy();
+            }
+        });
+
+        cutButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                doCut();
+            }
+        });
+
+        pasteButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                doPaste();
+            }
+        });
+    }
+    
+    private void doCopy() {
+
+        System.out.println(String.format("COPY: `%s`", textArea.getSelectedText()));
+        
+        // Get the system clipboard
+        Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();
+
+        // Create a transferable object encapsulating all the info for the copy
+        Transferable transferObject = new Transferable() {
+
+            private String text = textArea.getSelectedText();
+            
+            // Returns the copy data
+            public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException ,IOException {
+                System.out.println("  Transferable.getTransferData as " + flavor);
+                if (flavor.equals(DataFlavor.stringFlavor)) {
+                    return text;
+                }
+                throw new UnsupportedFlavorException(flavor);
+            }
+            
+            // Returns the set of data formats we can provide
+            public DataFlavor[] getTransferDataFlavors() {
+                System.out.println("  Transferable.getTransferDataFlavors");
+                return new DataFlavor[] { DataFlavor.stringFlavor };
+            }
+            
+            // Indicates whether we can provide data in the specified format
+            public boolean isDataFlavorSupported(DataFlavor flavor) {
+                System.out.println("  Transferable.isDataFlavorSupported: " + flavor);
+                return flavor.equals(DataFlavor.stringFlavor);
+            }
+        };
+        
+        // Now set the contents of the clipboard to our transferable object
+        // NOTE: The second argument "this" tells the system that this 
+        //       object would like to be the owner of the clipboard.
+        //       As such, this object must implement the ClipboardOwner interface
+        System.out.println("COPY: set system clipboard to Transferable");
+        cb.setContents(transferObject, this);
+    }
+
+    private void doCut() {
+
+        System.out.println("CUT");
+
+        // cut is just a copy that also removes data from document
+        doCopy();
+        textArea.replaceSelection("");
+    }
+    
+    private void doPaste() {
+
+        System.out.println("PASTE");
+        
+        // Grab system clipboard
+        Clipboard systemClipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+
+        System.out.println(String.format("PASTE: %d available flavours ... ",
+                systemClipboard.getAvailableDataFlavors().length));
+        for (DataFlavor f: systemClipboard.getAvailableDataFlavors()) {
+            System.out.println("  " + f.getHumanPresentableName() + "  " + f.toString());
+        }
+
+        // Check if we can get the data as a string
+        if (systemClipboard.isDataFlavorAvailable(DataFlavor.stringFlavor)) {
+            System.out.println("PASTE: DataFlavor.stringFlavor available");
+            try {
+                // Grab the data, set our text area to the data
+                String theText = (String)systemClipboard.getData(DataFlavor.stringFlavor);
+                textArea.replaceSelection(theText);
+                System.out.println("PASTE: '" + theText + "'");
+            } catch (UnsupportedFlavorException e) {
+                e.printStackTrace();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            System.out.println("PASTE: DataFlavor.stringFlavor NOT available");
+        }
+    }
+
+    // Implement the ClipboardOwner interface
+    public void lostOwnership(Clipboard clipboard, Transferable contents) {
+        System.out.println("ClipboardOwner: lost clipboard ownership");
+    }
+
+    public static void main(String[] args) {
+        JFrame f = new JFrame("Clipboard");
+        f.getContentPane().add(new ClipboardDemo());
+        f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        f.pack();
+        f.setVisible(true);
+    }
+}

java/3-5-Clipboard/DragAndDropDemo.java

+import java.awt.*;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.io.IOException;
+import java.io.File;
+
+import javax.swing.*;
+import javax.swing.event.MouseInputAdapter;
+import java.awt.event.MouseEvent;
+
+public class DragAndDropDemo extends JPanel {
+
+    private JLabel imageLabel;
+    private Image image;
+
+    public DragAndDropDemo() {
+
+        setLayout(new GridLayout());
+
+        // drag target
+        imageLabel = new JLabel("", SwingConstants.CENTER);
+        imageLabel.setBackground(Color.WHITE);
+        imageLabel.setOpaque(true);
+        add(imageLabel);
+
+        imageLabel.setTransferHandler(new ImageTransferHandler());
+
+        // create a drag gesture
+        DragGesture dg = new DragGesture();
+        imageLabel.addMouseListener(dg); // For mouseDragged
+        imageLabel.addMouseMotionListener(dg); // For mouseReleased
+    }
+
+    // create an image transfer handler
+    private class ImageTransferHandler extends TransferHandler {
+
+        protected Transferable createTransferable(JComponent c) {
+
+            System.out.println("Creating Transferable");
+
+
+            return new Transferable() {
+
+                public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
+                    if (flavor.equals(DataFlavor.imageFlavor)) {
+                        System.out.println("getTransferData: " + image);
+                        ImageIcon icon = (ImageIcon)imageLabel.getIcon();
+                        if(icon != null){                            
+                            return icon.getImage();
+                        }else{
+                            return null;
+                        }
+                    }
+                    throw new UnsupportedFlavorException(flavor);
+                }
+
+                public DataFlavor[] getTransferDataFlavors() {
+                    return new DataFlavor[] { DataFlavor.imageFlavor };
+                }
+
+                public boolean isDataFlavorSupported(DataFlavor flavor) {
+                    return flavor.equals(DataFlavor.imageFlavor);
+                }
+            };
+        }
+
+
+        public int getSourceActions(JComponent c) {
+            return TransferHandler.COPY;
+        }
+
+        public boolean importData(JComponent c, Transferable t) {
+            System.out.print("importData: ");
+            JLabel label = (JLabel)c;
+
+            imageLabel.setBackground(Color.WHITE);
+
+            if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
+
+                System.out.println("imageFlavour");
+
+                try {
+                    // Get the data and set our label's image icon to the new image.
+                    // Save a copy of the image so we can support dragging it out
+                    image = (Image)t.getTransferData(DataFlavor.imageFlavor);
+
+                    label.setIcon(new ImageIcon(image));
+                } catch (UnsupportedFlavorException e) {
+                    e.printStackTrace();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return true;
+
+            } else if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
+                System.out.println("javaFileListFlavour");
+
+                try {
+                    // Get the data and set our label's image icon to the new image.
+                    java.util.List<File> files = (java.util.List<File>) t.getTransferData(DataFlavor.javaFileListFlavor);
+                    File f = files.get(0);
+
+                    System.out.println("filePath: " + f.getAbsolutePath());
+                    ImageIcon iIcon = new ImageIcon(f.getAbsolutePath());
+                    image = iIcon.getImage();
+                    imageLabel.setIcon(iIcon);
+                } catch (UnsupportedFlavorException e) {
+                    e.printStackTrace();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return true;
+            }
+
+            System.out.println("rejecting");
+            return false;
+        }
+
+        public boolean canImport(JComponent c, DataFlavor[] transferFlavors) {
+
+            for(int i = 0; i < transferFlavors.length; i++) {
+                DataFlavor df = transferFlavors[i];
+                if (df.equals(DataFlavor.imageFlavor) || 
+                    df.equals(DataFlavor.javaFileListFlavor)) {
+                    // feedback to show CAN drag into widget
+                    imageLabel.setBackground(Color.GREEN.brighter());
+                    return true;
+                }
+            }
+            // feedback to show CAN'T drag into widget
+            imageLabel.setBackground(Color.RED.brighter());
+            return false;
+        }
+
+        protected void exportDone(JComponent c, Transferable data, int action) {
+            imageLabel.setBackground(Color.WHITE);
+            System.out.println("exportDone");
+        }
+
+    }
+
+    // A simple recognizer for the drag gesture
+    // The mouseDragged method is called whenever the mouse button is down and
+    // the mouse is moving. We only want to initiate drag & drop, for each drag
+    // gesture. As such, we only take action the first time mouseDragged is called,
+    // resetting whenever the mouse button is released.
+    private class DragGesture extends MouseInputAdapter {
+
+        private boolean armed = true;
+
+        public void mouseDragged(MouseEvent e) {
+
+            // Enter the conditional only once, at the start of the drag
+            if (armed) {
+                System.out.println("Drag starting");
+
+                // Initiate drag and drop
+                JComponent c = (JComponent)e.getSource();
+                TransferHandler handler = c.getTransferHandler();
+                handler.exportAsDrag(c, e, TransferHandler.COPY);
+
+                armed = false;
+            }
+        }
+
+        public void mouseReleased(MouseEvent e) {
+            // Get ready for the next drag
+            armed = true;
+        }
+    }
+
+    public static void main(String[] args) {
+        JFrame f = new JFrame("DragAndDropDemo");
+        f.setSize(200, 200);
+        f.getContentPane().add(new DragAndDropDemo());
+        f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        f.setVisible(true);
+    }
+}

java/3-5-Clipboard/makefile

+# super simple makefile
+# call it using 'make NAME=name_of_code_file_without_extension'
+# (assumes a .java extension)
+NAME = "ClipboardDemo"
+
+all:
+	@echo "Compiling..."
+	javac *.java
+
+run: all
+	@echo "Running..."
+	java $(NAME)
+
+clean:
+	rm -rf *.class

java/3-5-Clipboard/transferDemo/DragableImage.java

+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.MouseInputAdapter;
+
+/*
+ * A DragableImage displays an image and handles drag-and-drop data transfer.
+ */
+class DragableImage extends JComponent {
+
+	private Image image;
+
+	/* Create a image using either getImageFromFile or getEmptyImage */
+    private DragableImage(Image image) {
+        super();
+		this.image = image;
+		this.setFocusable(true);
+		
+		DragGesture dg = new DragGesture();
+		this.addMouseListener(dg);
+        this.addMouseMotionListener(dg);
+		this.addFocusListener(new HighlightWhenFocusedListener());
+    }
+    
+    /* Get an empty image (displays nothing) */
+    public static DragableImage getEmptyImage() {
+    	return new DragableImage(null);
+    }
+    
+    /* Get a image from an image file. */
+    public static DragableImage getImageFromFile(String path) {
+    	if (path == null) {
+    		return new DragableImage(null);
+    	}
+    	
+        java.net.URL imageURL = TransferDemo.class.getResource(path);
+
+        if (imageURL == null) {
+            System.err.println("Resource not found: " + path);
+            return new DragableImage(null);
+        } else {
+            return new DragableImage(new ImageIcon(imageURL, path).getImage());
+        }
+    }
+
+    public void setImage(Image image) {
+        this.image = image;
+        this.repaint();
+    }
+
+    public Image getImage() {
+        return this.image;
+    }
+    
+
+	protected void paintComponent(Graphics graphics) {
+		Graphics g = graphics.create();
+
+		// Draw in our entire space, even if isOpaque is false.
+		g.setColor(Color.WHITE);
+		g.fillRect(0, 0, image == null ? 125 : image.getWidth(this),
+				image == null ? 125 : image.getHeight(this));
+
+		if (image != null) {
+			// Draw image at its natural size of 125x125.
+			g.drawImage(image, 0, 0, this);
+		}
+
+		// Add a border, red if image currently has focus
+		if (this.isFocusOwner()) {
+			g.setColor(Color.RED);
+		} else {
+			g.setColor(Color.BLACK);
+		}
+		g.drawRect(0, 0, image == null ? 125 : image.getWidth(this),
+				image == null ? 125 : image.getHeight(this));
+		g.dispose();
+	}
+	
+	class HighlightWhenFocusedListener implements FocusListener {
+		public void focusGained(FocusEvent e) {
+			// Draw the component with a red border
+			// indicating that it has focus.
+			DragableImage.this.repaint();
+		}
+
+		public void focusLost(FocusEvent e) {
+			// Draw the component with a black border
+			// indicating that it doesn't have focus.
+			DragableImage.this.repaint();
+		}
+
+	}
+	
+	/*---------------------- Drag and Drop support ----------------------*/
+	
+	// MouseInputAdapter implements and provides default methods for 
+	// both MouseListener and MouseMotionListener interfaces.
+	class DragGesture extends MouseInputAdapter {
+	    private MouseEvent firstMouseEvent = null;
+
+	    public void mouseClicked(MouseEvent e) {
+			// Since the user clicked on us, let's get focus!
+			requestFocusInWindow();
+		}	
+		
+	    public void mousePressed(MouseEvent e) {
+
+	        // Don't bother to drag if there is no image.
+	        if (DragableImage.this.image == null) return;
+
+	        firstMouseEvent = e;
+
+	        // prevent any other listeners from acting on this event
+	        e.consume();
+	    }
+	    
+	    public void mouseReleased(MouseEvent e) {
+	        firstMouseEvent = null;
+	    }
+
+	    public void mouseDragged(MouseEvent e) {
+
+            // Don't bother to drag if the component displays no image.
+            if (DragableImage.this.image == null) return;
+
+            if (firstMouseEvent != null) {
+            	// prevent other listeners from acting on this event
+                e.consume();
+
+                int dx = Math.abs(e.getX() - firstMouseEvent.getX());
+                int dy = Math.abs(e.getY() - firstMouseEvent.getY());
+
+                // Arbitrarily define a 5-pixel shift as the
+                // official beginning of a drag.
+                if (dx > 5 || dy > 5) {
+                    // This is a drag, not a click.
+
+                    // If they are holding down the control key, COPY rather than MOVE
+                    int ctrlMask = InputEvent.CTRL_DOWN_MASK;
+                    int action = ((e.getModifiersEx() & ctrlMask) == ctrlMask) ?
+                          TransferHandler.COPY : TransferHandler.MOVE;
+
+                    // drag transfer setup
+                    JComponent c = (JComponent)e.getSource();
+                    TransferHandler handler = c.getTransferHandler();
+                    
+                    // Tell the transfer handler to initiate the drag.
+                    handler.exportAsDrag(c, firstMouseEvent, action);
+
+                    firstMouseEvent = null;
+                }
+            }
+        }	
+	}
+
+}

java/3-5-Clipboard/transferDemo/ImageGridPanel.java

+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+import java.awt.Image;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.ClipboardOwner;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.awt.event.KeyEvent;
+import java.io.IOException;
+
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JPanel;
+import javax.swing.KeyStroke;
+
+public class ImageGridPanel extends JPanel implements ClipboardOwner {
+
+	// Show up to 12 images
+	private DragableImage[] pics = new DragableImage[12];
+
+	// Data to load images into some of the 12 images.
+	private String[] picNames =
+			new String[] { "angry", "happy", "worried",  "laughing" };
+
+	// currently selected image index (-1 if none selected)
+	private int selectedPic = -1;
+	
+	// Buttons to make Cut/Copy/Paste visible
+	private JButton cutButton = new JButton("Cut");
+	private JButton copyButton = new JButton("Copy");
+	private JButton pasteButton = new JButton("Paste");
+
+	public ImageGridPanel() {
+		super(new BorderLayout());
+		this.layoutComponent();
+		this.registerControllers();
+	}
+	
+	private void layoutComponent() {
+
+		JPanel images = new JPanel(new GridLayout(3, 4));
+
+		for (int i = 0; i < this.pics.length; i++) {
+			if (i < this.picNames.length) {
+				this.pics[i] = DragableImage.getImageFromFile("images/"
+						+ picNames[i] + ".jpg");
+			} else {
+				this.pics[i] = DragableImage.getEmptyImage();
+			}
+			images.add(this.pics[i]);
+		}
+		this.add(images, BorderLayout.CENTER);
+
+		this.setPreferredSize(new Dimension(630, 520));
+		this.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
+
+		// out cut/copy/paste buttons into bottom panel
+		JPanel buttons = new JPanel(new FlowLayout(FlowLayout.LEFT));
+
+		buttons.add(cutButton);
+		buttons.add(copyButton);
+		buttons.add(pasteButton);
+
+		this.add(buttons, BorderLayout.NORTH);
+		
+	}
+	
+	private void registerControllers() {
+		// The transfer handler handles the drag-drop and cut-paste
+		// infrastructure
+		ImageTransferHandler picHandler = new ImageTransferHandler();
+		// This maintains the index of the currently selected image
+		// (this.selectedPic)
+		FocusListener fl = new PicFocusListener();
+		
+		for (int i = 0; i < this.pics.length; i++) {
+			this.pics[i].setTransferHandler(picHandler);
+			this.pics[i].addFocusListener(fl);
+		}
+		
+		cutButton.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				doCut();
+			}
+		});
+		
+		copyButton.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				doCopy();
+			}
+		});
+		
+		pasteButton.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				doPaste();
+			}
+		});
+
+	}
+	
+	// Called when this component no longer owns the clipboard
+	public void lostOwnership(Clipboard clipboard, Transferable contents) {
+		System.out.println("Lost clipboard ownership for " + selectedPic);
+	}
+	
+
+	/*
+	 * Copy the currently selected image.
+	 */
+	private void doCopy() {
+
+		// Get the system clipboard
+		Clipboard systemClipboard = Toolkit.getDefaultToolkit()
+				.getSystemClipboard();
+
+		// Create a transferable object encapsulating all the info for the copy
+		Transferable transferObject = new ImageTransferable(pics[selectedPic]);
+
+		// Now set the contents of the clipboard to our transferable object
+		systemClipboard.setContents(transferObject, this);
+		
+	}
+
+	private void doCut() {
+		this.doCopy(); // most of a cut is the same as a copy
+		this.pics[selectedPic].setImage(null);
+	}
+
+	private void doPaste() {
+
+		// Grab system clipboard
+		Clipboard systemClipboard = Toolkit.getDefaultToolkit()
+				.getSystemClipboard();
+
+		// For our own edification, print out the data formats available on the
+		// clipboard
+		for (DataFlavor flavor : systemClipboard.getAvailableDataFlavors()) {
+			System.out.println("Flavor: " + flavor);
+		}
+
+		// Check if we can get the data as an image
+		if (systemClipboard.isDataFlavorAvailable(DataFlavor.imageFlavor)) {
+			try {
+				// Grab the data, set the selected image to the provided image
+				Image img = (Image) systemClipboard
+						.getData(DataFlavor.imageFlavor);
+				assert img != null;
+				this.pics[selectedPic].setImage(img);
+			} catch (UnsupportedFlavorException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	/*
+	 * A listener to help us keep track of which image has been selected.
+	 */
+	class PicFocusListener implements FocusListener {
+		public void focusGained(FocusEvent e) {
+			Component c = e.getComponent();
+			for (int i = 0; i < pics.length; i++) {
+				if (pics[i] == c) {
+					selectedPic = i;
+					return;
+				}
+			}
+			assert false;
+		}
+
+		public void focusLost(FocusEvent e) {
+		}
+	}
+
+
+	/*
+	 * Create a set of cut/copy/paste menus. They call doCopyOrCut and doPaste.
+	 */
+	public JMenuBar createMenuBar() {
+		JMenuBar menubar = new JMenuBar();
+
+		JMenu file = new JMenu("File");
+
+		JMenuItem quit = new JMenuItem("Quit");
+		quit.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				System.exit(0);
+			}
+		});
+		quit.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q,
+				ActionEvent.META_MASK));
+		file.add(quit);
+
+		JMenu edit = new JMenu("Edit");
+		JMenuItem cut = new JMenuItem("Cut");
+		cut.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				doCut();
+			}
+		});
+		cut.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X,
+				ActionEvent.META_MASK));
+
+		JMenuItem copy = new JMenuItem("Copy");
+		copy.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				doCopy();
+			}
+		});
+		copy.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,
+				ActionEvent.META_MASK));
+
+		JMenuItem paste = new JMenuItem("Paste");
+		paste.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				doPaste();
+			}
+		});
+		paste.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V,
+				ActionEvent.META_MASK));
+
+		edit.add(cut);
+		edit.add(copy);
+		edit.add(paste);
+
+		menubar.add(file);
+		menubar.add(edit);
+		return menubar;
+	}
+}

java/3-5-Clipboard/transferDemo/ImageTransferHandler.java

+import java.io.*;
+import java.awt.*;
+import java.awt.datatransfer.*;
+import javax.swing.*;
+import java.util.List;
+
+class ImageTransferHandler extends TransferHandler {
+
+    DragableImage sourceImage;
+    boolean shouldRemove;
+
+    /* 
+     * Can we import one of the flavors provided? 
+     */
+    public boolean canImport(JComponent c, DataFlavor[] flavors) {
+        for (int i = 0; i < flavors.length; i++) {
+            if (flavors[i].equals(DataFlavor.imageFlavor) ||
+                    flavors[i].equals(DataFlavor.javaFileListFlavor)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /* 
+     * Import the data from the transferable to the component.
+     */
+    public boolean importData(JComponent c, Transferable t) {
+        Image image;
+        if (canImport(c, t.getTransferDataFlavors())) {
+            DragableImage dragableImage = (DragableImage)c;
+            //Don't drop on myself.
+            if (sourceImage == dragableImage) {
+                shouldRemove = false;
+                return true;
+            }
+            
+            try {
+            	if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
+            		image = (Image)t.getTransferData(DataFlavor.imageFlavor);
+            	} else if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
+                	List<File> files = (List<File>) t.getTransferData(DataFlavor.javaFileListFlavor);
+                    File f = files.get(0);
+                	ImageIcon iIcon = new ImageIcon(f.getAbsolutePath());
+                    image = iIcon.getImage();
+            	} else {
+            		image = null;	// assure compiler everything was initialized
+            		assert false;
+            	}
+                //Set the component to the new image.
+                dragableImage.setImage(image);
+                return true;
+            } catch (UnsupportedFlavorException ufe) {
+                System.out.println("importData: unsupported data flavor");
+            } catch (IOException ioe) {
+                System.out.println("importData: I/O exception");
+            }
+        }
+        return false;
+    }
+
+    /* 
+     * What kinds of drag actions can we support?
+     */
+    public int getSourceActions(JComponent c) {
+        return COPY_OR_MOVE;
+    }
+
+    /*
+     * Create a transferable to drag somewhere else.
+     */
+    protected Transferable createTransferable(JComponent c) {
+        sourceImage = (DragableImage)c;
+        shouldRemove = true;
+        return new ImageTransferable(sourceImage);
+    }
+
+    /*
+     * Finish the export.
+     */
+    protected void exportDone(JComponent c, Transferable data, int action) {
+        if (shouldRemove && (action == MOVE)) {
+            sourceImage.setImage(null);
+        }
+        sourceImage = null;
+    }
+}

java/3-5-Clipboard/transferDemo/ImageTransferable.java

+import java.awt.Image;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+
+/*
+ * Transfer an image from one source to another.
+ */
+public class ImageTransferable implements Transferable {
+
+    private Image image;
+
+    ImageTransferable(DragableImage pic) {
+        image = pic.getImage();
+    }
+
+    public Object getTransferData(DataFlavor flavor)
+        throws UnsupportedFlavorException {
+        if (!isDataFlavorSupported(flavor)) {
+            throw new UnsupportedFlavorException(flavor);
+        } 
+        return image;
+    }
+
+    public DataFlavor[] getTransferDataFlavors() {
+        return new DataFlavor[] { DataFlavor.imageFlavor };
+    }
+
+    public boolean isDataFlavorSupported(DataFlavor flavor) {
+        return flavor.equals(DataFlavor.imageFlavor);
+    }
+}
+

java/3-5-Clipboard/transferDemo/TransferDemo.java

+/*
+ * This demo started life as part of Sun's Java Tutorial for Drag and Drop/Cut and Paste.
+ * The tutorial had already been updated to Java 6 (which includes changes to
+ * TransferHandler that I didn't want to use yet), so a cached version was found
+ * at http://mockus.us/optimum/JavaTutorial/mustang/uiswing/dnd/examples/index.html#DragPictureDemo
+ * (retrieved June 17, 2009).
+ * 
+ * It was modified by Byron Weber Becker as follows:
+ * -- code to initialize the pictures was simplified with an array and loop
+ * -- removed unused imports 
+ * -- used inner classes for listeners rather than exposing the
+ *    methods in a class's public interface
+ * -- there were funny inheritance interactions between DragablePicture and Picture
+ *    in the mouse and mousemotion listeners, so combined the two classes
+ * -- added support for the javaFileList data flavor, enabling drag 'n drop
+ *    from the desktop and to other applications such as image editors
+ * -- removed the copy/cut/paste magic using action maps and the automatic 
+ *    stuff in TransferHandler and replaced it with direct and easier to
+ *    understand implementations.
+ */
+
+import javax.swing.*;
+
+public class TransferDemo  {
+
+    /**
+     * Create the GUI and show it.  For thread safety,
+     * this method should be invoked from the
+     * event-dispatching thread.
+     */
+    private static void createAndShowGUI() {
+
+        //Create and set up the window.
+        JFrame frame = new JFrame("TransferDemo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+        //Create and set up the menu bar and content pane.
+        ImageGridPanel demo = new ImageGridPanel();
+        frame.setContentPane(demo);
+        frame.setJMenuBar(demo.createMenuBar());
+        
+        //Display the window.
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    public static void main(String[] args) {
+    	System.out.println("You may need to copy the images directory from the");
+    	System.out.println("source code directory to the same directory as TransferDemo.class.");
+
+        //Schedule a job for the event-dispatching thread:
+        //creating and showing this application's GUI.
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            public void run() {
+                createAndShowGUI();
+            }
+        });
+    }
+}

java/3-5-Clipboard/transferDemo/makefile

+# super simple makefile
+# call it using 'make NAME=name_of_code_file_without_extension'
+# (assumes a .java extension)
+NAME = "TransferDemo"
+
+all:
+	@echo "Compiling..."
+	javac $(NAME).java
+
+run: all
+	@echo "Running..."
+	java $(NAME)
+
+clean:
+	rm -rf *.class

x/1-5-Events/eventloop.cpp

@@ -219,7 +219,7 @@ void initX(int argc, char* argv[], XInfo& xinfo) {
     XSetBackground( xinfo.display, xinfo.gc, background );
     XSetForeground( xinfo.display, xinfo.gc, foreground );
 
-    // Tell the window manager what input events you want.
+    // Tell the base window system what input events you want.
     // ButtomMotionMask: The client application receives MotionNotify events only when at least one button is pressed.
     XSelectInput( xinfo.display, xinfo.window,
                   ButtonPressMask | KeyPressMask | ButtonMotionMask );