gomp-20050608-branch/libjava/classpath/examples/gnu/classpath/examples/datatransfer/Demo.java

   1 /* Demo.java -- And example of copy/paste datatransfer
   2    Copyright (C) 2005 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath examples.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA. */
  20
  21 package gnu.classpath.examples.datatransfer;
  22
  23 import java.awt.*;
  24 import java.awt.event.*;
  25 import java.awt.datatransfer.*;
  26
  27 import java.io.*;
  28 import java.net.URL;
  29 import java.util.Arrays;
  30 import java.util.Iterator;
  31 import java.util.Random;
  32
  33 /**
  34  * An example how datatransfer works for copying and pasting data to
  35  * and from other programs.
  36  */
  37 class Demo
  38   extends Frame
  39   implements ActionListener, ItemListener, FlavorListener
  40 {
  41   public static void main(String args[])
  42   {
  43     new Demo();
  44   }
  45
  46   private TextArea text;
  47   private Button copyText;
  48   private Button pasteText;
  49
  50   private ImageComponent image;
  51   private Button copyImage;
  52   private Button pasteImage;
  53
  54   private ObjectComponent object;
  55   private Button copyObject;
  56   private Button pasteObject;
  57
  58   private FilesComponent files;
  59   private Button copyFiles;
  60   private Button pasteFiles;
  61
  62   private FlavorsComponent flavors;
  63   private FlavorDetailsComponent details;
  64
  65   private Demo()
  66   {
  67     super("GNU Classpath datatransfer");
  68
  69     /* Add all the different panel to the main window in one row. */
  70     setLayout(new GridLayout(5, 1, 10, 10));
  71     add(createTextPanel());
  72     add(createImagePanel());
  73     add(createObjectPanel());
  74     add(createFilesPanel());
  75     add(createFlavorsPanel());
  76
  77     /* Add listeners for the various buttons and events we are
  78        interested in. */
  79     addWindowListener(new WindowAdapter ()
  80       {
  81         public void windowClosing (WindowEvent e)
  82         {
  83           dispose();
  84         }
  85       });
  86     flavors.addItemListener(this);
  87     Toolkit t = Toolkit.getDefaultToolkit();
  88     Clipboard c = t.getSystemClipboard();
  89     c.addFlavorListener(this);
  90
  91     /* Show time! */
  92     pack();
  93     show();
  94   }
  95
  96   /**
  97    * The Text Panel will show simple text that can be copied and pasted.
  98    */
  99   private Panel createTextPanel()
 100   {
 101     Panel textPanel = new Panel();
 102     textPanel.setLayout(new BorderLayout());
 103     text = new TextArea("GNU Everywhere!",
 104                         2, 80,
 105                         TextArea.SCROLLBARS_VERTICAL_ONLY);
 106     text.setEditable(false);
 107     text.setEnabled(true);
 108     Panel textButtons = new Panel();
 109     textButtons.setLayout(new FlowLayout());
 110     copyText = new Button("Copy text");
 111     copyText.addActionListener(this);
 112     pasteText = new Button("Paste text");
 113     pasteText.addActionListener(this);
 114     textButtons.add(copyText);
 115     textButtons.add(pasteText);
 116     textPanel.add(text, BorderLayout.CENTER);
 117     textPanel.add(textButtons, BorderLayout.SOUTH);
 118     return textPanel;
 119   }
 120
 121   /**
 122    * The Image Panel shows an image that can be copied to another
 123    * program or be replaced by pasting in an image from another
 124    * application.
 125    */
 126   private Panel createImagePanel()
 127   {
 128     Panel imagePanel = new Panel();
 129     imagePanel.setLayout(new BorderLayout());
 130     URL imageurl = this.getClass()
 131       .getResource("/gnu/classpath/examples/icons/big-fullscreen.png");
 132     Image img = Toolkit.getDefaultToolkit().createImage(imageurl);
 133     image = new ImageComponent(img);
 134     Panel imageButtons = new Panel();
 135     copyImage = new Button("Copy image");
 136     copyImage.addActionListener(this);
 137     pasteImage = new Button("Paste image");
 138     pasteImage.addActionListener(this);
 139     imageButtons.add(copyImage);
 140     imageButtons.add(pasteImage);
 141     imagePanel.add(image, BorderLayout.CENTER);
 142     imagePanel.add(imageButtons, BorderLayout.SOUTH);
 143     return imagePanel;
 144   }
 145
 146   /**
 147    * The Object Panel holds a simple (Point) object that can be copied
 148    * and pasted to another program that supports exchanging serialized
 149    * objects.
 150    */
 151   private Panel createObjectPanel()
 152   {
 153     Panel objectPanel = new Panel();
 154     objectPanel.setLayout(new BorderLayout());
 155     Random random = new Random();
 156     int x = (byte) random.nextInt();
 157     int y = (byte) random.nextInt();
 158     object = new ObjectComponent(new Point(x, y));
 159     Panel objectButtons = new Panel();
 160     copyObject = new Button("Copy object");
 161     copyObject.addActionListener(this);
 162     pasteObject = new Button("Paste object");
 163     pasteObject.addActionListener(this);
 164     objectButtons.add(copyObject);
 165     objectButtons.add(pasteObject);
 166     objectPanel.add(object, BorderLayout.CENTER);
 167     objectPanel.add(objectButtons, BorderLayout.SOUTH);
 168     return objectPanel;
 169   }
 170
 171   /**
 172    * The Files Panel shows the files from the current working
 173    * directory. They can be copied and pasted between other
 174    * applications that support the exchange of file lists.
 175    */
 176   private Panel createFilesPanel()
 177   {
 178     Panel filesPanel = new Panel();
 179     filesPanel.setLayout(new BorderLayout());
 180     files = new FilesComponent(new File(".").listFiles());
 181     Panel filesButtons = new Panel();
 182     copyFiles = new Button("Copy files");
 183     copyFiles.addActionListener(this);
 184     pasteFiles = new Button("Paste files");
 185     pasteFiles.addActionListener(this);
 186     filesButtons.add(copyFiles);
 187     filesButtons.add(pasteFiles);
 188     filesPanel.add(files, BorderLayout.CENTER);
 189     filesPanel.add(filesButtons, BorderLayout.SOUTH);
 190     return filesPanel;
 191   }
 192
 193   /**
 194    * The Flavors Panel shows the different formats (mime-types) that
 195    * data on the clipboard is available in. By clicking on a flavor
 196    * details about the representation class and object is given.
 197    */
 198   private Panel createFlavorsPanel()
 199   {
 200     Panel flavorsPanel = new Panel();
 201     flavorsPanel.setLayout(new BorderLayout());
 202     Label flavorsHeader = new Label("Flavors on clipboard:");
 203     Toolkit t = Toolkit.getDefaultToolkit();
 204     Clipboard c = t.getSystemClipboard();
 205     DataFlavor[] dataflavors = c.getAvailableDataFlavors();
 206     flavors = new FlavorsComponent(dataflavors);
 207     details = new FlavorDetailsComponent(null);
 208     flavorsPanel.add(flavorsHeader, BorderLayout.NORTH);
 209     flavorsPanel.add(flavors, BorderLayout.CENTER);
 210     flavorsPanel.add(details, BorderLayout.SOUTH);
 211     return flavorsPanel;
 212   }
 213
 214   /**
 215    * FlavorListener implementation that updates the Flavors Panel
 216    * whenever a change in the mime-types available has been detected.
 217    */
 218   public void flavorsChanged(FlavorEvent event)
 219   {
 220     Toolkit t = Toolkit.getDefaultToolkit();
 221     Clipboard c = t.getSystemClipboard();
 222     DataFlavor[] dataflavors = c.getAvailableDataFlavors();
 223     flavors.setFlavors(dataflavors);
 224     details.setDataFlavor(null);
 225   }
 226
 227   /**
 228    * ItemChangeListener implementation that updates the flavor details
 229    * whenever the user selects a different representation of the data
 230    * available on the clipboard.
 231    */
 232   public void itemStateChanged(ItemEvent evt)
 233   {
 234     DataFlavor df = null;
 235     String s = flavors.getSelectedItem();
 236     if (s != null)
 237       {
 238         try
 239           {
 240             df = new DataFlavor(s);
 241           }
 242         catch (ClassNotFoundException cnfe)
 243           {
 244             cnfe.printStackTrace();
 245           }
 246       }
 247     details.setDataFlavor(df);
 248   }
 249
 250   /**
 251    * ActionListener implementations that will copy or past data
 252    * to/from the clipboard when the user requests that for the text,
 253    * image, object of file component.
 254    */
 255   public void actionPerformed (ActionEvent evt)
 256   {
 257     Button b = (Button) evt.getSource();
 258     Toolkit t = Toolkit.getDefaultToolkit();
 259     Clipboard c = t.getSystemClipboard();
 260     if (b == copyText)
 261       c.setContents(new StringSelection(text.getText()), null);
 262
 263     if (b == pasteText)
 264       {
 265         String s = null;
 266         try
 267           {
 268             s = (String) c.getData(DataFlavor.stringFlavor);
 269           }
 270         catch (UnsupportedFlavorException dfnse)
 271           {
 272           }
 273         catch (IOException ioe)
 274           {
 275           }
 276         catch (ClassCastException cce)
 277           {
 278           }
 279         if (s == null)
 280           t.beep();
 281         else
 282           text.setText(s);
 283       }
 284
 285     if (b == copyImage)
 286       c.setContents(new ImageSelection(image.getImage()), null);
 287
 288     if (b == pasteImage)
 289       {
 290         Image i = null;
 291         try
 292           {
 293             i = (Image) c.getData(DataFlavor.imageFlavor);
 294           }
 295         catch (UnsupportedFlavorException dfnse)
 296           {
 297           }
 298         catch (IOException ioe)
 299           {
 300           }
 301         catch (ClassCastException cce)
 302           {
 303           }
 304         if (i == null)
 305           t.beep();
 306         else
 307           image.setImage(i);
 308       }
 309
 310     if (b == copyObject)
 311       c.setContents(new ObjectSelection(object.getObject()), null);
 312
 313     if (b == pasteObject)
 314       {
 315         Serializable o = null;
 316         try
 317           {
 318             o = (Serializable) c.getData(ObjectSelection.objFlavor);
 319           }
 320         catch (UnsupportedFlavorException dfnse)
 321           {
 322           }
 323         catch (IOException ioe)
 324           {
 325           }
 326         catch (ClassCastException cce)
 327           {
 328           }
 329         if (o == null)
 330           t.beep();
 331         else
 332           object.setObject(o);
 333       }
 334
 335     if (b == copyFiles)
 336       c.setContents(new FilesSelection(files.getFiles()), null);
 337
 338     if (b == pasteFiles)
 339       {
 340         java.util.List fs = null;
 341         try
 342           {
 343             fs = (java.util.List) c.getData(DataFlavor.javaFileListFlavor);
 344           }
 345         catch (UnsupportedFlavorException dfnse)
 346           {
 347           }
 348         catch (IOException ioe)
 349           {
 350           }
 351         catch (ClassCastException cce)
 352           {
 353           }
 354         if (fs == null)
 355           t.beep();
 356         else
 357           files.setFiles(fs);
 358       }
 359   }
 360
 361   /**
 362    * Simple awt component that shows an settable image.
 363    */
 364   static class ImageComponent extends Component
 365   {
 366     private Image image;
 367
 368     ImageComponent(Image image)
 369     {
 370       setSize(20, 20);
 371       setImage(image);
 372     }
 373
 374     Image getImage()
 375     {
 376       return image;
 377     }
 378
 379     void setImage(Image image)
 380     {
 381       this.image = image;
 382       repaint();
 383     }
 384
 385     public void paint(Graphics g)
 386     {
 387       g.drawImage(image, 0, 0, getWidth(), getHeight(), this);
 388     }
 389   }
 390
 391   /**
 392    * Simple awt component that shows a settable Serializable object.
 393    */
 394   static class ObjectComponent extends TextArea
 395   {
 396     private Serializable object;
 397
 398     ObjectComponent(Serializable object)
 399     {
 400       super("", 2, 80, TextArea.SCROLLBARS_NONE);
 401       setEditable(false);
 402       setEnabled(false);
 403       setObject(object);
 404     }
 405
 406     Serializable getObject()
 407     {
 408       return object;
 409     }
 410
 411     void setObject(Serializable object)
 412     {
 413       this.object = object;
 414       setText("Class: " + object.getClass().getName()
 415               + "\n"
 416               + "toString(): " + object.toString());
 417       repaint();
 418     }
 419   }
 420
 421   /**
 422    * Simple awt component that shows a settable list of Files.
 423    */
 424   static class FilesComponent extends List
 425   {
 426     private File[] files;
 427
 428     FilesComponent(File[] files)
 429     {
 430       super(4, true);
 431       setFiles(files);
 432     }
 433
 434     File[] getFiles()
 435     {
 436       String[] strings = getSelectedItems();
 437       if (strings == null || strings.length == 0)
 438         return (File[]) files.clone();
 439
 440       File[] fs = new File[strings.length];
 441       for (int i = 0; i < strings.length; i++)
 442         fs[i] = new File(strings[i]);
 443       return fs;
 444     }
 445
 446     void setFiles(File[] files)
 447     {
 448       this.files = files;
 449       removeAll();
 450       for (int i = 0; i < files.length; i++)
 451         {
 452           addItem(files[i].toString());
 453           select(i);
 454         }
 455     }
 456
 457     void setFiles(java.util.List list)
 458     {
 459       File[] fs = new File[list.size()];
 460       int i = 0;
 461       Iterator it = list.iterator();
 462       while (it.hasNext())
 463         fs[i++] = (File) it.next();
 464
 465       setFiles(fs);
 466     }
 467   }
 468
 469   /**
 470    * Simple awt component that shows a settable list of DataFlavors.
 471    */
 472   static class FlavorsComponent extends List
 473   {
 474     FlavorsComponent(DataFlavor[] flavors)
 475     {
 476       super(4);
 477       setFlavors(flavors);
 478     }
 479
 480     void setFlavors(DataFlavor[] flavors)
 481     {
 482       removeAll();
 483       for (int i = 0; i < flavors.length; i++)
 484         {
 485           addItem(flavors[i].getMimeType());
 486         }
 487     }
 488   }
 489
 490   /**
 491    * Simple awt component that shows the details for and an object as
 492    * found on the system clipboard as represented by a given
 493    * DataFlavor.
 494    */
 495   static class FlavorDetailsComponent extends TextArea
 496   {
 497     private DataFlavor df;
 498
 499     FlavorDetailsComponent(DataFlavor df)
 500     {
 501       super("", 2, 80, TextArea.SCROLLBARS_NONE);
 502       setEditable(false);
 503       setEnabled(false);
 504       setDataFlavor(df);
 505     }
 506
 507     void setDataFlavor(DataFlavor df)
 508     {
 509       if (df == this.df
 510           || (df != null && df.equals(this.df)))
 511         return;
 512
 513       this.df = df;
 514
 515       if (df == null)
 516         setText("No flavor selected");
 517       else
 518         {
 519           Object o = null;
 520           Throwable exception = null;
 521           try
 522             {
 523               Toolkit t = Toolkit.getDefaultToolkit();
 524               Clipboard c = t.getSystemClipboard();
 525               o = c.getData(df);
 526             }
 527           catch (Throwable t)
 528             {
 529               exception = t;
 530             }
 531           if (o != null)
 532             {
 533               setText("Data: " + o.getClass().getName()
 534                       + "\n"
 535                       + o);
 536             }
 537           else
 538             {
 539               setText("Error retrieving: " + df
 540                       + "\n"
 541                       + exception != null ? exception.toString() : "");
 542             }
 543         }
 544       repaint();
 545     }
 546   }
 547
 548   /**
 549    * Helper class to put an Image on a clipboard as
 550    * DataFlavor.imageFlavor.
 551    */
 552   static class ImageSelection implements Transferable
 553   {
 554     private final Image img;
 555
 556     ImageSelection(Image img)
 557     {
 558       this.img = img;
 559     }
 560
 561     static DataFlavor[] flavors = new DataFlavor[] { DataFlavor.imageFlavor };
 562     public DataFlavor[] getTransferDataFlavors()
 563     {
 564       return (DataFlavor[]) flavors.clone();
 565     }
 566
 567     public boolean isDataFlavorSupported(DataFlavor flavor)
 568     {
 569       return flavor.equals(DataFlavor.imageFlavor);
 570     }
 571
 572     public Object getTransferData(DataFlavor flavor)
 573       throws UnsupportedFlavorException
 574     {
 575       if (!isDataFlavorSupported(flavor))
 576         throw new UnsupportedFlavorException(flavor);
 577
 578       return img;
 579     }
 580   }
 581
 582   /**
 583    * Helper class to put an Object on a clipboard as Serializable
 584    * object.
 585    */
 586   static class ObjectSelection implements Transferable
 587   {
 588     private final Serializable obj;
 589
 590     ObjectSelection(Serializable obj)
 591     {
 592       this.obj = obj;
 593     }
 594
 595     static DataFlavor objFlavor = new DataFlavor(Serializable.class,
 596                                                  "Serialized Object");
 597     static DataFlavor[] flavors = new DataFlavor[] { objFlavor };
 598     public DataFlavor[] getTransferDataFlavors()
 599     {
 600       return (DataFlavor[]) flavors.clone();
 601     }
 602
 603     public boolean isDataFlavorSupported(DataFlavor flavor)
 604     {
 605       return flavor.equals(objFlavor);
 606     }
 607
 608     public Object getTransferData(DataFlavor flavor)
 609       throws UnsupportedFlavorException
 610     {
 611       if (!isDataFlavorSupported(flavor))
 612         throw new UnsupportedFlavorException(flavor);
 613
 614       return obj;
 615     }
 616   }
 617
 618   /**
 619    * Helper class to put a List of Files on the clipboard as
 620    * DataFlavor.javaFileListFlavor.
 621    */
 622   static class FilesSelection implements Transferable
 623   {
 624     private final File[] files;
 625
 626     FilesSelection(File[] files)
 627     {
 628       this.files = files;
 629     }
 630
 631     static DataFlavor[] flavors = new DataFlavor[]
 632       { DataFlavor.javaFileListFlavor };
 633     public DataFlavor[] getTransferDataFlavors()
 634     {
 635       return (DataFlavor[]) flavors.clone();
 636     }
 637
 638     public boolean isDataFlavorSupported(DataFlavor flavor)
 639     {
 640       return flavor.equals(DataFlavor.javaFileListFlavor);
 641     }
 642
 643     public Object getTransferData(DataFlavor flavor)
 644       throws UnsupportedFlavorException
 645     {
 646       if (!isDataFlavorSupported(flavor))
 647         throw new UnsupportedFlavorException(flavor);
 648
 649       return Arrays.asList(files);
 650     }
 651   }
 652 }