/*
 * $Id: JDataTableBean.java,v 1.17 2005/08/21 13:04:58 zfq Exp zfq $
 *
 * Copyright (C) 2001-2003 Extreme Component, Inc. All rights reserved.
 * Use is subject to license terms. 
 */

package com.zfqjava.swing; 


import java.util.*;

import java.text.MessageFormat;

import java.io.File;

import java.security.AccessController;
import java.security.PrivilegedAction;

import java.sql.*;

import java.awt.*;
import java.awt.event.*;
import java.awt.print.*;

import java.beans.*;

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
import javax.swing.text.AttributeSet;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import com.zfqjava.swing.model.*;
import com.zfqjava.swing.cell.Cell;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.sql.*;
import javax.swing.filechooser.FileFilter;

/**
 * JDataTableBean
 *
 * @author $Author: zfq $
 * @version $Revision: 1.17 $ $Date: 2005/08/21 13:04:58 $
 */
public class JDataTableBean extends JBean {
    // class fields
    private static final String BUNDLE =
	"com.zfqjava.swing.resources.datatablebean";
    private static final String NAME = "JDataTableBean";
    private static final String VERSION = "2.5.0";
    /**
     * Identifies the main menubar.
     */
    public static final String MAIN_MENUBAR = "main-menubar";
    /**
     * Identifies the main toolbar.
     */
    public static final String MAIN_TOOLBAR = "main-toolbar";
    /**
     * Identifies the style toolbar.
     */
    public static final String STYLE_TOOLBAR = "style-toolbar";
    
    // instance fields
    private static final Logger log = Logger.getLogger(JDataTableBean.class.getName());  // util.Logger
    private void setAppProperties() {
	try {
	    AccessController.doPrivileged(new PrivilegedAction() {
		    public Object run() {
			System.setProperty("application.name", NAME);
			System.setProperty("application.version", VERSION);
			return null;
		    }
		});
	} catch(Exception e) {
	    e.printStackTrace();
	}
    }
    private JPanel centerPanel;
    private String url;
    private String username;
    private char[] password;
    private String command;
    private String driver;
    private String tableName = "usertesttable";
//    private String tableName;
    private int[] keyColumns = { 0 };
    private JMenuBar menuBar;
    private JToolBar toolBar;
    private JStyleBar styleBar;    
    private JDataGrid dataGrid;
    private Handler handler;
    private Map uiMap = new HashMap(2);
    private boolean useRowset;
    private boolean useCached;
    private int pageSize = 20;
    private boolean sync;
    private boolean passResultSet;
    public JDataTableBean() {
//        setLogLevel(null, Level.FINER);
        verifyLicense(NAME, VERSION);        
        initComponents();
    }
    public void updateUI() {
	super.updateUI();
	if(uiMap != null) {
	    for(Iterator i=uiMap.values().iterator(); i.hasNext(); ) {
		Component c = (Component)i.next();
		SwingUtilities.updateComponentTreeUI(c);
	    }
	}
    }
    // overide
    private void initComponents() {
	getResourceManager().addBundle(BUNDLE);
        setAppProperties();
        boolean hideSplash = Boolean.getBoolean(JDataTableBean.class.getName()+".hideSplash");        
        if(!hideSplash) {
            doSplash();
        }
	setTitle(getString("title"));
	disableIndexActions();
	centerPanel = createCenterPanel();
	setDataGrid(createDataGrid());
	add(centerPanel, BorderLayout.CENTER);
	add(createNorthPanel(), BorderLayout.NORTH);
	add(getStatusBar(), BorderLayout.SOUTH);
//  	setupDerby(); // need to create directory.
  	setupHsqldb();
        if(!hideSplash) {
            doSplash();
        }
    }
    private JPanel createCenterPanel() {
	JPanel panel = new JPanel(new BorderLayout());
	return panel;
    }
    
    protected JFrame createFrame() {
	JFrame f = super.createFrame();
	f.setSize(640, 480);
	return f;
    }
    protected JStatusBar createStatusBar() {	
	JStatusBar statusBar = new JStatusBar(JStatusBar.EDITOR);
	return statusBar;
    }    
    /**
     * Returns the menubar for the specified name.
     *
     * @param name the menubar name
     * @return the menubar
     * @since JDataGrid 1.5.1
     */
    public JMenuBar getMenuBar(String name) {
	if(MAIN_MENUBAR.equals(name)) {
	    return menuBar;
	}
	return null;
    }

