package com.vci.client.ui.swing.components.table;

/**
 * 
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2012</p>
 * <p>Company: VCI</p>
 * @author xchao
 * @time 2012-5-10
 * @version 1.0
 */
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.regex.Pattern;

import javax.swing.ImageIcon;
import javax.swing.JProgressBar;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.event.EventListenerList;

import com.vci.client.ui.swing.VCISwingUtil;
import com.vci.client.ui.swing.components.VCIJButton;
import com.vci.client.ui.swing.components.VCIJComboBox;
import com.vci.client.ui.swing.components.VCIJLabel;
import com.vci.client.ui.swing.components.VCIJOptionPane;
import com.vci.client.ui.swing.components.VCIJPanel;
import com.vci.client.ui.swing.components.VCIJScrollPane;
import com.vci.client.ui.swing.components.VCIJTable;
import com.vci.client.ui.swing.components.VCIJTextField;
import com.vci.client.ui.swing.components.table.export.VCIJTablePanelExportFilterDialog;
import com.vci.client.ui.swing.components.table.setting.ColumnSettingDialog;

public class VCIJTablePanel<T> extends VCIJPanel {
	/**
	 * 
	 */
	private static final long serialVersionUID = 3819801333985740641L;

	protected Component parentComponent = null;
	public void setParentComponent(Component parentComponent){
		this.parentComponent = parentComponent;
	}
	/************************  表格定制相关的 *********************************/
	private VCIJTableSorter sorter = null;
	private int headerHeight = VCISwingUtil.JTABLE_HEADER_HEIGHT;
	private int rowHeight = VCISwingUtil.JTABLE_HEADER_HEIGHT;
	private boolean showCheckbox = true;	// 是否显示CheckBox
	private boolean showRowNumber = true;	// 是否显示序号
	private boolean showPaging = true;		// 是否显示翻页按钮，不显示翻页按钮时，一次查询最大量（）的数据
	private boolean showExport = true;		// 是否显示导出按钮
	private boolean showColumnSetting = true;// 是否显示列设置按钮
	private boolean enableSorter = true;	// 是否启用排序
	private boolean enableMouseClickEffect = true;	// 是否启用在表格单元格上单击时，自动选中CheckBox效果
	private boolean enableMouseMoveEffect = true;		// 是否启用鼠标在单元格上移动时，当前行高亮显示的效果
	/**
	 *  是否启用 鼠标停留在数据行上时，行颜色自动高亮
	 */
	private boolean enableRowColorChangeInMouseHover = true;
	/**
	 * 是否启用鼠标按下拖动（框选）时，执行将数据行选中
	 */
	private boolean enbleMouseDraggedChecked = false;	
	protected IVCIJTableBaseCheckManager tbChkManager = null;
	private boolean isSingleCheckManager = false;
	private Integer columnDefaultWidth = 100;
	private Integer columnDefaultWidthMax = 2500;
	private HashMap<Integer, Integer> columnWidthMaps = new HashMap<Integer, Integer>();
	private int pageButtonFlowAlign = FlowLayout.LEFT;
	private int customButtonFlowAlign = FlowLayout.LEFT;
	private boolean customButtonAutoScroll = true;
	private int[] pageSizeList = null;
	private VCIJTableModel<T> tableModel = null;
	private VCIJTable table = null;
	private VCIJTableDataProvider<T> dataProvider = null;
	// 列是否可以移动顺序，默认为false，不可移动顺序
	private boolean reorderingAllowed = false;
	// 列是否可以拖动宽度，默认true，可以拖动
	private boolean resizingAllowed = true;
	// 是否显示网络线，默认true,显示
	private boolean showGrid = true;
	// 是否启用列选择，默认为true，可以选择列（不是一整行）
	private boolean columnSelectionAllowed = true;
	// Table列自动调整大小模式
	private int autoResizeMode = JTable.AUTO_RESIZE_OFF;
	// 行选择模式，默认支持多行选择
	private int selectionMode = ListSelectionModel.MULTIPLE_INTERVAL_SELECTION;//ListSelectionModel.MULTIPLE_INTERVAL_SELECTION;
	// 可编辑列的索引
	private List<Integer> ediableColumnList = new LinkedList<Integer>();
	private boolean cellEditable = false;
	
	// 加载数据时，是否显示进度条
	private boolean showProgressBar = true;
	// 是否是最后点击行才被选中，同时清空当前已经选中的其它数据模式是否生效
	private boolean lastClickRowToChecked = true;
	/************************  翻页相关的 *********************************/
	private VCIJComboBox cbxPageSize = new VCIJComboBox();
	private VCIJButton btnFirst = this.createNewButton("tablepage_first.png", "首页");
	private VCIJButton btnPrev = this.createNewButton("tablepage_pre.png", "上一页");
	private VCIJButton btnNext = this.createNewButton("tablepage_next.png", "下一页");
	private VCIJButton btnLast = this.createNewButton("tablepage_last.png", "尾页");
	private VCIJButton btnReload = this.createNewButton("tablepage_refresh.png", "刷新");

	private VCIJTextField txtPageIndex = new VCIJTextField("1", 5);
	private VCIJButton btnGoPage = this.createNewButton("tablepage_go.png", "跳转到指定页");
	
	private final String PAGE_INFO_FORMAT = "共{0}条，共{1}页，第{2}页"; 
	private VCIJLabel lblPageInfo = new VCIJLabel(PAGE_INFO_FORMAT);
	private int total = 0;
	private int pageCount = 0;
	private int pageIndex = 1;
	private int pageSize = 50;


	private VCIJButton btnExport = this.createNewButton("xls.png", "导出数据");
	private VCIJButton btnColumnSetting = this.createNewButton("table.png", "调整列宽");
	
	/************************  自定义按钮相关的 *********************************/
	private List<VCIJButton> customButtons = new LinkedList<VCIJButton>();			// 自定义功能按钮
	
	protected EventListenerList checkListeners = new EventListenerList();
	public void addCheckListener(VCIJTableCheckListener checkListener){
		listenerList.add(VCIJTableCheckListener.class, checkListener);
	}
	public void removeCheckListener(VCIJTableCheckListener checkListener){
		listenerList.remove(VCIJTableCheckListener.class, checkListener);
	}
	
