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


import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.swing.DefaultCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
import javax.swing.event.CellEditorListener;
import javax.swing.event.ChangeEvent;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;

/**
 * 
 * <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
 */
public class VCIJTableCheckBoxManager implements IVCIJTableBaseCheckManager {

    private byte[] tableCheck = new byte[0];

    private IndexJCheckBox[] templetBox = new IndexJCheckBox[] {
            new IndexJCheckBox((String) null, false),
            new IndexJCheckBox((String) null, true) };

    private JTable table;

    private JCheckBox headerCheckBox;

    private int checkStata = -1;

    private Map<Integer, Object> selectedIndexMap = new HashMap<Integer, Object>();

    private int tableCheckedCount = 0;

    private boolean fireChanged = true;

    private int headerCheckBoxColumn = 0;

    private int checkBoxColumn = 0;

    private static final int DFAULT_MAX_WIDTH = 23;

    private static final int DFAULT_MIN_WIDTH = 23;

    private static final int DFAULT_PREFERRED_WIDTH = 23;

    private int maxWidth = DFAULT_MAX_WIDTH;

    private int minWidth = DFAULT_MIN_WIDTH;

    private int preferredWidth = DFAULT_PREFERRED_WIDTH;

    private IndexJCheckBox editorCheckBox = new IndexJCheckBox();

    private MouseListener nowMouseListen = null;

