/* Demo.java -- And example of copy/paste datatransfer
Copyright (C) 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath examples.
GNU Classpath 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 2, or (at your option)
any later version.
GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA. */
package gnu.classpath.examples.datatransfer;
import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
import java.io.*;
import java.net.URL;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Random;
/**
* An example how datatransfer works for copying and pasting data to
* and from other programs.
*/
class Demo
extends Frame
implements ActionListener, ItemListener, FlavorListener
{
public static void main(String args[])
{
new Demo();
}
private TextArea text;
private Button copyText;
private Button pasteText;
private ImageComponent image;
private Button copyImage;
private Button pasteImage;
private ObjectComponent object;
private Button copyObject;
private Button pasteObject;
private FilesComponent files;
private Button copyFiles;
private Button pasteFiles;
private FlavorsComponent flavors;
private FlavorDetailsComponent details;
private Demo()
{
super("GNU Classpath datatransfer");
/* Add all the different panel to the main window in one row. */
setLayout(new GridLayout(5, 1, 10, 10));
add(createTextPanel());
add(createImagePanel());
add(createObjectPanel());
add(createFilesPanel());
add(createFlavorsPanel());
/* Add listeners for the various buttons and events we are
interested in. */
addWindowListener(new WindowAdapter ()
{
public void windowClosing (WindowEvent e)
{
dispose();
}
});
flavors.addItemListener(this);
Toolkit t = Toolkit.getDefaultToolkit();
Clipboard c = t.getSystemClipboard();
c.addFlavorListener(this);
/* Show time! */
pack();
show();
}
/**
* The Text Panel will show simple text that can be copied and pasted.
*/
private Panel createTextPanel()
{
Panel textPanel = new Panel();
textPanel.setLayout(new BorderLayout());
text = new TextArea("GNU Everywhere!",
2, 80,
TextArea.SCROLLBARS_VERTICAL_ONLY);
text.setEditable(false);
text.setEnabled(true);
Panel textButtons = new Panel();
textButtons.setLayout(new FlowLayout());
copyText = new Button("Copy text");
copyText.addActionListener(this);
pasteText = new Button("Paste text");
pasteText.addActionListener(this);
textButtons.add(copyText);
textButtons.add(pasteText);
textPanel.add(text, BorderLayout.CENTER);
textPanel.add(textButtons, BorderLayout.SOUTH);
return textPanel;
}
/**
* The Image Panel shows an image that can be copied to another
* program or be replaced by pasting in an image from another
* application.
*/
private Panel createImagePanel()
{
Panel imagePanel = new Panel();
imagePanel.setLayout(new BorderLayout());
URL imageurl = this.getClass()
.getResource("/gnu/classpath/examples/icons/big-fullscreen.png");
Image img = Toolkit.getDefaultToolkit().createImage(imageurl);
image = new ImageComponent(img);
Panel imageButtons = new Panel();
copyImage = new Button("Copy image");
copyImage.addActionListener(this);
pasteImage = new Button("Paste image");
pasteImage.addActionListener(this);
imageButtons.add(copyImage);
imageButtons.add(pasteImage);
imagePanel.add(image, BorderLayout.CENTER);
imagePanel.add(imageButtons, BorderLayout.SOUTH);
return imagePanel;
}
/**
* The Object Panel holds a simple (Point) object that can be copied
* and pasted to another program that supports exchanging serialized
* objects.
*/
private Panel createObjectPanel()
{
Panel objectPanel = new Panel();
objectPanel.setLayout(new BorderLayout());
Random random = new Random();
int x = (byte) random.nextInt();
int y = (byte) random.nextInt();
object = new ObjectComponent(new Point(x, y));
Panel objectButtons = new Panel();
copyObject = new Button("Copy object");
copyObject.addActionListener(this);
pasteObject = new Button("Paste object");
pasteObject.addActionListener(this);
objectButtons.add(copyObject);
objectButtons.add(pasteObject);
objectPanel.add(object, BorderLayout.CENTER);
objectPanel.add(objectButtons, BorderLayout.SOUTH);
return objectPanel;
}
/**
* The Files Panel shows the files from the current working
* directory. They can be copied and pasted between other
* applications that support the exchange of file lists.
*/
private Panel createFilesPanel()
{
Panel filesPanel = new Panel();
filesPanel.setLayout(new BorderLayout());
files = new FilesComponent(new File(".").listFiles());
Panel filesButtons = new Panel();
copyFiles = new Button("Copy files");
copyFiles.addActionListener(this);
pasteFiles = new Button("Paste files");
pasteFiles.addActionListener(this);
filesButtons.add(copyFiles);
filesButtons.add(pasteFiles);
filesPanel.add(files, BorderLayout.CENTER);
filesPanel.add(filesButtons, BorderLayout.SOUTH);
return filesPanel;
}
/**
* The Flavors Panel shows the different formats (mime-types) that
* data on the clipboard is available in. By clicking on a flavor
* details about the representation class and object is given.
*/
private Panel createFlavorsPanel()
{
Panel flavorsPanel = new Panel();
flavorsPanel.setLayout(new BorderLayout());
Label flavorsHeader = new Label("Flavors on clipboard:");
Toolkit t = Toolkit.getDefaultToolkit();
Clipboard c = t.getSystemClipboard();
DataFlavor[] dataflavors = c.getAvailableDataFlavors();
flavors = new FlavorsComponent(dataflavors);
details = new FlavorDetailsComponent(null);
flavorsPanel.add(flavorsHeader, BorderLayout.NORTH);
flavorsPanel.add(flavors, BorderLayout.CENTER);
flavorsPanel.add(details, BorderLayout.SOUTH);
return flavorsPanel;
}
/**
* FlavorListener implementation that updates the Flavors Panel
* whenever a change in the mime-types available has been detected.
*/
public void flavorsChanged(FlavorEvent event)
{
Toolkit t = Toolkit.getDefaultToolkit();
Clipboard c = t.getSystemClipboard();
DataFlavor[] dataflavors = c.getAvailableDataFlavors();
flavors.setFlavors(dataflavors);
details.setDataFlavor(null);
}
/**
* ItemChangeListener implementation that updates the flavor details
* whenever the user selects a different representation of the data
* available on the clipboard.
*/
public void itemStateChanged(ItemEvent evt)
{
DataFlavor df = null;
String s = flavors.getSelectedItem();
if (s != null)
{
try
{
df = new DataFlavor(s);
}
catch (ClassNotFoundException cnfe)
{
cnfe.printStackTrace();
}
}
details.setDataFlavor(df);
}
/**
* ActionListener implementations that will copy or past data
* to/from the clipboard when the user requests that for the text,
* image, object of file component.
*/
public void actionPerformed (ActionEvent evt)
{
Button b = (Button) evt.getSource();
Toolkit t = Toolkit.getDefaultToolkit();
Clipboard c = t.getSystemClipboard();
if (b == copyText)
c.setContents(new StringSelection(text.getText()), null);
if (b == pasteText)
{
String s = null;
try
{
s = (String) c.getData(DataFlavor.stringFlavor);
}
catch (UnsupportedFlavorException dfnse)
{
}
catch (IOException ioe)
{
}
catch (ClassCastException cce)
{
}
if (s == null)
t.beep();
else
text.setText(s);
}
if (b == copyImage)
c.setContents(new ImageSelection(image.getImage()), null);
if (b == pasteImage)
{
Image i = null;
try
{
i = (Image) c.getData(DataFlavor.imageFlavor);
}
catch (UnsupportedFlavorException dfnse)
{
}
catch (IOException ioe)
{
}
catch (ClassCastException cce)
{
}
if (i == null)
t.beep();
else
image.setImage(i);
}
if (b == copyObject)
c.setContents(new ObjectSelection(object.getObject()), null);
if (b == pasteObject)
{
Serializable o = null;
try
{
o = (Serializable) c.getData(ObjectSelection.objFlavor);
}
catch (UnsupportedFlavorException dfnse)
{
}
catch (IOException ioe)
{
}
catch (ClassCastException cce)
{
}
if (o == null)
t.beep();
else
object.setObject(o);
}
if (b == copyFiles)
c.setContents(new FilesSelection(files.getFiles()), null);
if (b == pasteFiles)
{
java.util.List fs = null;
try
{
fs = (java.util.List) c.getData(DataFlavor.javaFileListFlavor);
}
catch (UnsupportedFlavorException dfnse)
{
}
catch (IOException ioe)
{
}
catch (ClassCastException cce)
{
}
if (fs == null)
t.beep();
else
files.setFiles(fs);
}
}
/**
* Simple awt component that shows an settable image.
*/
static class ImageComponent extends Component
{
private Image image;
ImageComponent(Image image)
{
setSize(20, 20);
setImage(image);
}
Image getImage()
{
return image;
}
void setImage(Image image)
{
this.image = image;
repaint();
}
public void paint(Graphics g)
{
g.drawImage(image, 0, 0, getWidth(), getHeight(), this);
}
}
/**
* Simple awt component that shows a settable Serializable object.
*/
static class ObjectComponent extends TextArea
{
private Serializable object;
ObjectComponent(Serializable object)
{
super("", 2, 80, TextArea.SCROLLBARS_NONE);
setEditable(false);
setEnabled(false);
setObject(object);
}
Serializable getObject()
{
return object;
}
void setObject(Serializable object)
{
this.object = object;
setText("Class: " + object.getClass().getName()
+ "\n"
+ "toString(): " + object.toString());
repaint();
}
}
/**
* Simple awt component that shows a settable list of Files.
*/
static class FilesComponent extends List
{
private File[] files;
FilesComponent(File[] files)
{
super(4, true);
setFiles(files);
}
File[] getFiles()
{
String[] strings = getSelectedItems();
if (strings == null || strings.length == 0)
return (File[]) files.clone();
File[] fs = new File[strings.length];
for (int i = 0; i < strings.length; i++)
fs[i] = new File(strings[i]);
return fs;
}
void setFiles(File[] files)
{
this.files = files;
removeAll();
for (int i = 0; i < files.length; i++)
{
addItem(files[i].toString());
select(i);
}
}
void setFiles(java.util.List list)
{
File[] fs = new File[list.size()];
int i = 0;
Iterator it = list.iterator();
while (it.hasNext())
fs[i++] = (File) it.next();
setFiles(fs);
}
}
/**
* Simple awt component that shows a settable list of DataFlavors.
*/
static class FlavorsComponent extends List
{
FlavorsComponent(DataFlavor[] flavors)
{
super(4);
setFlavors(flavors);
}
void setFlavors(DataFlavor[] flavors)
{
removeAll();
for (int i = 0; i < flavors.length; i++)
{
addItem(flavors[i].getMimeType());
}
}
}
/**
* Simple awt component that shows the details for and an object as
* found on the system clipboard as represented by a given
* DataFlavor.
*/
static class FlavorDetailsComponent extends TextArea
{
private DataFlavor df;
FlavorDetailsComponent(DataFlavor df)
{
super("", 2, 80, TextArea.SCROLLBARS_NONE);
setEditable(false);
setEnabled(false);
setDataFlavor(df);
}
void setDataFlavor(DataFlavor df)
{
if (df == this.df
|| (df != null && df.equals(this.df)))
return;
this.df = df;
if (df == null)
setText("No flavor selected");
else
{
Object o = null;
Throwable exception = null;
try
{
Toolkit t = Toolkit.getDefaultToolkit();
Clipboard c = t.getSystemClipboard();
o = c.getData(df);
}
catch (Throwable t)
{
exception = t;
}
if (o != null)
{
setText("Data: " + o.getClass().getName()
+ "\n"
+ o);
}
else
{
setText("Error retrieving: " + df
+ "\n"
+ exception != null ? exception.toString() : "");
}
}
repaint();
}
}
/**
* Helper class to put an Image on a clipboard as
* DataFlavor.imageFlavor.
*/
static class ImageSelection implements Transferable
{
private final Image img;
ImageSelection(Image img)
{
this.img = img;
}
static DataFlavor[] flavors = new DataFlavor[] { DataFlavor.imageFlavor };
public DataFlavor[] getTransferDataFlavors()
{
return (DataFlavor[]) flavors.clone();
}
public boolean isDataFlavorSupported(DataFlavor flavor)
{
return flavor.equals(DataFlavor.imageFlavor);
}
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException
{
if (!isDataFlavorSupported(flavor))
throw new UnsupportedFlavorException(flavor);
return img;
}
}
/**
* Helper class to put an Object on a clipboard as Serializable
* object.
*/
static class ObjectSelection implements Transferable
{
private final Serializable obj;
ObjectSelection(Serializable obj)
{
this.obj = obj;
}
static DataFlavor objFlavor = new DataFlavor(Serializable.class,
"Serialized Object");
static DataFlavor[] flavors = new DataFlavor[] { objFlavor };
public DataFlavor[] getTransferDataFlavors()
{
return (DataFlavor[]) flavors.clone();
}
public boolean isDataFlavorSupported(DataFlavor flavor)
{
return flavor.equals(objFlavor);
}
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException
{
if (!isDataFlavorSupported(flavor))
throw new UnsupportedFlavorException(flavor);
return obj;
}
}
/**
* Helper class to put a List of Files on the clipboard as
* DataFlavor.javaFileListFlavor.
*/
static class FilesSelection implements Transferable
{
private final File[] files;
FilesSelection(File[] files)
{
this.files = files;
}
static DataFlavor[] flavors = new DataFlavor[]
{ DataFlavor.javaFileListFlavor };
public DataFlavor[] getTransferDataFlavors()
{
return (DataFlavor[]) flavors.clone();
}
public boolean isDataFlavorSupported(DataFlavor flavor)
{
return flavor.equals(DataFlavor.javaFileListFlavor);
}
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException
{
if (!isDataFlavorSupported(flavor))
throw new UnsupportedFlavorException(flavor);
return Arrays.asList(files);
}
}
}