    /**
     * Returns the toolbar for the specified name.
     *
     * @param name the toolbar name
     * @return the toolbar
     * @since JDataGrid 1.5.1
     */
    public JToolBar getToolBar(String name) {
	if(MAIN_TOOLBAR.equals(name)) {
	    return toolBar;
 	} else if(STYLE_TOOLBAR.equals(name)) {
	    return styleBar;
	}
	return null;
    }    
    public static void main(String[] args) {
        final JDataTableBean bean = new JDataTableBean();
        bean.setDefaultCloseOperation(JBean.EXIT_ON_CLOSE);
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                bean.showFrame();
                bean.queryTable();
            }
        });
    }
    private void registerDriver() {
	try {
	    Class.forName(driver, true, JDataTableBean.class.getClassLoader());
	} catch (Exception e) {
	    error(e);
	}
    }
    private void setupDerby() {
	url="jdbc:derby:usertesttable;create=true";
	username="user1";
	password="user1".toCharArray();
	driver="org.apache.derby.jdbc.EmbeddedDriver";
	command = "select * from usertesttable";
    }
    private void setupOdbc() {
	url = "jdbc:odbc:";
//  	username = System.getProperty("user.name");
	username = "sa";
	password = new char[0];	
	driver = "sun.jdbc.odbc.JdbcOdbcDriver"; // default
	command = "select * from usertesttable";
    }
    private void setupHsqldb() {
	url = "jdbc:hsqldb:mem:test";
	username = "sa";
	password = new char[0];	
	driver = "org.hsqldb.jdbcDriver";
	command = "select * from usertesttable";
    }
    private void setupPostgres() {
	url = "jdbc:postgresql:postgres";
	username = "postgres";
	password = "postgres".toCharArray();
	driver = "postgresql.Driver";
//  	driver = "org.postgresql.Driver";
	command = "select * from usertesttable";
    }
    private void setupMysql() {
	url = "jdbc:mysql://localhost/test";
	username = "sa";
	password = new char[0];	
	driver = "com.mysql.jdbc.Driver";
	command = "select * from usertesttable";	
    }
    private void setupTable() {
	registerDriver();
	try {
	    Connection conn = DriverManager.getConnection(url, username, new String(password));
	    java.sql.Statement statement = conn.createStatement();
	    String sql = "create table usertesttable (username VARCHAR(12), age INTEGER, birth DATE)";
	    statement.executeUpdate(sql);
	    statement.close();
	    String insertSql = "insert into usertesttable (username, age, birth) values ( ?, ?, ?)";
	    PreparedStatement prepareStatement = conn.prepareStatement(insertSql);
	    for(int i=0; i<200; i++) {
		prepareStatement.setString(1, "user"+(i+1));
		prepareStatement.setInt(2, i+1);
		prepareStatement.setDate(3, new java.sql.Date(2004-1900, i%12, (i+1)%32));
		prepareStatement.addBatch();
	    }
	    prepareStatement.executeBatch();
	} catch (SQLException e) {
	    error(e);
	}
    }
    private void setModel(ResultSetTableModel newModel) {
	ResultSetTableModel oldModel = getModel();
	if(oldModel != null) {
	    oldModel.removeTableModelListener(getHandler());	    
	    oldModel.removePropertyChangeListener(getHandler());
	}
	newModel.addTableModelListener(getHandler());
	newModel.addPropertyChangeListener(getHandler());
  	dataGrid.setModel(new DefaultColumnSorter(new ResultSetDataGridModelAdapter(newModel)));
//  	dataGrid.setModel(newModel);	
    }
    private void queryTable() {
	ResultSetTableModel newModel = createModel();
	setModel(newModel);
	if(!sync) {
	    newModel.reload();
	}
    }
    private JPanel createNorthPanel() {
	JPanel panel = new JPanel();
	panel.setLayout(new BorderLayout());
	toolBar = createToolBar("main-toolbar");
	menuBar = createMenuBar("main-menubar");
	styleBar = createStyleBar();
	panel.add(menuBar, BorderLayout.NORTH);
	panel.add(toolBar, BorderLayout.CENTER);
	panel.add(styleBar, BorderLayout.SOUTH);
	return panel;
    }
    private JStyleBar createStyleBar() {
	JStyleBar styleBar = new JStyleBar();
	styleBar.setFloatable(false);
	styleBar.addChangeListener(getHandler());
	return styleBar;
    }
    
    /**
     * Sets the datagrid for this bean.
     *
     * @param dataGrid the datagrid
     * @since JDataGrid 1.5.1
     */
    public void setDataGrid(JDataGrid dataGrid) {
	JDataGrid oldValue = this.dataGrid;
	this.dataGrid = dataGrid;
	if(oldValue != dataGrid) {
	    if(oldValue != null) {
		oldValue.removePropertyChangeListener(handler);
		oldValue.getSelectionModel().removeListSelectionListener(handler);
		if(centerPanel != null) {
		    centerPanel.removeAll();
		}
	    }
	    if(dataGrid != null) {
		Handler handler = getHandler();
		dataGrid.addPropertyChangeListener(handler);
		dataGrid.getSelectionModel().addListSelectionListener(handler);
		if(centerPanel != null) {
		    centerPanel.add(new JScrollPane(dataGrid), BorderLayout.CENTER);
		}		
	    }
	    // find and speller cannot work?
	    JTextFinder finder = getTextFinder(false);
	    if(finder != null) {
		finder.setForComponent(dataGrid);
	    }
	    JTextSpeller speller = getTextSpeller(false);
	    if(speller != null) {
		speller.setForComponent(dataGrid);
	    }
	    if(styleBar != null) {
		styleBar.setDefaultAttributes(createAttributes(dataGrid));
	    }	    
	}
    }
    private Font getDefaultFont() {
//  	Font font = dataGrid.getFont();
	Font font = new Font("Dialog", Font.PLAIN, 12);
	return font;
    }
    // move to JDataGrid? JDataGrid.createDefaultCellAttributes
    private AttributeSet createAttributes(JDataGrid dataGrid) {
	Font font = getDefaultFont();
	dataGrid.setFont(font);
	SimpleAttributeSet a = new SimpleAttributeSet();
	Color fgColor = dataGrid.getForeground();
	Color bgColor = dataGrid.getBackground();
	StyleConstants.setFontFamily(a, font.getFamily());
	StyleConstants.setFontSize(a, font.getSize());	
	StyleConstants.setBold(a, font.isBold());
	StyleConstants.setItalic(a, font.isItalic());
	StyleConstants.setForeground(a, fgColor);
	StyleConstants.setBackground(a, bgColor);
        if(log.isLoggable(Level.FINE)) {
            log.fine("default attributes: " + a);
        }
	return a;
    }
    /**
     * Returns the datagrid for this bean.
     *
     * @return the datagrid for this bean
     * @since JDataGrid 1.5.1
     */
    public JDataGrid getDataGrid() {
	return dataGrid;
    }
    // TODO: 
    // UNKNOWN_PAGE_COUNT...
    // focus for JStyleBar...
    // add PopupMenu to delete the current row...
    
    /**
     * Creates a datagrid for this bean.
     *
     * @return a new datagrid
     * @since JDataGrid 1.5.1     
     */    
    protected JDataGrid createDataGrid() {
	JDataGrid dataGrid = new JDataTable();
	// disable press key to start editing	
	dataGrid.putClientProperty("JTable.autoStartsEdit", Boolean.FALSE);
	// change the start click count to 2	
//  	dataGrid.putClientProperty("JDataGrid.clickCountToStartsEdit", new Integer(2));
	dataGrid.putClientProperty("JDataGrid.columnSortingEnabled", Boolean.TRUE);
	dataGrid.putClientProperty("JDataGrid.switchUnsortedOrderEnabled", Boolean.TRUE);
	// set selectionBorderPainted property
//  	dataGrid.setSelectionBorderPainted(true);
	dataGrid.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
	dataGrid.getRowHeader().putClientProperty("JLineBar.showArrowIcon", Boolean.TRUE);
	dataGrid.setAlternatingRowBackground(new Color(224, 224, 224));
	dataGrid.getCellSelectionModel().setSelectionMode(CellSelectionModel.SINGLE_INTERVAL_SELECTION);
        dataGrid.setCellSelectionEnabled(true);
	return dataGrid;
    }
    private ResultSet createResultSet() {
	ResultSet rs = null;
	try {
	    Connection conn = DriverManager.getConnection(url, username, new String(password));
	    java.sql.Statement s = null;	    
	    try {
		s = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
				     ResultSet.CONCUR_UPDATABLE);
            } catch (SQLException e) {
                s = conn.createStatement();
                if(log.isLoggable(Level.FINER)) {
                    log.log(Level.FINER, "createStatement faied", e);
                }
            }
            rs = s.executeQuery(command);
        } catch (SQLException e) {
            if(log.isLoggable(Level.FINER)) {
                log.log(Level.FINER, "createResultSet failed", e);
            }
	}
	return rs;
    }
    private ResultSetTableModel createModel() {
	registerDriver();
	setupTable();
	ResultSetTableModel model = null;
	if(!useRowset) {
	    if(passResultSet) {
		// create result set
		ResultSet rs = createResultSet();
		model = new ResultSetTableModel(rs, sync, pageSize);
                if(log.isLoggable(Level.FINE)) {
                    log.fine("Pass ResultSet directly");
                }
	    } else {
		model = new ResultSetTableModel(command, url, username, new String(password), sync, pageSize);
                if(log.isLoggable(Level.FINE)) {
                    log.fine("Pass url directly");
                }
	    }
	    model.setTableName(tableName);
	    model.setKeyColumns(keyColumns);
            if(log.isLoggable(Level.FINE)) {
                log.fine("ResultSetTableModel used");
                log.fine("rowCount="+model.getRowCount()+",columnCount="+model.getColumnCount());
            }
	} else {
	    RowSet rs = null;
	    try {
                if(useCached) {
                    rs = new com.sun.rowset.CachedRowSetImpl();
                    if(log.isLoggable(Level.FINE)) {
                        log.fine("CachedRowSet");
                    }
                } else {
                    rs = new com.sun.rowset.JdbcRowSetImpl();
                    if(log.isLoggable(Level.FINE)) {
                        log.fine("JdbcRowSet");
                    }
                }
		rs.setUrl(url);
		rs.setUsername(username);
		rs.setPassword(new String(password));
		rs.setCommand(command);
	    } catch (SQLException e) {
                if(log.isLoggable(Level.FINER)) {
                    log.log(Level.FINER, "create rowset failed", e);
                }
	    }
	    model = new RowSetTableModel(rs, sync, pageSize);
	    model.setTableName(tableName);
	    model.setKeyColumns(keyColumns);
            if(log.isLoggable(Level.FINE)) {
                log.fine("RowSetTableModel used");
            }
	}
	return model;
    }
    /**
     * <b>Note:</b>This method is not common API, please do not rely
     * on this method even existing.
     */        
    public void doChangeOption() {
	Object[] options = { "HSQLDB", "ODBC", "Derby", "Postgres", "MySQL" };
	JComboBox message = new JComboBox(options);
	int value = JOptionPane.showOptionDialog(this,
						 message,
						 getString("configDialog-title"),
						 JOptionPane.OK_CANCEL_OPTION, 						 
						 JOptionPane.INFORMATION_MESSAGE,
						 null,
						 null,
						 null);
	if(value == JOptionPane.OK_OPTION) {
	    String item = (String)message.getSelectedItem();
	    if(item.equals("Derby")) {
		setupDerby();
	    } else if(item.equals("ODBC")) {
		setupOdbc();
	    } else if(item.equals("HSQLDB")) {
		setupHsqldb();
	    } else if(item.equals("Postgres")) {
		setupPostgres();
	    } else if(item.equals("MySQL")) {
		setupMysql();
	    }
	}
    }
    public void doExport() {
	TableModel model = dataGrid.getModel();
	JFileChooser fc = createFileChooserForExport();
	int retValue = fc.showDialog(this, null);
	if(retValue == JFileChooser.APPROVE_OPTION) {
	    try {
		File f = fc.getSelectedFile();
		if(f != null) {
		    String format = getExtension(f);
		    // enable excel loose format
		    Map map = new HashMap(1);
		    map.put(ModelIO.ENABLE_LOOSE_FORMAT, Boolean.TRUE);
                    System.out.println("format="+format);
                    // end
                    if(format == null) {
                        FileFilter fileFilter = fc.getFileFilter();
                        if(fileFilter instanceof DefaultFileFilter) {
                            format = ((DefaultFileFilter)fileFilter).getPreferredExtensionName();
                            String name = f.getName() + "." + format;
                            f = new File(f.getParent(), name);
                            if(f.exists()) {
                                int option = JOptionPane.showConfirmDialog(this, getString("overideConfirmMessage") + " " + f.getName() + " ?", null, JOptionPane.YES_NO_OPTION);
                                if(option != JOptionPane.YES_OPTION) {
                                    return;
                                }
                            }
                        }
                    }                    
		    ModelIO.writeTableModel(model, format, map, f);
		}
	    } catch (Exception ex) {
                ex.printStackTrace();
		JOptionPane.showMessageDialog(this, ex);
	    }
	}	
    }
    public void doPageSetup() {
	getPrintPreview().pageSetup();
    }
    public void doPrint() {
	getPrintPreview().print(createPrintable(dataGrid));
    }
    public void doPrintPreview() {
	final JPrintPreview printPreview = getPrintPreview();
	JFrame frame = getFrame();
	JInternalFrame internalFrame = getInternalFrame();
	java.applet.Applet applet = (java.applet.Applet)SwingUtilities.getAncestorOfClass(java.applet.Applet.class, this);
  	if(frame != null) {
	    printPreview.showFrame(frame);
	} else if(internalFrame != null) {
	    printPreview.showInternalFrame(internalFrame);
	} else if(applet != null) {
	    printPreview.showApplet(applet);
	} else {
            // show frame when it's not in frame, internalFrame, applet
            printPreview.showFrame();
        }
	// pre.setColorType(JPrintPreview.COLOR);
	// should move to JPrintPreview, use flag to control asynchronized?
	SwingUtilities.invokeLater(new Runnable() {
		public void run() {
		    printPreview.setPrintData(createPrintable(dataGrid));
		}
	    });
    }
    public void doFind() {
	JTextFinder finder = getTextFinder();
	finder.setDialogType(JTextFinder.FIND_DIALOG);	
	finder.showDialog(this);
    }
    public void doFindNext() {
	JTextFinder finder = getTextFinder();
	finder.findNext();
    }
    public void doReplace() {
	JTextFinder finder = getTextFinder();
	finder.setDialogType(JTextFinder.REPLACE_DIALOG);
	finder.showDialog(this);	
    }
    public void doSpell() {
	JTextSpeller speller = getTextSpeller();
	speller.showDialog(this);
    }
    public void doSelectAll() {
	dataGrid.selectAll();
    }
    private boolean isButtonSelected(ActionEvent e) {
	return ((AbstractButton)e.getSource()).isSelected();
    }
    public void doViewToolBar(ActionEvent e) {
	boolean b = isButtonSelected(e);
	toolBar.setVisible(b);
    }
    public void doViewStatusBar(ActionEvent e) {
	boolean b = isButtonSelected(e);
	getStatusBar().setVisible(b);
    }    
    public void doViewRowHeader(ActionEvent e) {
	boolean b = isButtonSelected(e);
	Component header = dataGrid.getRowHeader();
	if(header != null && header.getParent() instanceof JViewport) {
	    header.getParent().setVisible(b);
	}
    }
    public void doViewColumnHeader(ActionEvent e) {
	boolean b = isButtonSelected(e);
	Component header = dataGrid.getTableHeader();
	if(header != null && header.getParent() instanceof JViewport) {
	    header.getParent().setVisible(b);
	}
    }
    private String getPkString() {
	if(keyColumns == null) {
	    return null;
	}
	StringBuffer sb = new StringBuffer(4);
	for(int i=0; i<keyColumns.length; i++) {
	    sb.append(keyColumns[i]+1);
	    sb.append(",");
	}
	if(sb.length() > 0 && sb.charAt(sb.length()-1) == ',') {
	    sb.deleteCharAt(sb.length()-1);
	}
	return sb.toString();
    }
    private int[] convertPkString(String pkString) {
	java.util.List l = new LinkedList();	
	StringTokenizer st = new StringTokenizer(pkString);
	while(st.hasMoreTokens()) {
	    l.add(st.nextToken());
	}
	for(ListIterator i=l.listIterator(); i.hasNext(); ) {
	    String s = (String)i.next();
	    try {
		Integer n = Integer.valueOf(s);
		i.set(n);
	    } catch (NumberFormatException e) {
		error(e);
		i.remove();
	    }
	}
	int[] a = new int[l.size()];
	Iterator it = l.iterator();
	for(int i=0; i<a.length; i++) {
	    a[i] = ((Integer)it.next()).intValue() - 1;
	}
	return a;   
    }
    // actions
    /**
     * <b>Note:</b>This method is not common API, please do not rely
     * on this method even existing.
     */        
    public void doQuery() {
	JLabel tableNameLabel = new JLabel(getString("tableNameText"));
	JLabel pkindexLabel = new JLabel(getString("primarykeyColumnIndexText"));
	JLabel querySqlLabel = new JLabel(getString("querySqlText"));
	JTextField tableNameField = new JTextField(tableName, 16);
	JTextField pkindexField = new JTextField(getPkString(), 4);
	JTextArea queryArea = new JTextArea(command, 4, 20);
	Object[] message = {
	    tableNameLabel,
	    tableNameField,
	    pkindexLabel,
	    pkindexField,
	    querySqlLabel,
	    new JScrollPane(queryArea) };
	int retValue = JOptionPane.showOptionDialog(this,
						    message,
						    getString("queryDialog-title"),
						    JOptionPane.OK_CANCEL_OPTION, 						 
						    JOptionPane.INFORMATION_MESSAGE,
						    null,
						    null,
						    null);
	if(retValue == JOptionPane.OK_OPTION) {
	    String tableName = tableNameField.getText();
	    String pkindex = pkindexField.getText();
	    String command = queryArea.getText();
	    this.tableName = tableName;
	    this.keyColumns = convertPkString(pkindex);
	    if(command != null && !command.equals("")) {
		this.command = command;
		queryTable();
	    }
	}
    }
    /**
     * <b>Note:</b>This method is not common API, please do not rely
     * on this method even existing.
     */        
    public void doPreferences() {
	AbstractButton b1 = createButton("resultset");
	AbstractButton b2 = createButton("rowset");
	AbstractButton b3 = createButton("cached");
	AbstractButton b4 = createButton("sync");
	AbstractButton b5 = createButton("passResultSet");
	JLabel label = new JLabel(getString("pageSizeText"));
	JTextField field = new JTextField(""+pageSize, 4);
	b1.setSelected(!useRowset);
	b2.setSelected(useRowset);
	b3.setSelected(useCached);
	b4.setSelected(sync);
	b5.setSelected(passResultSet);
	Object[] message = { b1, b4, b5, b2, b3, label, field };
	int retValue = JOptionPane.showOptionDialog(this,
						    message,
						    getString("PreferencesDialog-title"),
						    JOptionPane.OK_CANCEL_OPTION, 						 
						    JOptionPane.INFORMATION_MESSAGE,
						    null,
						    null,
						    null);
	if(retValue == JOptionPane.OK_OPTION) {
	    useRowset = b2.isSelected();
	    useCached = b3.isSelected();
	    sync = b4.isSelected();
	    passResultSet = b5.isSelected();
	    String text = field.getText();
	    try {
		pageSize = Integer.parseInt(text);
	    } catch (NumberFormatException e) {
		JOptionPane.showMessageDialog(this, e);
	    }
	}
    }
    /**
     * <b>Note:</b>This method is not common API, please do not rely
     * on this method even existing.
     */        
    public void doOption() {
	JTextField urlField = new JTextField(url, 20);
	JTextField usernameField = new JTextField(username, 9);
	JPasswordField passwordField = new JPasswordField(new String(password), 9);
	JTextField driverField = new JTextField(driver, 25);
	Object[] message = {
	    new JLabel(getString("urlText")),
	    urlField,
	    new JLabel(getString("usernameText")),	    
	    usernameField,
	    new JLabel(getString("passwordText")),	    
	    passwordField,
	    new JLabel(getString("driverText")),
	    driverField };
	int retValue = JOptionPane.showOptionDialog(this,
						    message,
						    getString("optionDialog-title"),
						    JOptionPane.OK_CANCEL_OPTION, 						 
						    JOptionPane.INFORMATION_MESSAGE,
						    null,
						    null,
						    null);
	if(retValue == JOptionPane.OK_OPTION) {
	    String oldUrl = this.url;
	    url = urlField.getText();
	    username = usernameField.getText();
	    password = passwordField.getPassword();
	    driver = driverField.getText();
	}
    }
    public void doNextPage() {
	getModel().nextPage();	
    }
    public void doPreviousPage() {
	getModel().previousPage();	
    }
    public void doGoPage() {
	String s = JOptionPane.showInputDialog(this, "Please input the page number:");
	if(s == null) {
	    return;
	}
	int index = -1;
	try {
	    index = Integer.parseInt(s);
	} catch (NumberFormatException e) {
	    JOptionPane.showMessageDialog(this, e);
	}
	if(index == -1 || index < 1) {
	    return;
	}
	getModel().setPageIndex(index);	
    }
    public void doLastRow() {
        getDataTable().lastRow();
    }
    public void doFirstRow() {
        getDataTable().firstRow();
    }
    public void doNextRow() {
        getDataTable().nextRow();
    }
    public void doPreviousRow() {
        getDataTable().previousRow();
    }
    public void doGoRow() {
	String s = JOptionPane.showInputDialog(this, "Please input the row number:");
	if(s == null) {
	    return;
	}	
	int index = -1;
	try {
	    index = Integer.parseInt(s);
	} catch (NumberFormatException e) {
	    JOptionPane.showMessageDialog(this, e);
	}
	if(index == -1 || index < 1) {
	    return;
	}
	ResultSetTableModel model = getModel();
	if(model != null) {
	    int rowIndex = index-1;
	    if(rowIndex >=0 && rowIndex <= getModel().getAllRowCount()-1) {
		getModel().setRowIndex(rowIndex);		
	    }
	}
    }
    public void doInsertRow() {
        getDataTable().insertRow();
    }
    public void doDeleteRow() {
        getDataTable().deleteRow();
    }
    public void doRefreshRow() {
        getDataTable().refreshRow();
    }
    private JDataTable getDataTable() {
        return (JDataTable)dataGrid;
    }
    private void updateIndexActions() {
	ResultSetTableModel model = getModel();
	if(model != null) {
	    int pageIndex = model.getPageIndex();
	    int pageCount = model.getPageCount();	    
	    int rowCount = model.getRowCount();
            int allRowCount = model.getAllRowCount();
	    // data to model row
	    int row = model.dataToModelRow(model.getRowIndex());
	    // model to sorter row
	    row = modelToSorterRow(row);
	    boolean canNextPage = allRowCount == ResultSetTableModel.UNKNOWN_COUNT || pageIndex < pageCount - 1;
	    boolean canPreviousPage = pageIndex > 0;
	    boolean canNextRow = (canNextPage || row < rowCount-1);
	    boolean canPreviousRow = (canPreviousPage || row > 0);
	    getAction("firstRow").setEnabled(canPreviousRow);
	    getAction("previousRow").setEnabled(canPreviousRow);
	    getAction("lastRow").setEnabled(canNextRow);
	    getAction("nextRow").setEnabled(canNextRow);
	    getAction("previousPage").setEnabled(canPreviousPage);
	    getAction("nextPage").setEnabled(canNextPage);
	} else {
	    disableIndexActions();
	}
    }
    // Todo:
    private void disableIndexActions() {
	getAction("firstRow").setEnabled(false);
	getAction("previousRow").setEnabled(false);
	getAction("lastRow").setEnabled(false);
	getAction("nextRow").setEnabled(false);
	getAction("previousPage").setEnabled(false);
	getAction("nextPage").setEnabled(false);
    }
    private void updateStatusBar() {
	String text = null;
	ResultSetTableModel model = getModel();
	if(model != null) {
	    MessageFormat format = new MessageFormat(getString("status-message"));
	    int pageIndex = model.getPageIndex();
	    int pageCount = model.getPageCount();
	    int rowIndex = model.getRowIndex();
	    int rowCount = model.getAllRowCount();
	    text = format.format(new Object[] {
		new Integer(rowIndex+1),
		new Integer(rowCount),
		new Integer(pageIndex+1),
		new Integer(pageCount)
		    });
	}
	getStatusBar().setText(text);
    }
    private void error(Exception e) {
        if(log.isLoggable(Level.FINER)) {
            log.log(Level.FINER, e.getMessage(), e);
        }
    }
    /**
     * Returns the print preview component.
     *
     * @return the print preview component
     * @since JDataGrid 1.5.1
     */
    public JPrintPreview getPrintPreview() {
	return getPrintPreview(true);
    }
    private JPrintPreview getPrintPreview(boolean create) {
	JPrintPreview printPreview = null;
	if(uiMap != null) {
	    printPreview = (JPrintPreview)uiMap.get("print-preview");
	}
	if(printPreview == null && create) {
	    printPreview = createPrintPreview();
	    uiMap.put("print-preview", printPreview);
	}
	return printPreview;
    }        
    private JPrintPreview createPrintPreview() {
	JPrintPreview printPreview = new JPrintPreview();
	return printPreview;
    }
    /**
     * Creates the printable for the specified data grid.
     *
     * @param dataGrid the dataGrid
     * @return the printable
     * @since JDataGrid 1.5.1
     */    
    protected Printable createPrintable(JDataGrid dataGrid) {
	Map map = (printProperties != null ? printProperties : createPrintProperties());
	return PrintFactory.createPrintable(dataGrid, map);
    }
    
    private Map printProperties;

    /**
     * Returns the print properties.
     * @return the print properties
     * @since JDataGrid 2.5.0
     */
    public Map getPrintProperties() {
        return printProperties;
    }

    /**
     * Sets the print properties.
     * @param printProperties the print properties
     * @since JDataGrid 2.5.0
     */
    public void setPrintProperties(Map printProperties) {
        Map oldValue = this.printProperties;
        this.printProperties = printProperties;
        firePropertyChange("printProperties", oldValue, printProperties);
    }
    
    /**
     * Creates the default print properties.
     * @return the print properties
     * @since JDataGrid 2.5.0
     */    
    public Map createPrintProperties() {
        Map map = new HashMap();
	map.put(PrintFactory.HORIZONTAL_ALIGNMENT, new Integer(SwingConstants.CENTER));
	// map.put(PrintFactory.ORIENTATION, new Integer(SwingConstants.VERTICAL));
	map.put(PrintFactory.CENTER_MARGIN, new Insets(6, 0, 6, 0));	
	map.put(PrintFactory.HEADER_FORMAT, new MessageFormat(getTitle()));
	map.put(PrintFactory.HEADER_MARGIN, new Insets(0, 0, 6, 0));
	map.put(PrintFactory.HEADER_TEXT_ALIGNMENT, new Integer(SwingConstants.CENTER));
	map.put(PrintFactory.HEADER_ICON, getIcon("logo-small-image"));	
	map.put(PrintFactory.FOOTER_FORMAT, new MessageFormat("Page {0}"));
	map.put(PrintFactory.FOOTER_MARGIN, new Insets(6, 0, 0, 0));
	map.put(PrintFactory.FOOTER_ALIGNMENT, new Integer(SwingConstants.RIGHT));
	map.put(PrintFactory.SHOW_HEADER_LINE, Boolean.TRUE);
	map.put(PrintFactory.SHOW_FOOTER_LINE, Boolean.TRUE);	
	// map.put(PrintFactory.TABLE_SHOW_ROW_HEADER, Boolean.FALSE);
	// map.put(PrintFactory.TABLE_SHOW_COLUMN_HEADER, Boolean.FALSE);
	// map.put(PrintFactory.TABLE_SHOW_GRID_LINE, Boolean.FALSE);
	// map.put(PrintFactory.TABLE_PRINT_AREA, dataTable.getSelectedCell());
        return map;
    }    
    private static String getExtension(File f) {
	String name = f.getName();
	int index = name.lastIndexOf(".");
	if(index != -1) {
	    name = name.substring(index+1);
	}
	return null;
    }    
    private JFileChooser createFileChooserForExport() {
//  	JFileChooser fc = new JFileChooser(new File(System.getProperty("user.dir")));
	JFileChooser fc = new JFileChooser();	
	fc.setApproveButtonText(getString("exportButton.name"));
	Integer mnemonic = getResourceManager().getMnemonic("exportButton.mnemonic");
	if(mnemonic != null) {
	    fc.setApproveButtonMnemonic(mnemonic.intValue());
	}	
	fc.setApproveButtonToolTipText(getString("exportButton.desc"));
	fc.addChoosableFileFilter(new DefaultFileFilter("txt", getString("txt.desc")));
	fc.addChoosableFileFilter(new DefaultFileFilter("csv", getString("csv.desc")));
	fc.addChoosableFileFilter(new DefaultFileFilter(new String[] {"html","htm"}, getString("html.desc")));
	fc.setAcceptAllFileFilterUsed(false);	
	return fc;
    }
    private JTextFinder getTextFinder() {
	return getTextFinder(true);
    }
    private JTextFinder getTextFinder(boolean create) {
	JTextFinder finder = null;
	if(uiMap != null) {
	    finder = (JTextFinder)uiMap.get("finder");
	}
	if(finder == null && create) {
	    finder = createTextFinder();
	    finder.setForComponent(dataGrid);
	    uiMap.put("finder", finder);
	}
	return finder;
    }        
    private JTextFinder createTextFinder() {
	JTextFinder finder = new JTextFinder();
	return finder;
    }
    private JTextSpeller getTextSpeller() {
	return getTextSpeller(true);
    }
    private JTextSpeller getTextSpeller(boolean create) {
	JTextSpeller speller = null;
	if(uiMap != null) {
	    speller = (JTextSpeller)uiMap.get("speller");
	}
	if(speller == null && create) {
	    speller = createTextSpeller();
	    speller.setForComponent(dataGrid);
	    uiMap.put("speller", speller);
	}
	return speller;
    }    
    private JTextSpeller createTextSpeller() {
	JTextSpeller speller = new JTextSpeller();
	return speller;
    }    
    private ResultSetTableModel getModel() {
        return getDataTable().getResultSetTableModel();
    }
    private DefaultColumnSorter getSorter() {
	TableModel model = dataGrid.getModel();
	if(model instanceof DefaultColumnSorter) {
	    return (DefaultColumnSorter)model;
	} else {
	    return null;
	}
    }
    private int sorterToModelRow(int row) {
	DefaultColumnSorter sorter = getSorter();
	if(sorter != null) {
	    return sorter.sorterToModelRow(row);
	} else {
	    return row;
	}	
    }
    private int modelToSorterRow(int row) {
	DefaultColumnSorter sorter = getSorter();
	if(sorter != null) {
	    return sorter.modelToSorterRow(row);
	} else {
	    return row;
	}	
    }
    private int modelToDataRow(int row) {
	ResultSetTableModel model = getModel();
	if(model != null) {
	    return model.modelToDataRow(row);
	} else {
	    return row;
	}
    }
    private int dataToModelRow(int row) {
	ResultSetTableModel model = getModel();
	if(model != null) {
	    return model.dataToModelRow(row);
	} else {
	    return row;
	}	
    }
    private int sorterToDataRow(int row) {
	return modelToDataRow(sorterToModelRow(row));
    }
    private int dataToSorterRow(int row) {
	return modelToSorterRow(dataToModelRow(row));
    }
    // get handler
    private Handler getHandler() {
	if(handler == null) {
	    handler = new Handler();
	}
	return handler;
    }    
    // event 
    private void doPageIndexChanged(PropertyChangeEvent e) {
	dataGrid.getRowHeader().setFirstLineIndex(getModel().getFirstRowIndex());
	updateIndexActions();
	updateStatusBar();
	dataGrid.putClientProperty("JDataGrid.sortColumn", null);
	dataGrid.putClientProperty("JDataGrid.sortOrder", null);
    }
    private void doRowIndexChanged(PropertyChangeEvent e) {
        if(log.isLoggable(Level.FINE)) {
            log.log(Level.FINE, "rowCount="+dataGrid.getRowCount()+",model rowcount="+getModel().getRowCount());
        }
	dataGrid.getRowHeader().setFirstLineIndex(getModel().getFirstRowIndex());	
	int rowIndex = ((Integer)e.getNewValue()).intValue();
	int sorterRow = dataToSorterRow(rowIndex);
	int leadColumn = dataGrid.getColumnModel().getSelectionModel().getLeadSelectionIndex();
	if(leadColumn <0 || leadColumn > dataGrid.getColumnCount()-1) {
	    leadColumn = 0;
	}
	if(!dataGrid.isCellSelected(sorterRow, leadColumn)) {
	    dataGrid.selectCell(sorterRow, leadColumn);
	    dataGrid.changeSelection(sorterRow, leadColumn, false, false);
	}
        if(log.isLoggable(Level.FINE)) {
            log.fine("sorterRow="+sorterRow+",leadColumn="+leadColumn);
        }
	updateIndexActions();
	updateStatusBar();
    }
    private void doPageCountChanged(PropertyChangeEvent e) {
	updateIndexActions();
	updateStatusBar();
    }
    private void doAllRowCountChanged(PropertyChangeEvent e) {
	updateIndexActions();
	updateStatusBar();
    }
    private void doModelChanged(PropertyChangeEvent e) {
	updateIndexActions();
	updateStatusBar();
    }
    private void doTableChanged(TableModelEvent e) {
	updateIndexActions();
	updateStatusBar();	
    }
    // handler
    class Handler implements PropertyChangeListener,
			     TableModelListener,
			     ListSelectionListener,
			     ChangeListener {
	// PropertyChangeListener
	public void propertyChange(PropertyChangeEvent e) {
            String property = e.getPropertyName();
	    if(property == "pageIndex") {
		doPageIndexChanged(e);
	    } else if(property == "rowIndex") {
		doRowIndexChanged(e);
	    } else if(property == "pageCount") {
		doPageCountChanged(e);
	    } else if(property == "allRowCount") {
		doAllRowCountChanged(e);
	    } else if(property == "model") {
		doModelChanged(e);
	    }
        }
	public void tableChanged(TableModelEvent e) {
	    doTableChanged(e);
	}
	public void valueChanged(ListSelectionEvent e) {
	    if(!e.getValueIsAdjusting()) {
		int sorterRow = dataGrid.getSelectionModel().getLeadSelectionIndex();
		boolean selected = dataGrid.getSelectionModel().isSelectedIndex(sorterRow);
		if(sorterRow >= 0 && selected) {
		    int dataRow = sorterToDataRow(sorterRow);
		    getModel().setRowIndex(dataRow);
		}
	    }
	    changeStyleBar(e);
	}
	private void changeStyleBar(ListSelectionEvent e) {
	    if(!e.getValueIsAdjusting()) {
		int row = dataGrid.getSelectionModel().getLeadSelectionIndex();
		int column = dataGrid.getColumnModel().getSelectionModel().getLeadSelectionIndex();
		if(row != -1 && column != -1) {
		    if(dataGrid.getSelectionModel().isSelectedIndex(row) &&
		       dataGrid.getColumnModel().getSelectionModel().isSelectedIndex(column)) {
			styleBar.setAttributes(dataGrid.getCellAttributes(row, column));
		    }
		}
	    }	    
	}
	public void stateChanged(ChangeEvent e) {
	    AttributeSet a = styleBar.getChangedAttributes();
	    if(a == null) {
		// should not handle it
		return;
	    }
	    dataGrid.setCellAttributes(a);
	}
    }
}