    private ActionListener actionChange = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            clickCheckBox(table.getEditingRow());
            checkedChanged2(table.getEditingRow());
        }
    };
    
    private void responseCheckListener(ActionEvent ae){
    	VCIJTableCheckListener[] checkListeners = tablePanel.getListeners(VCIJTableCheckListener.class);
        if(checkListeners != null){
        	for (int i = 0; i < checkListeners.length; i++) {
			}
        }
    }

    private void setTableModelFireTableDataChanged(){
    	table.getModel().addTableModelListener(new TableModelListener(){
			public void tableChanged(TableModelEvent e) {
				clearSelect();
			}
    	});
    }
    
    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#close()
	 */
    @Override
	public void close() {
        clear();
        table = null;
    }

    private void clear() {
        tableCheck = new byte[0]; //  @jve:decl-index=0:

        table = null;

        headerCheckBox = null;

        checkStata = -1;

        selectedIndexMap = new HashMap<Integer, Object>();

        tableCheckedCount = 0;

        fireChanged = true;

        //        addCheckBox = null;

        headerCheckBoxColumn = 0;

        checkBoxColumn = 0;

        removeSet();
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#setCheckBoxColumn(int)
	 */
    @Override
	public void setCheckBoxColumn(int col) {
        checkBoxColumn = col;
        if (table != null) {
            setColumnAttributes();
        }
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#setSelected(int[])
	 */
    @Override
	public void setSelected(int[] indexs) {
        for (int i = 0; i < indexs.length; i++) {
            tableCheck[indexs[i]] = 1;
            tableCheckedCount++;
        }
        updateStata();
        table.revalidate();
        table.repaint();
    }

    private void setColumnAttributes() {
        TableColumn tc = table.getColumnModel().getColumn(checkBoxColumn);
        tc.setPreferredWidth(preferredWidth);
        tc.setMaxWidth(maxWidth);
        tc.setMinWidth(minWidth);
        tc.setCellRenderer(getCheckBoxsCellRenderer());
        tc.setCellEditor(getCheckBoxsCellEditor(true));
    }

    private void addTableMouseListener() {
        nowMouseListen = new java.awt.event.MouseAdapter() {
            public void mouseClicked(java.awt.event.MouseEvent e) {
                 if (e.getButton() != java.awt.event.MouseEvent.BUTTON1)
                    return;
                 //************************************
                 if (e.getClickCount() == 2) {
                     int selectRow = VCIJTableCheckBoxManager.this.table
                     		.getSelectedRow();
                     if (selectRow > -1) {
                         int col = VCIJTableCheckBoxManager.this.table
                                 .columnAtPoint(e.getPoint());
                         if (col != -1) {  	
                        	 doubleclickedRow(selectRow);
                         }
                     }
                 } else if (e.getClickCount() == 1) {
                    int selectRow = VCIJTableCheckBoxManager.this.table
                    		.getSelectedRow();
                    if (selectRow > -1) {
                        int col = VCIJTableCheckBoxManager.this.table
                                .columnAtPoint(e.getPoint());
                        if (col != -1 && col == checkBoxColumn) {	
                        	// add by xchao 2012.08.20
                        	// 放开 clickedRow(selectRow) 将导致，点击列头的CheckBox时，需要单击两次才能实现选择中效果
                        	// 估计是与table添加了鼠标单击事件导致的，将其注释掉时，效果与预期一致，因此注释了此行
                            //clickedRow(selectRow);
                        	// add by xchao 2012.08.20
                        }
                    }
                }
     
            }

            /**
             * Invoked when the mouse exits a component.
             */
            public void mouseExited(MouseEvent e) {
            }
        };
        table.addMouseListener(nowMouseListen);
    }
    
    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#clickedRow(int)
	 */
    @Override
	public void clickedRow(int rowIndex){
    	clickCheckBox(rowIndex);
        checkedChanged(rowIndex);
        table.revalidate();
        table.repaint();
    }
  //*****************************  
    public void doubleclickedRow(int rowIndex){
    	doubleclickCheckBox(rowIndex);
        checkedChanged(rowIndex);
        table.revalidate();
        table.repaint();
    }
//******************************
    protected VCIJTablePanel<?> tablePanel = null;
    public VCIJTableCheckBoxManager(VCIJTablePanel<?> tablePanel, JTable table) {
    	this.tablePanel = tablePanel;
        this.table = table;
        addTableMouseListener();
        setColumnAttributes();
        setTableModelFireTableDataChanged();
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#removeSet()
	 */
    @Override
	public void removeSet() {
        if (table != null) {
            table.removeMouseListener(nowMouseListen);
            TableColumn tc = table.getColumnModel().getColumn(checkBoxColumn);
            tc.setCellRenderer(null);
            tc.setCellEditor(null);
        }
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getCheckBox(int)
	 */

	public JCheckBox getCheckBox(int i) {
        return templetBox[tableCheck[i]];
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#isSelected(int)
	 */
    @Override
	public boolean isSelected(int i) {
        return tableCheck[i] == 0 ? false : true;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#size()
	 */
    @Override
	public int size() {
        return tableCheck.length;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#clearCheckBoxList()
	 */
    @Override
	public void clearCheckBoxList() {
        createCheckBoxList();
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#createCheckBoxList()
	 */
    @Override
	public void createCheckBoxList() {
        tableCheck = new byte[0];
        selectedIndexMap = new HashMap<Integer, Object>();
        tableCheckedCount = 0;
        checkStata = -1;
        selectLogicCheckBoxChecked(true);
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#resetCheckBox(int)
	 */
    @Override
	public void resetCheckBox(int size) {
        createCheckBoxList();
        addCheckBoxs(size);
        checkStata--;
        selectLogicCheckBoxChecked(true);
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getTable()
	 */
    @Override
	public JTable getTable() {
        return this.table;
    }

    {
        initCheckBox();
    }

	/* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#initCheckBox()
	 */
	@Override
	public void initCheckBox() {
		for (int i = 0; i < templetBox.length; i++) {
			// templetBox[i].addChangeListener(checkChange);
			templetBox[i].setVisible(true);
		}
		editorCheckBox.addActionListener(actionChange);
		editorCheckBox.addMouseListener(new MouseAdapter() {
			public void mousePressed(MouseEvent e) {
				if (table.getEditingRow() > 0
						&& table.getEditingRow() < tableCheck.length) {
					editorCheckBox
							.setSelected(tableCheck[table.getEditingRow()] == 0 ? false
									: true);
				}
			}
		});
	}

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#addCheckBoxs(int)
	 */
    @Override
	public void addCheckBoxs(int size) {
        tableCheck = new byte[size];
        selectedIndexMap.clear();
        //        addTableMouseListener();
        //        setColumnAttributes();
    }

	/* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#setHeaderShowCheckbox(int)
	 */
	@Override
	public void setHeaderShowCheckbox(int col) {
		headerCheckBoxColumn = col;
		final JTableHeader jh = table.getTableHeader();
		TableColumnModel headerColumnMode = jh.getColumnModel();
		headerColumnMode.getColumn(0).setHeaderRenderer(
				new TableHeaderRenderer(getHeaderCheckBox()));
		jh.addMouseListener(new java.awt.event.MouseAdapter() {
			public void mouseClicked(java.awt.event.MouseEvent e) {
				int column;
				if ((column = jh.columnAtPoint(e.getPoint())) != -1) {
					TableColumn tc = table.getColumnModel().getColumn(
							checkBoxColumn);
					tc.getCellEditor().cancelCellEditing();
					if (column == headerCheckBoxColumn) {
						selectLogicCheckBoxChecked(true);
						jh.repaint();
					}
				}
			}
		});
	}

    private void selectLogicCheckBoxChecked(boolean seleteSaveTable) {
        checkStata++;
        if (checkStata == 3) {
            checkStata = 0;
        }
        switch (checkStata) {
        case SELECT_PART:
            getHeaderCheckBox().setSelected(true);
            getHeaderCheckBox().setEnabled(false);
            if (seleteSaveTable) {
                seletedCheckBoxCheck();
            }
            break;
        case SELECT_ALL:
            getHeaderCheckBox().setSelected(true);
            getHeaderCheckBox().setEnabled(true);
            if (seleteSaveTable) {
                selectAllTable(true);
            }
            break;
        case SELECT_NONE:
            getHeaderCheckBox().setSelected(false);
            getHeaderCheckBox().setEnabled(true);
            if (seleteSaveTable) {
                selectAllTable(false);
            }
            break;
        }
        table.getTableHeader().repaint();
    }

    private void checkedChanged(int index) {
        if (fireChanged && !table.isEditing()) {
            changeStata(index);
        }
    }

    private void checkedChanged2(int index) {
        if (table.isEditing()) {
            changeStata(index);
        }
    }
    
    private void changeStata(int index) {

        if (checkStata == SELECT_NONE) {
            selectedIndexMap = new HashMap<Integer, Object>();
        }

        if (checkStata == SELECT_ALL) {
            selectedIndexMap = new HashMap<Integer, Object>();
            for (int i = 0; i < tableCheck.length; i++) {
                selectedIndexMap.put(i, null);
            }
        }

        if (tableCheck[index] == 1) {
            tableCheckedCount++;
            selectedIndexMap.put(index, null);
        } else {
            tableCheckedCount--;
            selectedIndexMap.remove(index);
        }

        updateStata();
    }

    private void updateStata() {
        int changedStata = 0;
        if (tableCheckedCount != 0) {
            if (tableCheckedCount == tableCheck.length) {
                changedStata = SELECT_ALL;
            } else {
                changedStata = SELECT_PART;
            }
        } else {
            changedStata = SELECT_NONE;
        }

        if (changedStata != checkStata) {
            changedStata--;
            checkStata = changedStata;
            selectLogicCheckBoxChecked(false);
            table.getTableHeader().repaint();
        }
    }

    private void selectAllTable(boolean check) {
        fireChanged = false;
        byte nowCheckStata = (byte) (check ? 1 : 0);
        for (int i = 0; i < tableCheck.length; i++) {
            tableCheck[i] = nowCheckStata;
        }
        if (check) {
            tableCheckedCount = tableCheck.length;
        } else {
            tableCheckedCount = 0;
        }
        table.revalidate();
        table.repaint();
        fireChanged = true;
    }

    private JCheckBox getHeaderCheckBox() {
        if (headerCheckBox == null) {
            headerCheckBox = new JCheckBox();
            headerCheckBox.setBorderPainted(true);
            headerCheckBox.setBorder(UIManager.getBorder("TableHeader.cellBorder"));
            headerCheckBox.addActionListener(new ActionListener() {
				@Override
				public void actionPerformed(ActionEvent e) {
		            responseCheckListener(e);
				}
			});
        }
        return headerCheckBox;
    }

    private void clickCheckBox(int i) {
        if (tableCheck != null) {
            tableCheck[i] = (byte) (tableCheck[i] == 0 ? 1 : 0);
        }
    }
   //**************************** 
    private void doubleclickCheckBox(int i) {
        if (tableCheck != null) {
            tableCheck[i] = 0;
        }
    }
  //*******************************
    protected class TableHeaderRenderer implements TableCellRenderer {
        private JCheckBox renderCheckBoxs;

        public TableHeaderRenderer(JCheckBox tableCheck) {
            renderCheckBoxs = tableCheck;
        }

        public Component getTableCellRendererComponent(JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column) {
        	
        	renderCheckBoxs.setHorizontalAlignment(SwingConstants.CENTER);// 表头标签剧中
        	renderCheckBoxs.setBorderPainted(true);
        	renderCheckBoxs.setBorder(UIManager.getBorder("TableHeader.cellBorder"));        	

        	return renderCheckBoxs;
        }
    }

    private void seletedCheckBoxCheck() {
        fireChanged = false;
        tableCheckedCount = 0;

        Set<Integer> keys = selectedIndexMap.keySet();
        int checkIndex = 0;
        for (Iterator<Integer> keyItr = keys.iterator(); keyItr.hasNext();) {
            checkIndex = keyItr.next();
            if (tableCheck.length > checkIndex) {
                tableCheck[checkIndex] = 1;
                tableCheckedCount++;
            }
        }

        if (tableCheckedCount == 0) {
            selectLogicCheckBoxChecked(true);
        } else if (tableCheck.length > 0
                && tableCheckedCount == tableCheck.length) {
            selectLogicCheckBoxChecked(false);
        }
        table.revalidate();
        table.repaint();
        fireChanged = true;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#changeCheckBoxStata(int)
	 */
    @Override
	public void changeCheckBoxStata(int... stata) {
        for (int i = 0; i < stata.length; i++) {
            checkStata = stata[i] - 1;
            selectLogicCheckBoxChecked(true);
            if (checkStata == stata[i]) {
                break;
            }
        }
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#clearAndChangeCheckBoxStata(int)
	 */
    @Override
	public void clearAndChangeCheckBoxStata(int... stata) {
        clearSelect();
        changeCheckBoxStata(stata);
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#clearSelect()
	 */
    @Override
	public void clearSelect() {
        selectAllTable(false);
        getHeaderCheckBox().setSelected(false);
        getHeaderCheckBox().setEnabled(true);
        table.revalidate();
        table.repaint();
        updateStata();
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#setSelectedCheckIndexs(java.util.List)
	 */
    @Override
	public void setSelectedCheckIndexs(List<Integer> selectedInx) {
        selectedIndexMap = new HashMap<Integer, Object>();
        for (int i = 0; i < selectedInx.size(); i++) {
            selectedIndexMap.put(selectedInx.get(i), null);
        }
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getCheckBoxsCellEditor(boolean)
	 */
    @Override
	public TableCellEditor getCheckBoxsCellEditor(boolean addListener) {
        TableCellEditor tce = new CheckBoxsCellEditor();
        if (addListener)
            tce.addCellEditorListener(new CheckBoxCellEditorListener());
        return tce;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getCheckBoxsCellRenderer()
	 */
    @Override
	public TableCellRenderer getCheckBoxsCellRenderer() {
        return new CheckBoxsRenderer();
    }

    class CheckBoxsCellEditor extends DefaultCellEditor {

        /**
         * 
         */
        private static final long serialVersionUID = -1875319868682535006L;

        public CheckBoxsCellEditor() {
            super(new JTextField());
        }

        public Component getTableCellEditorComponent(JTable table,
                Object value, boolean isSelected, int row, int column) {
            return editorCheckBox;
        }
    }

    protected class CheckBoxsRenderer implements TableCellRenderer {

        public CheckBoxsRenderer() {
        }

        public Component getTableCellRendererComponent(JTable table,
                Object value, boolean isSelected, boolean hasFocus, int row,
                int column) {
            if (row < tableCheck.length) {
            	
            	JCheckBox comp = (JCheckBox) templetBox[tableCheck[row]];
            	//comp.setBackground(table.getBackground());
            	comp.setOpaque(false);
            	comp.setHorizontalAlignment(SwingConstants.CENTER);// 表头标签剧中
                return (Component) comp;//templetBox[tableCheck[row]];
            }
            return null;
        }
    }

    private class IndexJCheckBox extends JCheckBox {
        public IndexJCheckBox(String text, boolean selected) {
            super(text, selected);
        }

        public IndexJCheckBox() {
            super("", false);
        }

        /**
         * 
         */
        private static final long serialVersionUID = 1L;

    }
    

    
    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getSelectedIndexsSet()
	 */
    @Override
	public Set<Integer> getSelectedIndexsSet(){
    	return getSelectedIndexsSet(tablePanel.getTableModel());
    }
    
    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getSelectedIndexsSet(com.vci.base.ui.swing.components.table.VCIJTableModel)
	 */
    @Override
	@Deprecated
    public Set<Integer> getSelectedIndexsSet(VCIJTableModel<?> baseTableModel){
    	Set<Integer> set = new HashSet<Integer>();
    	switch (checkStata) {
        case SELECT_PART:
            set = selectedIndexMap.keySet();
            break;
        case SELECT_ALL:
            HashSet<Integer> allItem = new HashSet<Integer>();
            for (int i = 0; i < baseTableModel.getList().size(); i++) {
                allItem.add(i);
            }
            set = allItem;
            break;
        case SELECT_NONE:
            set = new HashSet<Integer>();
            break;
        }
    	return set;
    }
    
    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getSelectedIndexs()
	 */
    @Override
	public int[] getSelectedIndexs() {
    	return getSelectedIndexs(tablePanel.getTableModel());
    }
    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getSelectedIndexs(com.vci.base.ui.swing.components.table.VCIJTableModel)
	 */
    @Override
	@Deprecated
    public int[] getSelectedIndexs(VCIJTableModel<?> baseTableModel) {
    	Set<Integer> set = getSelectedIndexsSet(baseTableModel);
    	Integer[] ints = new Integer[set.size()];
        ints = set.toArray(ints);
        Arrays.sort(ints);
        int[] res = new int[ints.length];
        for (int i = 0; i < res.length; i++) {
			res[i] = ints[i].intValue();
		}
        return res;
    }

    class CheckBoxCellEditorListener implements CellEditorListener {
        int row;

        int col;

        public void editingStopped(ChangeEvent e) {
            table.revalidate();
            table.repaint();
            //            editorCheckBox
            //                    .setSelected(tableCheck[table.getEditingRow()] == 0 ? false
            //                            : true);
            //            editorCheckBox.setIndex(table.getEditingRow());
        }

        public void editingCanceled(ChangeEvent e) {
            table.revalidate();
            table.repaint();
        }
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#removeAllSelectedIndex()
	 */
    @Override
	public void removeAllSelectedIndex() {
        selectedIndexMap = new HashMap<Integer, Object>();
        tableCheckedCount = 0;
        updateStata();
    }

	/* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#removeAllSelectedIndexAndCheckBox(com.vci.base.ui.swing.components.table.VCIJTableModel)
	 */
	@Override
	@SuppressWarnings("rawtypes")
    public void removeAllSelectedIndexAndCheckBox(VCIJTableModel baseTableModel) {
        int[] indexs = getSelectedIndexs(baseTableModel);
        tableCheck = new byte[tableCheck.length - indexs.length];
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#removeAllSelectedIndexAndCheckBox(java.lang.Integer[])
	 */
    @Override
	public void removeAllSelectedIndexAndCheckBox(Integer[] indexs) {
        tableCheck = new byte[tableCheck.length - indexs.length];
        for (int i = indexs.length - 1; i >= 0; i--) {
            selectedIndexMap.remove(indexs[i]);
        }
        tableCheckedCount = selectedIndexMap.size();
        updateStata();
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getMaxWidth()
	 */
    @Override
	public int getMaxWidth() {
        return maxWidth;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#setMaxWidth(int)
	 */
    @Override
	public void setMaxWidth(int maxWidth) {
        this.maxWidth = maxWidth;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getMinWidth()
	 */
    @Override
	public int getMinWidth() {
        return minWidth;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#setMinWidth(int)
	 */
    @Override
	public void setMinWidth(int minWidth) {
        this.minWidth = minWidth;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#getPreferredWidth()
	 */
    @Override
	public int getPreferredWidth() {
        return preferredWidth;
    }

    /* (non-Javadoc)
	 * @see com.vci.base.ui.swing.components.table.IVCIJTableBaseCheckManager#setPreferredWidth(int)
	 */
    @Override
	public void setPreferredWidth(int preferredWidth) {
        this.preferredWidth = preferredWidth;
    }
}