/** You may copy this example and use it for any purpose, commercial or otherwise. */

import com.ricebridge.xmlman.*;

import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;

import javax.swing.*;
import javax.swing.table.*;
import javax.swing.border.*;

import java.io.*;
import java.util.*;
import java.util.List;


/** This is a little Swing application that shows you how to load and
 *  save XML data into a JTable using XML Manager. The user selects
 *  an XML file to load, enters the XPath expressions to apply to
 *  the XML, and views the results in a table. The data can then be
 *  edited and saved using the same XPath expressions. The data can
 *  also be cut-and-pasted into a spreadsheet.
 *
 *  To compile and run this program, you will need to include xmlman.jar
 *  (in the lib folder of the XML Manager distribution) in your CLASSPATH. 
 */
public class SwingTable {

  // Start the application.
  public static void main( String[] pArgs ) throws Exception {
    SwingTable rtm = new SwingTable();
  }


  // Some static definitions.
  private static Font sLabelFont = new Font("SansSerif",0,11);
  private static Font sInputFont = new Font("Monospaced",0,11);


  // These are the main application logic veriables.
  private XmlManager   iXmlManager   = null;
  private RecordSpec   iRecordSpec   = null;
  private File         iXmlFile      = null;


  // These are the user interface variables
  private JFrame       iMainFrame    = null;
  private JTable       iTable        = null;
  private JFileChooser iFileChooser  = null;
  private JTextField   iRecordPath   = null;
  private List         iFieldPaths   = null;
  private JToolBar     iSpecBar      = null;
  private JButton      iReloadButton = null;
  private Clipboard    iClipboard    = null;


  /** Create the user interface and set up XML Manager. */
  public SwingTable() throws Exception {

    // System integration.
    iClipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );

    // Set up XML Manager.
    // We turn off namespaces as the application has no facility to change them.
    // We also make the table editable.
    iXmlManager = new XmlManager();
    iXmlManager.getXmlSpec().setNamespaceAware(false);
    iXmlManager.getXmlSpec().setProperty( "TableModel.editable", true );
  
    // The rest of this method builds the user interface.

    iMainFrame   = new JFrame("SwingTable");
    iMainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    iFieldPaths = new ArrayList();

    Box toolbox = new Box( BoxLayout.Y_AXIS );
    toolbox.add( Box.createVerticalStrut(5) );
    toolbox.add( makeLoadBar() );
    toolbox.add( Box.createVerticalStrut(5) );
    toolbox.add( makeSpecBar() );

    makeTable();
    JScrollPane ts = new JScrollPane( iTable );
    iTable.setPreferredScrollableViewportSize(new Dimension(800, 300));

    iMainFrame.getContentPane().add( toolbox, BorderLayout.NORTH);
    iMainFrame.getContentPane().add( ts,      BorderLayout.CENTER);