	/**
	 * 
	 * @param dataProvider dataProvider
	 */
	public VCIJTablePanel(VCIJTableDataProvider<T> dataProvider){
		this.parentComponent = this;
		this.dataProvider = dataProvider;
		if(this.dataProvider != null){
			this.tableModel = new VCIJTableModel<T>(this, dataProvider.getColumns(), dataProvider.getClasses());
		}
	}
	
	private VCIJScrollPane dataScrollPane = new VCIJScrollPane();
	public VCIJScrollPane getDataScrollPane(){
		return dataScrollPane;
	}
	private VCIJScrollPane getVCIJTableScrollPane(){
		if(this.isEnableSorter()){
			this.sorter = new VCIJTableSorter(this.tableModel);
			this.table = new VCIJTable(this.sorter);
			this.sorter.setTableHeader(this.table.getTableHeader());
		}else{
			this.table = new VCIJTable(tableModel);
		}		
		this.setTableStyle(this.table);
		dataScrollPane = new VCIJScrollPane();
		dataScrollPane.getViewport().add(this.table);
		return dataScrollPane;
	}
	
	private void addCheckBoxColumnToTable(){
		if (isSingleCheckManager) {
			this.tbChkManager = new VCIJTableRadioManager(this, this.table);
		}else {
			this.tbChkManager = new VCIJTableCheckBoxManager(this, this.table);
		}
    	tbChkManager.setHeaderShowCheckbox(0);
	}
	private void setTableStyle(VCIJTable table){
		table.setFont(VCISwingUtil.FONT_DEFAULT);
		table.getTableHeader().setFont(VCISwingUtil.FONT_DEFAULT);
		table.setRowHeight(getRowHeight());
		table.getTableHeader().setReorderingAllowed(isReorderingAllowed());	// 列可移动顺序
		table.getTableHeader().setResizingAllowed(isResizingAllowed());		// 列可以以改变大小
		table.setAutoResizeMode(getAutoResizeMode()); 						// 关闭自动计算列大小
		table.setShowGrid(isShowGrid());									// 显示网络
		table.setColumnSelectionAllowed(isColumnSelectionAllowed());		// 一次只能选择到一列。
		table.setSelectionMode(getSelectionMode());
		// 添加checkbox列，如果设置了不显示checkbox列，则列列宽为0（在后面构建时处理的）
		this.addCheckBoxColumnToTable();
		SimpleMouseListener<T> mouseListener = new SimpleMouseListener<T>(this, this.table);
		table.addMouseListener(mouseListener);
		table.addMouseMotionListener(mouseListener);
		
		
		IndexColumnTableCellRender<T>  tableCellRender = new IndexColumnTableCellRender<T>(this);
		tableCellRender.setTableCheckBoxManager(tbChkManager);

		for(int i = 0; i < this.table.getColumnModel().getColumnCount(); i++){
			int width = this.getColumnDefaultWidth();
			int widthMax = this.getColumnDefaultWidthMax();
			if(i == 0){
				width = 30;
				widthMax = 30;
				if(this.isShowCheckbox()){
					if(this.getColumnWidthMaps().containsKey(i)){
						width = this.getColumnWidthMaps().get(i);
					}
				} else{
					width = 0;
					widthMax = 0;
				}
			} else if(i == 1){
				width = 50;
				widthMax = 50;
				if(this.isShowRowNumber()){
					if(this.getColumnWidthMaps().containsKey(i)){
						width = this.getColumnWidthMaps().get(i);
					}
				} else {
					width = 0;
					widthMax = 0;
				}
			}else{
				if(this.getColumnWidthMaps().containsKey(i)){
					width = this.getColumnWidthMaps().get(i);
				}
			}
			table.getColumnModel().getColumn(i).setMinWidth(1);
			table.getColumnModel().getColumn(i).setMaxWidth(widthMax);
			table.getColumnModel().getColumn(i).setPreferredWidth(width);
			if(i != 0 ){
//				table.getColumnModel().getColumn(i).setCellRenderer(new IndexColumnTableCellRender<T>(this));
				
				if (isImageColumn(table, i)) {
					VciIconRenderer<T> iconRenderer = new VciIconRenderer<T>(this);
					iconRenderer.setTableCheckBoxManager(tbChkManager);
					table.getColumnModel().getColumn(i).setCellRenderer(iconRenderer);
					continue;
				}
				
				table.getColumnModel().getColumn(i).setCellRenderer(tableCellRender);
			}
		}
	}
	
	private boolean isImageColumn(VCIJTable table, int i) {
		boolean rs = false;
		if (table.getModel().getColumnClass(i) == ImageIcon.class) {
			return true;
		}
		return rs;
	}

	/**
	 * 构建TablePanel
	 */
	public void buildTablePanel(){
		this.setLayout(new BorderLayout());
		this.add(this.getVCIJTableScrollPane(), BorderLayout.CENTER);
		if(!this.isCustomButtonAutoScroll()) {
			this.add(this.getOperateButtonPanel(), BorderLayout.SOUTH);
		} else {
			VCIJScrollPane southJSP = new VCIJScrollPane();
			southJSP.getViewport().add(this.getOperateButtonPanel());
			int height = 0;
			if(isShowPaging() && showCustomButtons()){
				height = 100;
			} else if(this.isShowPaging() || this.isShowExport() || this.showCustomButtons()){
				height = 60;
			}
			southJSP.setPreferredSize(new Dimension(getWidth(), height));
			southJSP.setMaximumSize(new Dimension(getWidth(), height));
			southJSP.setMinimumSize(new Dimension(getWidth(), height));
			
			this.add(southJSP, BorderLayout.SOUTH);
		}
		this.setDefaultStyle();
		setProcessBarValueString("");
	}
	public void buildTablePanel(boolean isSingleCheckManager){
		this.isSingleCheckManager = isSingleCheckManager;
		this.buildTablePanel();
	}
	
	private void setDefaultStyle(){
		btnFirst.setEnabled(false);
		btnLast.setEnabled(false);
		btnPrev.setEnabled(false);
		btnNext.setEnabled(false);
		lblPageInfo.setText(MessageFormat.format(PAGE_INFO_FORMAT, new Object[]{0, 0, 0}));
	}
	
