bundles/org.simantics.spreadsheet.ui/src/org/simantics/spreadsheet/ui/test/RowHeaderExample.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.spreadsheet.ui.test;
  13 import java.awt.BorderLayout;
  14 import java.awt.Component;
  15 import java.awt.Toolkit;
  16 import java.awt.datatransfer.Clipboard;
  17 import java.awt.datatransfer.DataFlavor;
  18 import java.awt.datatransfer.StringSelection;
  19 import java.awt.event.ActionEvent;
  20 import java.awt.event.ActionListener;
  21 import java.awt.event.KeyEvent;
  22 import java.awt.event.WindowAdapter;
  23 import java.awt.event.WindowEvent;
  24 import java.util.StringTokenizer;
  25
  26 import javax.swing.AbstractListModel;
  27 import javax.swing.JComponent;
  28 import javax.swing.JFrame;
  29 import javax.swing.JLabel;
  30 import javax.swing.JList;
  31 import javax.swing.JOptionPane;
  32 import javax.swing.JScrollPane;
  33 import javax.swing.JTable;
  34 import javax.swing.KeyStroke;
  35 import javax.swing.ListCellRenderer;
  36 import javax.swing.ListModel;
  37 import javax.swing.UIManager;
  38 import javax.swing.event.TableModelEvent;
  39 import javax.swing.event.TableModelListener;
  40 import javax.swing.table.DefaultTableModel;
  41 import javax.swing.table.JTableHeader;
  42
  43 /**
  44  * @version 1.0 11/09/98
  45  */
  46
  47 class RowHeaderRenderer extends JLabel implements ListCellRenderer {
  48
  49         RowHeaderRenderer(JTable table) {
  50                 JTableHeader header = table.getTableHeader();
  51                 setOpaque(true);
  52                 setBorder(UIManager.getBorder("TableHeader.cellBorder"));
  53                 setHorizontalAlignment(CENTER);
  54                 setForeground(header.getForeground());
  55                 setBackground(header.getBackground());
  56                 setFont(header.getFont());
  57         }
  58
  59         public Component getListCellRendererComponent(JList list, Object value,
  60                         int index, boolean isSelected, boolean cellHasFocus) {
  61                 setText((value == null) ? "" : value.toString());
  62                 return this;
  63         }
  64 }
  65
  66 public class RowHeaderExample extends JFrame {
  67
  68         public RowHeaderExample() {
  69
  70                 super("Row Header Example");
  71                 setSize(300, 150);
  72
  73                 ListModel lm = new AbstractListModel() {
  74
  75                         public int getSize() {
  76                                 return 500;
  77                         }
  78
  79                         public Object getElementAt(int index) {
  80                                 return "" + index;
  81                         }
  82
  83                 };
  84
  85                 final DefaultTableModel dm = new DefaultTableModel(lm.getSize(), 500);
  86                 for(int i=0;i<10;i++) {
  87                         for(int j=0;j<10;j++) {
  88                                 dm.setValueAt(new Object () { private Integer i = new Integer((int)(20 *Math.random())); } , i, j);
  89                         }
  90                 }
  91
  92                 dm.addTableModelListener(new TableModelListener() {
  93
  94                         @Override
  95                         public void tableChanged(TableModelEvent e) {
  96 //                              System.out.println(e);
  97 //                              System.out.println(e.getColumn());
  98 //                              System.out.println(e.getFirstRow());
  99 //                              System.out.println(e.getLastRow());
 100 //                              System.out.println(e.getSource());
 101 //                              Object value = dm.getValueAt(e.getFirstRow(), e.getColumn());
 102 //                              System.out.println(value);
 103 //                              System.out.println(value.getClass());
 104 //                              Object value2 = dm.getValueAt(e.getFirstRow(), e.getColumn() + 1);
 105 //                              System.out.println(value2);
 106 //                              System.out.println(value2.getClass());
 107                         }
 108
 109                 });
 110
 111                 JTable table = new JTable(dm);
 112                 new ExcelAdapter(table);
 113                 table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
 114
 115                 table.setColumnSelectionAllowed(true);
 116                 table.addRowSelectionInterval(1, 3);
 117                 table.addColumnSelectionInterval(1, 3);
 118
 119                 JList rowHeader = new JList(lm);
 120                 rowHeader.setFixedCellWidth(50);
 121
 122                 rowHeader.setFixedCellHeight(table.getRowHeight() /*
 123         + table.getRowMargin() + table.getIntercellSpacing().height*/);
 124
 125                 rowHeader.setCellRenderer(new RowHeaderRenderer(table));
 126
 127                 JScrollPane scroll = new JScrollPane(table);
 128                 scroll.setRowHeaderView(rowHeader);
 129                 getContentPane().add(scroll, BorderLayout.CENTER);
 130         }
 131
 132         /**
 133          * ExcelAdapter enables Copy-Paste Clipboard functionality on JTables.
 134          * The clipboard data format used by the adapter is compatible with
 135          * the clipboard format used by Excel. This provides for clipboard
 136          * interoperability between enabled JTables and Excel.
 137          */
 138         public class ExcelAdapter implements ActionListener
 139         {
 140                 private String rowstring,value;
 141                 private Clipboard system;
 142                 private StringSelection stsel;
 143                 private JTable jTable1 ;
 144                 /**
 145                  * The Excel Adapter is constructed with a
 146                  * JTable on which it enables Copy-Paste and acts
 147                  * as a Clipboard listener.
 148                  */
 149                 public ExcelAdapter(JTable myJTable)
 150                 {
 151                         jTable1 = myJTable;
 152                         KeyStroke copy = KeyStroke.getKeyStroke(KeyEvent.VK_C,ActionEvent.CTRL_MASK,false);
 153                         // Identifying the copy KeyStroke user can modify this
 154                         // to copy on some other Key combination.
 155                         KeyStroke paste = KeyStroke.getKeyStroke(KeyEvent.VK_V,ActionEvent.CTRL_MASK,false);
 156                         // Identifying the Paste KeyStroke user can modify this
 157                         //to copy on some other Key combination.
 158                         jTable1.registerKeyboardAction(this,"Copy",copy,JComponent.WHEN_FOCUSED);
 159                         jTable1.registerKeyboardAction(this,"Paste",paste,JComponent.WHEN_FOCUSED);
 160                         system = Toolkit.getDefaultToolkit().getSystemClipboard();
 161                 }
 162                 /**
 163                  * Public Accessor methods for the Table on which this adapter acts.
 164                  */
 165                 public JTable getJTable() {return jTable1;}
 166                 public void setJTable(JTable jTable1) {this.jTable1=jTable1;}
 167                 /**
 168                  * This method is activated on the Keystrokes we are listening to
 169                  * in this implementation. Here it listens for Copy and Paste ActionCommands.
 170                  * Selections comprising non-adjacent cells result in invalid selection and
 171                  * then copy action cannot be performed.
 172                  * Paste is done by aligning the upper left corner of the selection with the
 173                  * 1st element in the current selection of the JTable.
 174                  */
 175                 public void actionPerformed(ActionEvent e)
 176                 {
 177                         if (e.getActionCommand().compareTo("Copy")==0)
 178                         {
 179                                 StringBuffer sbf=new StringBuffer();
 180                                 // Check to ensure we have selected only a contiguous block of
 181                                 // cells
 182                                 int numcols=jTable1.getSelectedColumnCount();
 183                                 int numrows=jTable1.getSelectedRowCount();
 184                                 int[] rowsselected=jTable1.getSelectedRows();
 185                                 int[] colsselected=jTable1.getSelectedColumns();
 186                                 if (!((numrows-1==rowsselected[rowsselected.length-1]-rowsselected[0] &&
 187                                                 numrows==rowsselected.length) &&
 188                                                 (numcols-1==colsselected[colsselected.length-1]-colsselected[0] &&
 189                                                                 numcols==colsselected.length)))
 190                                 {
 191                                         JOptionPane.showMessageDialog(null, "Invalid Copy Selection",
 192                                                         "Invalid Copy Selection",
 193                                                         JOptionPane.ERROR_MESSAGE);
 194                                         return;
 195                                 }
 196                                 for (int i=0;i<numrows;i++)
 197                                 {
 198                                         for (int j=0;j<numcols;j++)
 199                                         {
 200                                                 sbf.append(jTable1.getValueAt(rowsselected[i],colsselected[j]));
 201                                                 if (j<numcols-1) sbf.append("\t");
 202                                         }
 203                                         sbf.append("\n");
 204                                 }
 205                                 stsel  = new StringSelection(sbf.toString());
 206                                 system = Toolkit.getDefaultToolkit().getSystemClipboard();
 207                                 system.setContents(stsel,stsel);
 208                         }
 209                         if (e.getActionCommand().compareTo("Paste")==0)
 210                         {
 211                                 int startRow=(jTable1.getSelectedRows())[0];
 212                                 int startCol=(jTable1.getSelectedColumns())[0];
 213                                 try
 214                                 {
 215                                         String trstring= (String)(system.getContents(this).getTransferData(DataFlavor.stringFlavor));
 216                                         StringTokenizer st1=new StringTokenizer(trstring,"\n");
 217                                         for(int i=0;st1.hasMoreTokens();i++)
 218                                         {
 219                                                 rowstring=st1.nextToken();
 220                                                 StringTokenizer st2=new StringTokenizer(rowstring,"\t");
 221                                                 for(int j=0;st2.hasMoreTokens();j++)
 222                                                 {
 223                                                         value=(String)st2.nextToken();
 224                                                         if (startRow+i< jTable1.getRowCount()  &&
 225                                                                         startCol+j< jTable1.getColumnCount())
 226                                                                 jTable1.setValueAt(value,startRow+i,startCol+j);
 227                                                 }
 228                                         }
 229                                 }
 230                                 catch(Exception ex){ex.printStackTrace();}
 231                         }
 232                 }
 233         }
 234
 235
 236         public static void main(String[] args) {
 237                 RowHeaderExample frame = new RowHeaderExample();
 238                 frame.addWindowListener(new WindowAdapter() {
 239                         public void windowClosing(WindowEvent e) {
 240                                 System.exit(0);
 241                         }
 242                 });
 243                 frame.setVisible(true);
 244         }
 245 }