    iMainFrame.pack();
    iMainFrame.setVisible(true);    
  }


  /** Build the data table, and add the cut and paste functionality. */
  public void makeTable() {
    iTable = new JTable();
    iTable.setRowSelectionAllowed(true);
    iTable.setColumnSelectionAllowed(true);
    iTable.setCellSelectionEnabled(true);

    ActionMap am = iTable.getActionMap();
    am.put( "selectall", new AbstractAction() {
        public void actionPerformed( ActionEvent pEvent ) {        
          iTable.selectAll();
        }
      });

    am.put( "copy", new AbstractAction() {
        public void actionPerformed( ActionEvent pEvent ) {        
          int[] rows = iTable.getSelectedRows();
          int[] cols = iTable.getSelectedColumns();
          if( 0 < rows.length && 0 < cols.length ) {
            copy( rows[0], cols[0], rows[rows.length-1]+1, cols[cols.length-1]+1 );
          }
        }
      });

    am.put( "paste", new AbstractAction() {
        public void actionPerformed( ActionEvent pEvent ) {        
          try {
            int[] srows = iTable.getSelectedRows();
            int[] scols = iTable.getSelectedColumns();
            if( 0 < srows.length && 0 < scols.length ) {
              int sr = srows[0];
              int sc = scols[0];
              int mr = iTable.getRowCount() - sr;
              int mc = iTable.getColumnCount() - sc;

              String   datastr = (String)( iClipboard.getContents(this).getTransferData(DataFlavor.stringFlavor) );
              String[] rows    = datastr.split("\n");
              for( int r = 0; r < rows.length && r < mr; r++ ) {
                String[] cols = rows[r].split("\t");
                for( int c = 0; c < cols.length && c < mc; c++ ) {
                  iTable.setValueAt( cols[c], sr+r, sc+c );
                }
              }
            }
          } 
          catch( Exception e ) {
            displayError( "Could not transfer data: "+e.getMessage() );
          }
        }
      });

    KeyStroke selectall = KeyStroke.getKeyStroke(KeyEvent.VK_A,ActionEvent.CTRL_MASK,false);
    KeyStroke copy      = KeyStroke.getKeyStroke(KeyEvent.VK_C,ActionEvent.CTRL_MASK,false);
    KeyStroke paste     = KeyStroke.getKeyStroke(KeyEvent.VK_V,ActionEvent.CTRL_MASK,false);

    InputMap im = iTable.getInputMap();
    im.put( selectall, "selectall");
    im.put( copy,      "copy");
    im.put( paste,     "paste");
  }


  /** Create the top row of buttons, and define their actions. */
  public JToolBar makeLoadBar() {
    JToolBar toolbar = new JToolBar();
    new BoxLayout( toolbar, BoxLayout.X_AXIS );

    JButton reloadB = new JButton( "Reload" );
    reloadB.setPreferredSize( new Dimension(50,20) );
    reloadB.setEnabled(false); // enabled when we've loaded a file

    JButton loadB = new JButton( "Load XML File" );
    loadB.setPreferredSize( new Dimension(100,20) );

    JButton saveB = new JButton( "Save XML File" );
    saveB.setPreferredSize( new Dimension(100,10) );

    JButton viewB = new JButton( "View XML File" );
    viewB.setPreferredSize( new Dimension(100,10) );

    JButton genrsB = new JButton( "Show RecordSpec" );
    genrsB.setPreferredSize( new Dimension(150,10) );

    JButton copyB = new JButton( "Copy Table" );
    copyB.setPreferredSize( new Dimension(100,10) );


    reloadB.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent e ) {
          try {
            if( null != iXmlFile ) {
              load( iXmlFile );
            }
          }
          catch( XmlManagerException xme ) {
            displayError( xme.getUserMessage() );
          }
        }
      } );

    loadB.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent e ) {
          try {
            File xmlFile = askForXmlFile( true );
            if( null != xmlFile ) {
              load( xmlFile );
            }
          }
          catch( XmlManagerException xme ) {
            displayError( xme.getUserMessage() );
          }
        }
      } );

    saveB.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent e ) {
          try {
            File xmlFile = askForXmlFile( false );
            if( null != xmlFile ) {
              save( xmlFile );
            }
          }
          catch( XmlManagerException xme ) {
            displayError( xme.getUserMessage() );
          }
        }
      } );

    // View the current file if there is one, otherwise ask the user for a file.
    viewB.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent e ) {
          try {
            File xmlFile = null;
            if( null == iXmlFile ) {
              xmlFile = askForXmlFile( false );
            }
            else {
              xmlFile = iXmlFile;
            }

            show( xmlFile.getName(), readFile( xmlFile ), 500, 500 );
          }
          catch( XmlManagerException xme ) {
            displayError( xme.getUserMessage() );
          }
        }
      } );

    // Generate the Java source code to define the current RecordSpec.
    genrsB.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent e ) {
          try {
            RecordSpec rs = makeRecordSpec();
            StringBuffer rscode = new StringBuffer( " new RecordSpec( \"" );
            rscode.append( iRecordPath.getText().replaceAll("\"","\\n") );
            rscode.append( "\", new String[] { " );
            for( int fI = 0; fI < iFieldPaths.size(); fI++ ) {
              rscode.append( 0<fI?", \"":"\"" );
              rscode.append( ((JTextField)iFieldPaths.get(fI)).getText().replaceAll("\"","\\n"));
              rscode.append( "\"" );
            }
            rscode.append( " } ); " );
            show( "RecordSpec", rscode.toString(), 700, 50 );
          }
          catch( XmlManagerException xme ) {
            displayError( xme.getUserMessage() );
          }
        }
      } );

    // Copy the data in the table to the clipboard.
    // The Excel table format is used: fields are separated by
    // tabs, and rows by a newline
    copyB.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent pEvent ) {
          try {
            iTable.getActionMap().get("selectall").actionPerformed(pEvent);
            iTable.getActionMap().get("copy").actionPerformed(pEvent);
          }
          catch( XmlManagerException xme ) {
            displayError( xme.getUserMessage() );
          }
        }
      } );

    toolbar.add( reloadB );
    toolbar.add( Box.createHorizontalStrut(5) );
    toolbar.add( loadB );
    toolbar.add( Box.createHorizontalStrut(5) );
    toolbar.add( saveB );
    toolbar.add( Box.createHorizontalStrut(5) );
    toolbar.add( viewB );
    toolbar.add( Box.createHorizontalStrut(5) );
    toolbar.add( genrsB );
    toolbar.add( Box.createHorizontalStrut(5) );
    toolbar.add( copyB );
    toolbar.add( Box.createGlue() );

    iReloadButton = reloadB;
    
    return toolbar;
  }


  /** Build the text fields where the XPath expressions are entered. 
   *    The default values are for the plays.xml file.
   */
  public JToolBar makeSpecBar() {
    iSpecBar = new JToolBar();    

    JLabel rl = new JLabel("Record:");
    rl.setFont( sLabelFont );
    iSpecBar.add( rl );
    iRecordPath = new JTextField("/plays/author/play");
    iRecordPath.setFont( sInputFont );
    iRecordPath.setPreferredSize( new Dimension(120,20) );
    iRecordPath.setMinimumSize( new Dimension(50,20) );
    iSpecBar.add( iRecordPath );
    iSpecBar.add( Box.createHorizontalStrut(5) );

    JButton addB = new JButton( "Add Field" );
    addB.setPreferredSize( new Dimension(100,20) );
    addB.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent pEvent ) {
          try {
            addField("");
            iMainFrame.pack();
          }
          catch( XmlManagerException xme ) {
            displayError( xme.getUserMessage() );
          }
        }
      } );
    iSpecBar.add( Box.createHorizontalStrut(5) );

    JLabel fl = new JLabel("Fields:");
    fl.setFont( sLabelFont );
    iSpecBar.add( fl );

    iSpecBar.add( addB );

    String[] fieldpath = new String[] { "/plays/author/@name", "title", "@year", "@type" };
    for( int fI = 0; fI < fieldpath.length; fI++ ) {  
      addField( fieldpath[fI] );
    }

    return iSpecBar;
  }


  /** Add another XPath expression text input field. 
   *    There is no support for removing fields.
   */
  private void addField( String pFieldPath ) {
    int cc = iSpecBar.getComponentCount();
    Component c1 = iSpecBar.getComponent(cc-1);
    iSpecBar.remove(cc-1);

    JTextField f = new JTextField( pFieldPath );
    f.setFont( sInputFont );
    f.setPreferredSize( new Dimension(30,20) );
    f.setMinimumSize( new Dimension(100,20) );
    iSpecBar.add( Box.createHorizontalStrut(5) );
    iFieldPaths.add( f );
    iSpecBar.add( f );

    iSpecBar.add(c1);
  }

   
  /** Create a RecordSpec object based on the current values of the XPath expression fields. */
  private RecordSpec makeRecordSpec() {
    String[] fieldpaths = new String[ iFieldPaths.size() ]; 
    for( int fI = 0; fI < fieldpaths.length; fI++ ) {
      fieldpaths[fI] = ((JTextField)iFieldPaths.get(fI)).getText();
    }
    RecordSpec rs = new RecordSpec( iRecordPath.getText(), fieldpaths ); 
    return rs;
  }


  /** Ask the user for an XML file to laod or save. 
   *  @param pLoad if true then load, otherwise save
   */
  private File askForXmlFile( boolean pLoad ) {

    if( null == iFileChooser ) {
      iFileChooser = new JFileChooser( new File(".") );
    }

    int result 
      = pLoad 
      ? iFileChooser.showOpenDialog( iMainFrame )
      : iFileChooser.showSaveDialog( iMainFrame );
    
    if( JFileChooser.APPROVE_OPTION == result ) {
      File file = iFileChooser.getSelectedFile();
      return file;
    }

    return null;
  }


  /** Display an error message window. 
   *  @param pMsg the error message text
   */
  private void displayError( String pMsg ) {
    JOptionPane.showMessageDialog( iMainFrame, pMsg, "Error", JOptionPane.ERROR_MESSAGE );
  }


  /** Load and parse an XML file into a table. 
   *  @param pXmlFile XML file to load
   */
  private void load( File pXmlFile ) {
    boolean enablebuttons = false;
    try {
      RecordSpec rs = makeRecordSpec();
      TableModel tm  = iXmlManager.loadTableModel( pXmlFile, rs );
      iTable.setModel( tm );
      iTable.requestFocusInWindow();
      iXmlFile = pXmlFile;
      iMainFrame.setTitle( iXmlFile.getName() );
      enablebuttons = true;
    }
    catch( XmlManagerException xme ) {
      displayError( xme.getUserMessage() );
    }
    finally {
      iReloadButton.setEnabled( enablebuttons );
    }
  }


  /** Save an XML file using the data in the table. 
   *  @param pXmlFile file to save
   */
  private void save( File pXmlFile ) {
    boolean enablebuttons = false;
    try {
      RecordSpec rs = makeRecordSpec();
      TableModel tm = iTable.getModel();
      iXmlManager.saveTableModel( pXmlFile, rs, tm );
      iXmlFile = pXmlFile;
      iMainFrame.setTitle( iXmlFile.getName() );
    }
    catch( XmlManagerException xme ) {
      displayError( xme.getUserMessage() );
    }
  }


  /** Read a text file - used for display the XML source. */
  private String readFile( File pFile) {
    String text = "";
    BufferedReader br = null;
    try {
      String         line = null;
      StringBuffer   sb   = new StringBuffer();
      br = new BufferedReader( new FileReader( pFile ) );
      while( null != ( line = br.readLine() ) ) {
        sb.append( line );
        sb.append( "\n" );
      }
      text = sb.toString();
    }
    catch( Exception e ) {
      displayError( "Could not read file: "+pFile );
    }
    finally {
      if( null != br ) {
        try { br.close(); } catch( Exception e ) {}
      }
    }
    return text;
  }


  /** Show some text to the user in a new window. */
  private void show( String pTitle, String pText, int pWidth, int pHeight ) {
    final JFrame viewer = new JFrame( pTitle );
    viewer.setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
    viewer.setSize( pWidth, pHeight );

    JTextArea text = new JTextArea( pText );
    JScrollPane js = new JScrollPane( text );
    js.setPreferredSize(new Dimension(pWidth, pHeight));
    viewer.getContentPane().add( js, BorderLayout.CENTER );

    JButton close = new JButton("Close");
    close.addActionListener( new AbstractAction() {
        public void actionPerformed( ActionEvent e ) {
          viewer.dispose();
        }}
                             );
    viewer.getContentPane().add( close, BorderLayout.SOUTH );
    viewer.pack();
    viewer.setVisible(true);
  }


  /** Copy some data from the table into the clipboard. */
  private void copy( int sr, int sc, int er, int ec ) {
    StringBuffer sb = new StringBuffer();
    int numrows = iTable.getRowCount();
    int numcols = iTable.getColumnCount();
    sr = sr<0?0:sr;
    sc = sc<0?0:sc;
    er = er<numrows?er:numrows;
    ec = ec<numcols?ec:numcols;
    for( int r = sr; r < er; r++ ) {
      for( int c = sc; c < ec; c++ ) {
        sb.append( sc<c?"\t":"" );
        sb.append( iTable.getValueAt(r,c) );
      }
      sb.append("\n");
    }
    StringSelection ss = new StringSelection(sb.toString());
    iClipboard.setContents(ss,ss);
  }
}