	/**
	 * 返回底部操作的主Panel
	 * @return
	 */
	private VCIJPanel getOperateButtonPanel(){
		int rows = 1;
		int columns = 1;
		// 即包含分页按钮又包含自功能按钮，则将自定义功能按钮添加到第二行
		if(isShowPaging() && showCustomButtons()){
			rows += 1;
		}
		GridLayout layout = new GridLayout(rows, columns);
		VCIJPanel pal = new VCIJPanel(layout);
		pal.add(getPageButtonPanel());
		// 将自定义功能按钮添加到第二
		if(isShowPaging() && showCustomButtons()){
			pal.add(getCustomButtonPanel());
		}
		initPagerButtonAction();
		return pal;
	}

	/**
	 * 返回翻页按钮所在的Panel
	 * @return
	 */
	private VCIJPanel getPageButtonPanel(){
		VCIJPanel pal = new VCIJPanel(new FlowLayout(getPageButtonFlowAlign()));
		VCIJComboBox cbxPageSizes = getPageSizeComboBox(); 
		if(this.isShowPaging()){
			pal.add(cbxPageSizes);
			Dimension dim = new Dimension(25, 25);
			btnFirst.setMinimumSize(dim);
			btnFirst.setMaximumSize(dim);
			btnFirst.setPreferredSize(dim);
			pal.add(btnFirst);
			btnPrev.setMinimumSize(dim);
			btnPrev.setMaximumSize(dim);
			btnPrev.setPreferredSize(dim);
			pal.add(btnPrev);
			pal.add(txtPageIndex);
			btnGoPage.setMinimumSize(dim);
			btnGoPage.setMaximumSize(dim);
			btnGoPage.setPreferredSize(dim);
			pal.add(btnGoPage);
			btnNext.setMinimumSize(dim);
			btnNext.setMaximumSize(dim);
			btnNext.setPreferredSize(dim);
			pal.add(btnNext);
			btnLast.setMinimumSize(dim);
			btnLast.setMaximumSize(dim);
			btnLast.setPreferredSize(dim);
			pal.add(btnLast);
			btnReload.setMinimumSize(dim);
			btnReload.setMaximumSize(dim);
			btnReload.setPreferredSize(dim);
			pal.add(btnReload);
			pal.add(lblPageInfo);
			if(isShowExport()){
				pal.add(btnExport);
				if(isShowColumnSetting()){
					pal.add(btnColumnSetting);
				}
				addProcessBarToPanel(pal);
			}
		} else{
			pal.setLayout(new FlowLayout(getCustomButtonFlowAlign()));
			// 不显示翻页按钮时，设置页大小为最大
			pageSize =  ((Integer)cbxPageSizes.getItemAt(cbxPageSizes.getItemCount() - 1)).intValue();
			// 不显示翻页按钮，又存在自定义按钮时，则将自定义添加按钮添加到导出按钮的前面
			if(showCustomButtons()){
				for(VCIJButton btn : getCustomButtonsList()){
					pal.add(btn);
				}
			}

			if(isShowExport()){
				pal.add(btnExport);
				if(isShowColumnSetting()){
					pal.add(btnColumnSetting);
				}
				addProcessBarToPanel(pal);
			}
		}
		return pal;
	}
	
	private boolean showCustomButtons(){
		return (getCustomButtonsList() != null && getCustomButtonsList().size() > 0);
	}
	
	private VCIJComboBox getPageSizeComboBox(){
		VCIJComboBox cbx = new VCIJComboBox();
		int[] pageSizeList = getPageSizeList();
		if(pageSizeList == null || (pageSizeList != null && pageSizeList.length == 0)){
			setDefaultPageSizeList(cbx);
		} else{
			//edit by guo 当表格的每页行数只有一个选项时，直接添加到下拉框中；有多个选项的时候，设置默认的为list的最后一项，并把前面的选项添加到下拉框中，注：最后一项不添加，已经重复
			if(pageSizeList.length>1){
				int existItem = pageSizeList[pageSizeList.length-1];
				for(int i = 0; i < pageSizeList.length-1; i++){
					int pageSize = pageSizeList[i];
					if(i == 0){
						setPageSize(pageSize);
					}
					cbx.addItem(pageSize);
				}
				cbx.setSelectedItem(existItem);
				setPageSize(existItem);
			} else {
				for(int i = 0; i < pageSizeList.length; i++){
					int pageSize = pageSizeList[i];
					if(i == 0){
						setPageSize(pageSize);
					}
					cbx.addItem(pageSize);
				}
			}
		}
		this.cbxPageSize = cbx;
		return cbx;
	}
	
	private void setDefaultPageSizeList(VCIJComboBox cbx){
		cbx.addItem(50);
		int base = 100;
		for(int i = 1; i < 20; i++){
			if(i > 10){
				cbx.addItem((i - 10 + 1) * 1000);
			}else{
				cbx.addItem(i * base);
			}
		}
		cbx.setSelectedIndex(0);
		cbx.setSelectedItem(50);
	}
	
	private VCIJButton createNewButton(String icon, String toolTopText){
		VCIJButton btn = new VCIJButton();
		btn.setToolTipText(toolTopText);
		btn.setIcon(createImageIcon(icon));
		return btn;
	}
	
	private ImageIcon createImageIcon(String icon){
		return VCISwingUtil.createImageIcon(icon);
	}
	
	/**
	 * 返回自定义功能按钮所在的Panel
	 * @return
	 */
	private VCIJPanel getCustomButtonPanel(){
		VCIJPanel pal = new VCIJPanel(new FlowLayout(getCustomButtonFlowAlign()));
		List<VCIJButton> btns = this.getCustomButtonsList();
		// 如果不显示分页，但又需要显示导出，则将导出按钮与自定义功能按钮放在一行
		if(!isShowPaging() && isShowExport()){
			pal.add(btnExport);
			if(isShowColumnSetting()){
				pal.add(btnColumnSetting);
			}
			addProcessBarToPanel(pal);
		}
		for(VCIJButton btn : btns){
			pal.add(btn);
		}
		return pal;
	}
	
	private void addProcessBarToPanel(VCIJPanel pal){
		if(isShowProgressBar()){
			progressBar.setIndeterminate(true);
			pal.add(progressBar);
			pal.add(lblProgressStatus);
			
			Font font = new Font("宋体", Font.PLAIN, 14);
			lblProgressStatus.setForeground(Color.BLUE);
			lblProgressStatus.setFont(font);
		}
	}
	
	private void setProcessBarValueString(String value){
		String text = value;
		boolean visible = true;
		if(value == null || "".equals(value)){
			text = "";
			visible = false;
		}
		lblProgressStatus.setText(text);
		progressBar.setVisible(visible);
	}
	
	private void setButtonsEnabled(boolean enabled){
		List<VCIJButton> btns = getCustomButtonsList();
		for(VCIJButton btn : btns){
			btn.setEnabled(enabled);
		}
		cbxPageSize.setEnabled(enabled);
		btnFirst.setEnabled(enabled);
		btnPrev.setEnabled(enabled);
		btnNext.setEnabled(enabled);
		btnLast.setEnabled(enabled);
		btnReload.setEnabled(enabled);
		btnGoPage.setEnabled(enabled);
		btnExport.setEnabled(enabled);
		btnColumnSetting.setEnabled(enabled);
	}
	
	private JProgressBar progressBar = new JProgressBar(JProgressBar.HORIZONTAL,1,100);
	private VCIJLabel lblProgressStatus = new VCIJLabel("");
	
	private void initPagerButtonAction(){
		btnFirst.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			pageToFirst();
		}});
		btnPrev.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			pageToPrevious();
		}});
		btnNext.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			pageToNext();
		}});
		btnLast.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			pageToEnd();
		}});
		btnReload.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			pageToReload();
		}});
		txtPageIndex.addKeyListener(new KeyAdapter(){public void keyReleased(KeyEvent e) {
			if(e.getKeyCode() == KeyEvent.VK_ENTER){
				btnGoPage.doClick();
			}
		}});
		btnGoPage.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			pageToPage();
		}});
		cbxPageSize.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {
			pageToPageSizeChange();
		}});
		btnExport.setText("导出");
		btnExport.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			exportData();
		}});

		btnColumnSetting.setText("列设置");
		btnColumnSetting.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e) {
			columnSetting();
		}});
	}
	
	private void pageToFirst(){
		pageIndex = 1;
		this.refreshTableData();
	}

	private void pageToPrevious(){
		pageIndex--;
		if(pageIndex <= 0){
			pageIndex = 1;
		}
		this.refreshTableData();
	}
	
	private void pageToNext(){
		pageIndex++;
		if(pageIndex > pageCount){
			pageIndex = pageCount;
		}
		this.refreshTableData();
	}
	
	private void pageToEnd(){
		pageIndex = pageCount;
		this.refreshTableData();
	}
	
	private void pageToReload(){
		this.refreshTableData();
	}
	
	private void pageToPage(){
		String number = this.txtPageIndex.getText();
		Pattern p = Pattern.compile("[0-9]+");
		int maxIntStrLen = String.valueOf(Integer.MAX_VALUE).length();
		if(!p.matcher(number).matches()){
			VCIJOptionPane.showError(parentComponent, "只能按正整数查询");
			this.setPageIndexToTextField(pageIndex);
			return;
		} else if(number.length() > maxIntStrLen){
			VCIJOptionPane.showError(parentComponent, "输入的页数长度不得超过 " + String.valueOf(maxIntStrLen) + " 位");
			this.setPageIndexToTextField(pageIndex);
			return;
		} else if(Double.parseDouble(number) > Integer.MAX_VALUE){
			VCIJOptionPane.showError(parentComponent, "输入的页数不得大于 " + String.valueOf(Integer.MAX_VALUE));
			this.setPageIndexToTextField(pageIndex);
			return;
		}
		
		int iptPageIndex = Integer.valueOf(number);
		if(iptPageIndex <= 0 || iptPageIndex > pageCount){
			VCIJOptionPane.showError(parentComponent, 
					MessageFormat.format("只能输入{0}-{1}之间的数值进行查询",
							new Object[]{1, pageCount}));
			this.setPageIndexToTextField(pageIndex);
			return;
		}
		pageIndex = iptPageIndex;
		this.refreshTableData();
		this.txtPageIndex.requestFocus();
	}
	
	private void setPageIndexToTextField(int pageIndex){
		this.txtPageIndex.setText(String.valueOf(pageIndex));
	}

	private void pageToPageSizeChange(){
		VCISwingUtil.invokeLater(new Runnable(){
			public void run(){
				setPageSize(((Integer)cbxPageSize.getSelectedItem()).intValue());
				setPageIndex(1);
				refreshTableData();
			}
		}, 0);
	}
	
	
	private void exportData(){
		if(tableModel.getList().size() <= 0){
			VCIJOptionPane.showMessage(this, "没有数据可供导出！");
			return;
		}
		final VCIJTablePanel<T> tablePanel = this;
		VCISwingUtil.invokeLater(new Runnable() {
			public void run() {
				VCIJTablePanelExportFilterDialog<T> dialog = new VCIJTablePanelExportFilterDialog<T>(tablePanel);
				dialog.setModal(true);
				dialog.setVisible(true);
			}
		}, 0);
	}
	private void columnSetting(){
		final VCIJTablePanel<T> tablePanel = this;
		VCISwingUtil.invokeLater(new Runnable() {
			public void run() {
				ColumnSettingDialog<T> dialog = new ColumnSettingDialog<T>(tablePanel);
				dialog.buildDialog();
				dialog.setModal(true);
				dialog.setVisible(true);
			}
		}, 0);
	}
	/**
	 * 刷新数据
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-4
	 * @param datas 数据列表
	 */
	public void refreshTableData(T[] datas){
		refreshTableData(datas, true, true);
	}
	/**
	 * 向Table中追加数据
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-5
	 * @param datas
	 */
	public void addTableData(T[] datas){
		refreshTableData(datas, true, false);
	}

	/**
	 * 调用DataProvider的getDatas(pageIndex, pageSize)来填充Table
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-5
	 */
	public void refreshTableData(){
		if(isShowProgressBar()){
			refreshTableDataByProgressBar();
		} else {
			refreshTableDataDetail();
		}
	}
	
	private ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);
	public ThreadPoolExecutor getThreadPoolExecutor() {
		return threadPoolExecutor;
	}
	public void setThreadPoolExecutor(ThreadPoolExecutor threadPoolExecutor) {
		this.threadPoolExecutor = threadPoolExecutor;
	}
	public void shutdownThreadPool(){
		if(!threadPoolExecutor.isTerminating()){
			threadPoolExecutor.shutdown();
		}
	}
	private void refreshTableDataByProgressBar(){
		final int[] seconds = new int[]{1};
		final String loading = "正在查询数据,请稍等......";
		final javax.swing.Timer timer = new javax.swing.Timer(1000, new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				setProcessBarValueString(loading + "  " + String.valueOf(seconds[0]) + "s");
				seconds[0] += 1;
			}
		});
		timer.start();
		Runnable task = new Runnable() {
			public void run() {
				setProcessBarValueString(loading + "  " + String.valueOf(seconds[0]) + "s");
				seconds[0] += 1;
				setButtonsEnabled(false);
				refreshTableDataDetail();
				setProcessBarValueString("");
				setButtonsEnabled(true);
				setButtonEnables();
				timer.stop();
			}
		};
//		Thread t = new Thread(task);
//		t.start();
		threadPoolExecutor.submit(task);
	}
	
	private void refreshTableDataDetail(){
		if(dataProvider != null){
			// 调用DataProvider查询数据
			synchronized (VCIJTableDataProvider.class) {
				T[] datas = dataProvider.getDatas(getPageIndex(), getPageSize());
				// 在查询数据的同时获取数据总数
				total = dataProvider.getTotal();
				refreshTableData(datas, false, true);
			}
		}
	}
	/**
	 * 
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-5
	 * @param datas
	 * @param fromManualData 是否来自手动刷新的标识
	 * @param isClear 是否清空已有数据的标识
	 */
	private synchronized void refreshTableData(final T[] datas, final boolean fromManualData, final boolean isClear){
		refreshTableDataBefore();
		//System.err.println("datas length:"+datas.length+Thread.currentThread().getName());	
		//System.out.println(Thread.currentThread().getName());
		try{
			int pageIndex = getPageIndex();
			int pageSize = getPageSize();
			int pageCount = getPageCount();
			if(datas != null){
				if(fromManualData){
					pageCount = 1;
					pageIndex = 1;
					total = datas.length;
				}else{
					if(total == 0){
						pageCount = 0;
						pageCount = 0;
					} else {
						pageCount = total / pageSize;
						if(total % pageSize != 0){
							pageCount += 1;
						}
						pageCount = pageCount == 0 ? 1 : pageCount;
					}
				}
				int baseLength = tableModel.getList().size();
				// 如果清空当前的数据，则重新设置CheckBox的总数
				if(isClear){					
					baseLength = 0;
					if (tableModel.getRowCount() > 0)
						tableModel.clear();
				} else{
					// 不清空时，总数当前的总数+datas.length
					total = datas.length + baseLength;
				}
				// 设置Table的CheckBox总数，此数不等于total，
				// total是全部数据的总数
				// CheckBox是Table显示时，需要的CheckBox的总数，有多少条数据显示，有需要多少个CheckBox
				tbChkManager.addCheckBoxs(baseLength + datas.length);								
					for(T dataObj : datas){
						tableModel.addRow(dataProvider.getNewRowNode(dataObj));
					}								
				tableModel.fireTableDataChanged();
				setPageIndexToTextField(pageIndex);
			}
			setPageIndex(pageIndex);
			setPageSize(pageSize);
			setPageCount(pageCount);
			java.awt.EventQueue.invokeLater(new Runnable(){
				public void run() {
					setButtonEnables();
				}
			});

		}catch(Exception e){
			e.printStackTrace();
			VCIJOptionPane.showError(parentComponent, "加载数据的内部过程中出现错误！");
		} finally{
			refreshTableDataAfter();
		}
	}
	
	private void refreshTableDataBefore(){
		setCursor(new Cursor(Cursor.WAIT_CURSOR));
	}
	
	private void refreshTableDataAfter(){
		setCursor(new Cursor(0));
	}
	
	private void setButtonEnables(){
		btnFirst.setEnabled((pageIndex != 1));// 只要当前不每一页就可用
		btnLast.setEnabled(pageIndex != pageCount);// 只要当前不是最后一页就可用
		btnPrev.setEnabled(pageIndex > 1);
		btnNext.setEnabled(pageIndex < pageCount);
		lblPageInfo.setText(MessageFormat.format(PAGE_INFO_FORMAT, new Object[]{total, pageCount, pageIndex}));
	}
	
	
	/******************** getter&setter ********************/
	public void setTableSorter(VCIJTableSorter sorter){
		this.sorter = sorter;
	}
	public VCIJTableSorter getTableSorter(){
		return sorter;
	}
	public int getHeaderHeight() {
		return headerHeight;
	}
	public void setHeaderHeight(int headerHeight) {
		this.headerHeight = headerHeight;
	}
	public int getRowHeight() {
		return rowHeight;
	}
	public void setRowHeight(int rowHeight) {
		this.rowHeight = rowHeight;
	}
	public boolean isShowCheckbox() {
		return showCheckbox;
	}
	public void setShowCheckbox(boolean showCheckbox) {
		showCheckbox = true;
		this.showCheckbox = showCheckbox;
	}
	public boolean isShowRowNumber() {
		return showRowNumber;
	}
	public void setShowRowNumber(boolean showRowNumber) {
		this.showRowNumber = showRowNumber;
	}
	public boolean isShowPaging() {
		return showPaging;
	}
	public void setShowPaging(boolean showPaging) {
		this.showPaging = showPaging;
	}
	public boolean isShowExport() {
		return showExport;
	}
	public void setShowExport(boolean showExport) {
		this.showExport = showExport;
	}
	public boolean isShowColumnSetting() {
		return showColumnSetting;
	}
	public void setShowColumnSetting(boolean showColumnSetting) {
		this.showColumnSetting = showColumnSetting;
	}
	public boolean isEnableSorter() {
		return enableSorter;
	}
	public void setEnableSorter(boolean enableSorter) {
		this.enableSorter = enableSorter;
	}
	/**
	 * 是否启用在表格单元格上单击时，自动选中CheckBox效果
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-9-19
	 * @return
	 */
	public boolean isEnableMouseClickEffect() {
		return enableMouseClickEffect;
	}
	/**
	 * 是否启用在表格单元格上单击时，自动选中CheckBox效果
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-9-19
	 * @param enableMouseClickEffect
	 */
	public void setEnableMouseClickEffect(boolean enableMouseClickEffect) {
		this.enableMouseClickEffect = enableMouseClickEffect;
	}
	/**
	 * 是否启用鼠标在单元格上移动时，当前行高亮显示的效果
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-9-19
	 * @return
	 */
	public boolean isEnableMouseMoveEffect() {
		return enableMouseMoveEffect;
	}
	/**
	 * 设置 是否启用鼠标在单元格上移动时，当前行高亮显示的效果
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-9-19
	 * @param enableMouseMoveEffect
	 */
	public void setEnableMouseMoveEffect(boolean enableMouseMoveEffect) {
		this.enableMouseMoveEffect = enableMouseMoveEffect;
	}
	/**
	 * 返回  是否启用 鼠标停留在数据行上时，行颜色自动高亮
	 * @return
	 */
	public boolean isEnableRowColorChangeInMouseHover() {
		return enableRowColorChangeInMouseHover;
	}
	/**
	 * 设置  是否启用 鼠标停留在数据行上时，行颜色自动高亮
	 * @param enableRowColorChangeInMouseHover
	 */
	public void setEnableRowColorChangeInMouseHover(
			boolean enableRowColorChangeInMouseHover) {
		this.enableRowColorChangeInMouseHover = enableRowColorChangeInMouseHover;
	}
	/**
	 * 返回 是否启用鼠标按下拖动（框选）时，执行将数据行选中
	 * @return
	 */
	public boolean isEnbleMouseDraggedChecked() {
		return enbleMouseDraggedChecked;
	}
	/**
	 * 设置 是否启用鼠标按下拖动（框选）时，执行将数据行选中
	 * @param enbleMouseDraggedChecked
	 */
	public void setEnbleMouseDraggedChecked(boolean enbleMouseDraggedChecked) {
		this.enbleMouseDraggedChecked = enbleMouseDraggedChecked;
	}
	public Integer getColumnDefaultWidth() {
		return columnDefaultWidth;
	}
	public void setColumnDefaultWidth(Integer columnDefaultWidth) {
		this.columnDefaultWidth = columnDefaultWidth;
	}
	public Integer getColumnDefaultWidthMax() {
		return columnDefaultWidthMax;
	}
	public void setColumnDefaultWidthMax(Integer columnDefaultWidthMax) {
		this.columnDefaultWidthMax = columnDefaultWidthMax;
	}
	public HashMap<Integer, Integer> getColumnWidthMaps() {
		return columnWidthMaps;
	}
	public void setColumnWidthMaps(HashMap<Integer, Integer> columnWidthMaps) {
		this.columnWidthMaps = columnWidthMaps;
	}
	public int getPageButtonFlowAlign() {
		return pageButtonFlowAlign;
	}
	public void setPageButtonFlowAlign(int pageButtonFlowAlign) {
		this.pageButtonFlowAlign = pageButtonFlowAlign;
	}
	public int getCustomButtonFlowAlign() {
		return customButtonFlowAlign;
	}
	public void setCustomButtonFlowAlign(int customButtonFlowAlign) {
		this.customButtonFlowAlign = customButtonFlowAlign;
	}
	public boolean isCustomButtonAutoScroll() {
		return customButtonAutoScroll;
	}
	public void setCustomButtonAutoScroll(boolean customButtonAutoScroll) {
		this.customButtonAutoScroll = customButtonAutoScroll;
	}
	public VCIJTableModel<T> getTableModel() {
		return tableModel;
	}
	public VCIJTable getTable() {
		return table;
	}
	public int getPageIndex() {
		return pageIndex;
	}
	public void setPageIndex(int pageIndex){
		this.pageIndex = pageIndex;
	}
	public int getPageSize() {
		return pageSize;
	}
	public void setPageSize(int pageSize){
		this.pageSize = pageSize;
	}
	public int getPageCount() {
		return pageCount;
	}
	public void setPageCount(int pageCount) {
		this.pageCount = pageCount;
	}
	public int[] getPageSizeList() {
		return pageSizeList;
	}
	public void setPageSizeList(int[] pageSizeList) {
		this.pageSizeList = pageSizeList;
	}
	public VCIJTableDataProvider<T> getDataProvider() {
		return dataProvider;
	}
	public void setDataProvider(VCIJTableDataProvider<T> dataProvider) {
		this.dataProvider = dataProvider;
	}
	public void setTableModel(VCIJTableModel<T> tableModel) {
		this.tableModel = tableModel;
	}
	public void setTable(VCIJTable table) {
		this.table = table;
	}
	@Deprecated
	public LinkedList<VCIJButton> getCustomButtons() {
		List<VCIJButton> res = getCustomButtonsList();
		if(res instanceof LinkedList){
			return (LinkedList<VCIJButton>)res;
		}
		LinkedList<VCIJButton> list = new LinkedList<VCIJButton>();
		for(VCIJButton btn : customButtons){
			list.add(btn);
		}
		return list;
	}
	public List<VCIJButton> getCustomButtonsList() {
		return customButtons;
	}
	@Deprecated
	public void setCustomButtons(LinkedList<VCIJButton> customButtons) {
		this.customButtons = customButtons;
	}
	public void setCustomButtons(List<VCIJButton> customButtons) {
		this.customButtons = customButtons;
	}
	public boolean isReorderingAllowed() {
		return reorderingAllowed;
	}
	public void setReorderingAllowed(boolean reorderingAllowed) {
		this.reorderingAllowed = reorderingAllowed;
	}
	public boolean isResizingAllowed() {
		return resizingAllowed;
	}
	public void setResizingAllowed(boolean resizingAllowed) {
		this.resizingAllowed = resizingAllowed;
	}
	public boolean isShowGrid() {
		return showGrid;
	}
	public void setShowGrid(boolean showGrid) {
		this.showGrid = showGrid;
	}
	public boolean isColumnSelectionAllowed() {
		return columnSelectionAllowed;
	}
	public void setColumnSelectionAllowed(boolean columnSelectionAllowed) {
		this.columnSelectionAllowed = columnSelectionAllowed;
	}
	public int getAutoResizeMode() {
		return autoResizeMode;
	}
	public void setAutoResizeMode(int autoResizeMode) {
		this.autoResizeMode = autoResizeMode;
	}
	public int getSelectionMode() {
		return selectionMode;
	}
	public void setSelectionMode(int selectionMode) {
		this.selectionMode = selectionMode;
	}
	public boolean isShowProgressBar() {
		return showProgressBar;
	}
	public void setShowProgressBar(boolean showProgressBar) {
		this.showProgressBar = showProgressBar;
	}
	/**
	 * 返回 是否是最后点击行才被选中，同时清空当前已经选中的其它数据模式是否生效
	 * @return
	 */
	public boolean isLastClickRowToChecked() {
		return lastClickRowToChecked;
	}
	/**
	 * 返回 是否是最后点击行才被选中，同时清空当前已经选中的其它数据模式是否生效
	 * @param lastClickRowToChecked 是否是最后点击行才被选中，同时清空当前已经选中的其它数据模式是否生效
	 */
	public void setLastClickRowToChecked(boolean lastClickRowToChecked) {
		this.lastClickRowToChecked = lastClickRowToChecked;
	}
	/********************  getter&setter end ********************/
	

	public List<Integer> getEdiableColumnList() {
		return ediableColumnList;
	}
	public void setEdiableColumnList(List<Integer> ediableColumnList) {
		this.ediableColumnList = ediableColumnList;
	}
	/**
	 * 返回是否可以进行可编辑状态
	 * @return
	 */
	public boolean isCellEditable() {
		return cellEditable;
	}
	/**
	 * 设置可以进入可编辑状态
	 * @param cellEditable 是否可以进入可编辑状态 true：是  false：否
	 */
	public void setCellEditable(boolean cellEditable) {
		this.cellEditable = cellEditable;
	}
	/********************  public service&interface ********************/
	/**
	 * 返回选择的对象的行索引
	 * @return
	 */
	public int[] getSelectedRowIndexs(){
		int[] res = null;
		if(this.tbChkManager == null) {
			res = this.table.getSelectedRows();
		}else{
			res = this.tbChkManager.getSelectedIndexs();
		}
		return res;
	}
	
	@SuppressWarnings("hiding")
	private <T> LinkedList<T> convertListToLinkedList(List<T> list){
		LinkedList<T> res = new LinkedList<T>();
		for (int i = 0; i < list.size(); i++) {
			res.add(list.get(i));
		}
		return res;
	}

	/**
	 * 返回选择的对象
	 * @return
	 */
	 @Deprecated
	public LinkedList<T> getSelectedRowObjects(){
		List<T> list = getSelectedRowObjectsList();
		if(list instanceof LinkedList){
			return (LinkedList<T>)list;
		}
		return convertListToLinkedList(list);
	}
	/**
	 * 返回选择的对象
	 * @return
	 */
	public List<T> getSelectedRowObjectsList(){
		int[] rows = this.getSelectedRowIndexs();
		if(this.isEnableSorter()){
			int[] rowss = this.sorter.getSelectTypeTableModelRows(rows);
			rows = rowss;
		}
		List<T> list = new LinkedList<T>();
		for(int row : rows){
			list.add(this.tableModel.getList().get(row).getObject());
		}
		return list;
	}
	
	/**
	 * 返回当前页的数据对象
	 * @return
	 */
	@Deprecated
	public LinkedList<T> getObjects(){
		List<T> list = getObjectsList();
		if(list instanceof LinkedList){
			return (LinkedList<T>)list;
		}
		return convertListToLinkedList(list);
	}
	/**
	 * 返回当前页的数据对象
	 * @return
	 */
	public List<T> getObjectsList(){
		LinkedList<T> list = new LinkedList<T>();
		for(int row = 0; row < this.tableModel.getList().size(); row++){
			list.add(this.tableModel.getList().get(row).getObject());
		}
		return list;
	}
	/**
	 * 返回全部页的数据对象
	 * @return
	 */
	@Deprecated
	public LinkedList<T> getObjectsAll(){
		List<T> list = getObjectsAllList();
		if(list instanceof LinkedList){
			return (LinkedList<T>)list;
		}
		return convertListToLinkedList(list);
	}
	/**
	 * 返回全部页的数据对象
	 * @return
	 */
	public List<T> getObjectsAllList(){
		List<T> list = getObjectsList();
		int pageIndex = getPageIndex();
		int pageSize = getPageSize();
		int pageCount = getPageCount();
		for(;pageIndex <= pageCount; pageIndex++){
			T[] datas = dataProvider.getDatas(pageIndex, pageSize);
			for(T data : datas){
				list.add(data);
			}
		}
		return list;
	}
	
	/**
	 * 返回指定页的数据
	 * @return
	 */
	@Deprecated
	public List<T> getObjectsByPageIndex(int pageIndex){
		List<T> list = getObjectsByPageIndexList(pageIndex);
		if(list instanceof LinkedList){
			return (LinkedList<T>)list;
		}
		return convertListToLinkedList(list);
	}
	/**
	 * 返回指定页的数据
	 * @return
	 */
	public List<T> getObjectsByPageIndexList(int pageIndex){
		List<T> list = new LinkedList<T>();
		T[] datas = dataProvider.getDatas(pageIndex, pageSize);
		for(T data : datas){
			list.add(data);
		}
		return list;
	}
	

	/**
	 * 返回全部页的TableNode对象
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-15
	 * @param pageIndex
	 * @return
	 */
	@Deprecated
	public LinkedList<VCIJTableNode<T>> getTableNodesInAllPage(){
		List<VCIJTableNode<T>> list = getTableNodesInAllPageList();
		if(list instanceof LinkedList){
			return (LinkedList<VCIJTableNode<T>>)list;
		}
		LinkedList<VCIJTableNode<T>> res = new LinkedList<VCIJTableNode<T>>();
		for (int i = 0; i < list.size(); i++) {
			res.add(list.get(i));
		}
		return res;
	}
	/**
	 * 返回全部页的TableNode对象
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-15
	 * @param pageIndex
	 * @return
	 */
	public List<VCIJTableNode<T>> getTableNodesInAllPageList(){
		List<VCIJTableNode<T>> list = new LinkedList<VCIJTableNode<T>>();
		for(int pageIndex = 1; pageIndex >= getPageCount(); pageIndex++){
			T[] datas = dataProvider.getDatas(pageIndex, pageSize);
			for(T data : datas){
				list.add(dataProvider.getNewRowNode(data));
			}
		}
		return list;
	}
	
	/**
	 * 返回指定页的TableNode对象
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-15
	 * @param pageIndex
	 * @return
	 */
	public LinkedList<VCIJTableNode<T>> getTableNodesByPageIndex(int pageIndex){
		List<VCIJTableNode<T>> list = getTableNodesByPageIndexList(pageIndex);
		if(list instanceof LinkedList){
			return (LinkedList<VCIJTableNode<T>>)list;
		}
		LinkedList<VCIJTableNode<T>> res = new LinkedList<VCIJTableNode<T>>();
		for (int i = 0; i < list.size(); i++) {
			res.add(list.get(i));
		}
		return res;
	}
	/**
	 * 返回指定页的TableNode对象
	 * <p>Description: </p>
	 * 
	 * @author xchao
	 * @time 2012-6-15
	 * @param pageIndex
	 * @return
	 */
	public List<VCIJTableNode<T>> getTableNodesByPageIndexList(int pageIndex){
		List<VCIJTableNode<T>> list = new LinkedList<VCIJTableNode<T>>();
		T[] datas = dataProvider.getDatas(pageIndex, pageSize);
		for(T data : datas){
			list.add(dataProvider.getNewRowNode(data));
		}
		return list;
	}
	
	/**
	 * 根据行索引返回对象
	 * @param index
	 * @return
	 */
	public T getSpecialObjectByRowIndex(int index){
		int[] rows = {index};
		if(this.isEnableSorter()){
			int[] rowss = this.sorter.getSelectTypeTableModelRows(rows);
			rows = rowss;
		}
		T node = this.tableModel.getList().get(rows[0]).getObject();
		return node;
	}

	/**
	 * 清空勾选择的CheckBox
	 */
	public void clearCheckboxSelected(){
		if(tbChkManager != null){
			tbChkManager.clearSelect();
		}
	}
	/**
	 * 添加勾选指定的行
	 * @param indexIndex 行索引
	 */
	public void addClickedRow(int rowIndex){
		if(tbChkManager != null){
			tbChkManager.clickedRow(rowIndex);
		}
	}
	/********************  public service&interface ********************/
	@SuppressWarnings("hiding")
	class SimpleMouseListener<T> implements MouseListener, MouseMotionListener{
		private VCIJTablePanel<T> tablePanel = null;
		private VCIJTable table = null;
		public SimpleMouseListener(VCIJTablePanel<T> tablePanel, VCIJTable table){
			this.tablePanel = tablePanel;
			this.table = table;
		}
		boolean draggedInvoke = false;
		public void mouseDragged(MouseEvent e) {
			if(!tablePanel.isEnableMouseMoveEffect()){
				return;
			}
			draggedInvoke = true;
		}
		public void mouseMoved(MouseEvent e) {
			if(!tablePanel.isEnableMouseMoveEffect()){
				return;
			}
			int rowIndex = table.rowAtPoint(e.getPoint());
			if(!tablePanel.isLastClickRowToChecked()){
				if(!tbChkManager.getSelectedIndexsSet().contains(rowIndex)){
					if(isEnableRowColorChangeInMouseHover()){
						processCurrentRowColor(rowIndex);
					}
				}
			} else{
				
			}
			updateUI();
		}
		public void mouseClicked(MouseEvent e) {
			int column = table.columnAtPoint(e.getPoint());
			int rowIndex = table.rowAtPoint(e.getPoint());
			// 单元格上不启用点击效果时，如果单击的是第一列，且第一列又是CheckBox列，则此时依然需要改变选择行的颜色
			if(!tablePanel.isEnableMouseClickEffect()){
				if(tablePanel.isShowCheckbox()){
					// 此时，非CheckBox列时，不作响应
					if(column != 0){
						return;
					}
				}
			}
			if(column == 0){
				tbChkManager.clickedRow(rowIndex);
			} else {
				if(!tablePanel.isLastClickRowToChecked()){
					tbChkManager.clickedRow(rowIndex);
				} else {
					if(!tbChkManager.getSelectedIndexsSet().contains(rowIndex)){
						tbChkManager.clearSelect();
					}
					tbChkManager.clickedRow(rowIndex);
				}
			}
		}
		public void mousePressed(MouseEvent e) {
		}
		public void mouseReleased(MouseEvent e) {
			if(!tablePanel.isEnableMouseMoveEffect()){
				return;
			}
			int columnIndexByPoint = table.columnAtPoint(e.getPoint());
			if(draggedInvoke){
				draggedInvoke = false;
				int[] rowIndexs = table.getSelectedRows();
				if(!tablePanel.isLastClickRowToChecked()){
					tbChkManager.clearSelect();
					for(int rowIndex : rowIndexs){
						tbChkManager.clickedRow(rowIndex);
					}
				} else {
					if(columnIndexByPoint != 0){
						int rowIndex = tablePanel.getTable().getSelectedRow();
						if(!tbChkManager.getSelectedIndexsSet().contains(rowIndex)){
							tbChkManager.clearSelect();
						}
						tbChkManager.clickedRow(rowIndex);
					}
				}
			}
			updateUI();
		}
		public void mouseEntered(MouseEvent e) {
		}
		public void mouseExited(MouseEvent e) {
		}
	}

	public void processCurrentRowColor(int rowIndex){
		Set<Integer> set = tbChkManager.getSelectedIndexsSet();
		if(!set.contains(rowIndex)){
			setRowBackgroundColor(rowIndex, VCISwingUtil.JTABLE_ROW_BACKGROUND_COLOR_HOVER);
		} else{
			setRowBackgroundColor(rowIndex, VCISwingUtil.JTABLE_ROW_BACKGROUND_COLOR_CHECKED);
		}
	}
	
	public Color getDefaultBackgroundColor(int rowIndex){
		Color color = (rowIndex % 2) == 0 ? VCISwingUtil.JTABLE_ROW_BACKGROUND_COLOR_EVEN : VCISwingUtil.JTABLE_ROW_BACKGROUND_COLOR_ODD;
		return color;
	}
	public void setRowBackgroundColor(final int changedRow, final Color color){
		int columnCount = table.getColumnCount();
		int startColumn = this.isShowCheckbox() ? 1 : 0;
		IndexColumnTableCellRender<T> tableCellRender = null;
		for(int i = startColumn; i < columnCount; i++){
			tableCellRender = new IndexColumnTableCellRender<T>(this) {
				/**
				 * 
				 */
				private static final long serialVersionUID = 6645602836163826027L;

				@Override
				public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
					Component compt = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
					if(row == changedRow){
						table.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
						setBackground(color);
					}
					return compt;
				}
			};
			tableCellRender.setTableCheckBoxManager(tbChkManager);
			table.getColumnModel().getColumn(i).setCellRenderer(tableCellRender);
		}
        updateUI();
	}
}