package framePackage;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.util.Arrays;
import java.util.EventObject;

import javax.swing.DefaultCellEditor;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableCellRenderer;
import javax.swing.text.JTextComponent;

import basicPackage.VRoom;

import assistPackage.AdjustData;
import assistPackage.AdjustRoom;
import assistPackage.VGM;

public class AdjustTable extends JTable{
	private int _tabelID;
	private AdjustPanel _parent;
	private AdjustTableModel _model;//, _model2;
//	private AttributiveCellTableModel _ventilatorModel;
	private AdjustRoom[] _data;
	private String[] _columnNames;
	private JComboBox _cbVentilator;
	private int _rowLowestRatio;
	private static int NAME = 0, ORDER = 1, CLAIM = 1, DESIGN = 2, ADJUST = 2, METER = 3, RATIO = 4, 
				METER2 = 5, RATIO2 = 6, RATIO3 = 7;
	private static int PROCENT = 0, METER_CUBE = 1;

	public AdjustTable(AdjustPanel panel, int tabelID){
		super();
		_tabelID = tabelID;
		_parent = panel;
		if (tabelID == 1){
			_columnNames = new String[8];
			setTableHeader(null);
			_data = new AdjustRoom[1];
		}
		else if (tabelID == 2){
			_columnNames = new String[]{"Naam ruimte of ventiel",
					"<html>Geëist debiet<br />(m³/h)</html>",
					"<html>Ontwerpdebiet<br />(m³/h)</html>",
					"<html>Gemeten debieten<br />(m³/h)</html>", 
					"<html>verhouding<br />t.o.v. ontwerp</html>","","",""};
//			getTableHeader().setPreferredSize(new Dimension(getPreferredSize().width, 50));
			_data = new AdjustRoom[0];
		}
		else if (tabelID == 3){
			_columnNames = new String[8];
			setTableHeader(null);
			_data = new AdjustRoom[2];
		}
		else if (tabelID == 4){
			_columnNames = new String[]{"Naam ruimte of ventiel","Volgorde",
					"<html>Afsteldebiet<br />(m³/h)</html>", 
					"<html>Gemeten debieten<br />(m³/h)</html>", 
					"<html>verhouding<br />t.o.v. ontwerp</html>",
					"<html>Gemeten debieten<br />(m³/h)</html>",
					"<html>verhouding<br />t.o.v. geëist</html>",
					"<html>verhouding<br />t.o.v. ontwerp</html>"};
			_data = new AdjustRoom[0];
		}

		_model = new AdjustTableModel();
		setModel(_model);
		if (tabelID == 1){
			_cbVentilator = new JComboBox(new String[]{"%","m³/h"});
			getColumnModel().getColumn(RATIO).setCellEditor(new DefaultCellEditor(_cbVentilator));
		}
		
		DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
		renderer.setHorizontalAlignment(JLabel.RIGHT); 
		setGridColor(Color.BLACK);

		int[] width = {200, 130, 130, 140, 100, 140, 100, 100};
		for (int i = 0; i < getColumnCount(); i++) {
			this.getColumnModel().getColumn(i).setMaxWidth(width[i]);
			if ((_tabelID != 1 && _tabelID != 3) || i != DESIGN || i != RATIO)
				this.getColumnModel().getColumn(i).setCellRenderer(renderer);
		}

		ListSelectionListener listener = new TableSelectionListener();
		this.getSelectionModel().addListSelectionListener(listener);
		this.setCellSelectionEnabled(true);
		
	}
	public class AdjustTableModel extends AbstractTableModel{
		public AdjustTableModel() {
			super();
		}

		@Override
		public String getColumnName(int col) {
			return _columnNames[col];
		}

		@Override
		public int getColumnCount() {
			return _columnNames.length;
		}

		@Override
		public int getRowCount() {
			if (_data == null) return 0;
			else if (_tabelID == 2 || _tabelID == 4) return _data.length + 2;
			else return _data.length;
		}

		@Override
		public Object getValueAt(int row, int col) {
			AdjustData ad = Program.getVentilatie().getAdjustData(_parent.getFlowtype());
			if (_tabelID == 1){
				if (col == 1 && row == 0) return "Ventilatorinstelling";
				else if (col == 2 && row == 0) return "uw keuze  (1):";
				else if (col == METER) return VGM.getPrintFormat(
						ad.getVentilatorFlow(), VGM.SHOW_QUESTIONMARK_ROUND_UP)
						+ ad.getVentilatorMeterType();
				else if (col == RATIO) return ad.getVentilatorMeterType();
			}
			else if (_tabelID == 2){
				if ( row < _data.length) {
					if (col == NAME) return _data[row].toString();
					if (col == CLAIM) return _data[row].getClaimAsString();//VGM.getString(_data[row].getClaim(), 1);
					else if (col == DESIGN) return VGM.getPrintFormat(_data[row].getDesign(),VGM.ROUND_UP);
					else if (col == METER) return VGM.getPrintFormat(
							_data[row].getMetering(0), VGM.SHOW_QUESTIONMARK_ROUND_UP);
					else if (col == RATIO) {
						return VGM.getStringOrNone(_data[row].getRatio(0), 2);
					}
				}
				else if (row == _data.length + 1){
					if (col == NAME) return "Totaal";
					else if (col < METER2) return getTotal(col);
				}
			}
			else if (_tabelID == 3){
				if (col == ORDER && row == 0) return "Ventilatorinstelling";
				else if (col == ORDER && row == 1) return "Ventilatorafstelling";
				else if (col == ADJUST && row == 0) return "voorstel (2):";
				else if (col == ADJUST && row == 1) return "uw keuze (2):";
				else if (col == RATIO && row == 0) return "voorstel (3):";
				else if (col == RATIO && row == 1) return "uw keuze (3):";
				else if (col == METER && row == 0) return VGM.getPrintFormat(
						ad.getVentilatorCalcul1(), VGM.ROUND_UP)
						+ ad.getVentilatorMeterType();
				else if (col == METER && row == 1) return VGM.getPrintFormat(
						ad.getVentilatorMeter1(), VGM.SHOW_QUESTIONMARK_ROUND_UP)
						+ ad.getVentilatorMeterType();
				else if (col == METER2 && row == 0) return VGM.getPrintFormat(
						ad.getVentilatorCalcul2(), VGM.ROUND_UP)
						+ ad.getVentilatorMeterType();
				else if (col == METER2 && row == 1) return VGM.getPrintFormat(
						ad.getVentilatorMeter2(), VGM.SHOW_QUESTIONMARK_ROUND_UP)
						+ ad.getVentilatorMeterType();
			}
			else if (_tabelID == 4){
				if ( row < _data.length) {
					if (col == NAME) return _data[row].toString();
					else if (col == ORDER) return String.valueOf(_data[row].getOrdening());
					else if (col == ADJUST){
						if (row == 0) return "geen actie";
						else return VGM.getPrintFormat(_data[row].getCalculate(), VGM.ROUND);//getString(_data[row].getCalculate(), 2);
					}
					else if (col == METER)
						return VGM.getPrintFormat(_data[row].getMetering(1), VGM.SHOW_QUESTIONMARK_ROUND_UP);
					else if (col == METER2)
						return VGM.getPrintFormat(_data[row].getMetering(2), VGM.SHOW_QUESTIONMARK_ROUND_UP);
					else if (col == RATIO) return VGM.getStringOrNone(_data[row].getRatio(1), 2);
					else if (col == RATIO2) return VGM.getStringOrNone(_data[row].getRatio(2), 2);
					else if (col == RATIO3) return VGM.getStringOrNone(_data[row].getRatio(3), 2);
				}
				else if (row == _data.length + 1){
					if (col == NAME) return "Totaal";
					else if (col > ADJUST) return getTotal(col);
				}
			}
			return null;
		}		
		@Override
		public void setValueAt(Object value, int row, int col) {
			AdjustData adjustData = Program.getVentilatie().getAdjustData(_parent.getFlowtype());
			if (_tabelID == 1){
				if (col == METER) {
					adjustData.setVentilatorFlow(VGM.parseInt(String.valueOf(value)));
					if (adjustData.getVentilatorFlow() > 0 && _parent.getStep() == 1) 
						_parent.setButtonNextEnabled(true);
				}
				else if (col == RATIO){
					adjustData.setVentilatorMeterType(String.valueOf(value));
					fireTableRowsUpdated(row, row);
					_parent.fireTable3();//getTable(3).fireTableDataChanged();
				}
			}
			else if (_tabelID == 3){
				if (col == METER && row == 1) {
					adjustData.setVentilatorMeter1(VGM.parseFloat(value.toString()));
					if (adjustData.getVentilatorMeter1() > 0 && _parent.getStep() == 4) 
						_parent.setButtonNextEnabled(true);
				}
				else if (col == METER2 && row == 1) {
					adjustData.setVentilatorMeter2(VGM.parseFloat(value.toString()));
					if (adjustData.getVentilatorMeter2() > 0 && _parent.getStep() == 6) 
						_parent.setButtonNextEnabled(true);
				}
			}
			else if ( _tabelID == 2 && col == METER) {
				_data[row].setMetering(0, VGM.parseInt(String.valueOf(value)));
//				_data[row].setRatio(0);
				fireTableCellUpdated(_data.length + 1, METER);
				fireTableCellUpdated(row, RATIO);
				fireTableCellUpdated(_data.length + 1, RATIO);
				if (adjustData.checkMetering(0) && _parent.getStep() == 2) //checkMetering was eerst gedefinieerd in AdjustTable
					_parent.setButtonNextEnabled(true);
			}
			else if ( _tabelID == 4){
				if (col == METER){
					_data[row].setMetering(1, VGM.parseInt(String.valueOf(value)));
//					_data[row].setRatio(1);
					fireTableCellUpdated(_data.length + 1, METER);
					fireTableCellUpdated(row, RATIO);
					fireTableCellUpdated(_data.length + 1, METER);
					if (adjustData.checkMetering(1) && _parent.getStep() == 5) 
						_parent.setButtonNextEnabled(true);
				}
				else if (col == METER2){ 
					_data[row].setMetering(2, VGM.parseInt(String.valueOf(value)));
					_data[row].checkRatio(_data, true);
					fireTableDataChanged();
//					fireTableCellUpdated(_data.length + 1, METER2);
//					fireTableCellUpdated(row, RATIO2);
//					fireTableCellUpdated(row, RATIO3);
//					fireTableCellUpdated(_data.length + 1, RATIO2);
//					fireTableCellUpdated(_data.length + 1, RATIO2);
					if (row == _rowLowestRatio && _data[row].getMetering(2) > 0 &&  _parent.getStep() == 7)
						_parent.setButtonNextEnabled(true);
					if (adjustData.checkMetering(2) && _parent.getStep() == 8) 
						_parent.setButtonNextEnabled(true);
				}
			}
			Program.SAVE_OK++;
		}
		@Override
	    public boolean isCellEditable(int row, int col) { 
			if (isCellPriority(row, col, true)) return true;
	    	return false;
	    }
//	    public Class getColumnClass(int c) { 
////	    	return String.class;
//	    	return getValueAt(0, c).getClass(); 
//	    }
	}
	/**
	 * Tabel4: gaat na of de meting van de debieten gelijk of groter zijn dan het vereist debiet
	 * rekening houdend met de afwijking volgens de parameters
	 * @param calculate: true = eerst ratio berekenen en OK-bits setten
	 * @param all: true = alle metingen, false = enkel de meting met het laagste ratio
	 * @return aantal afwijkende waarden
	 */
	public int getBadRatio(boolean calculate, boolean all){
		int badRatio = 0;
		for (int i = 0; i < _data.length; i++) {
			if (all || i == _rowLowestRatio){
				if (calculate) _data[i].checkRatio(_data, false);
				if (!_data[i].isClaimOK() || !_data[i].isDesignOK()) badRatio++;
			}
		}
		return badRatio;
	}
	/**
	 * Tabel4: gaat na of de meting van de debieten gelijk of groter zijn dan het vereist debiet
	 * rekening houdend met de afwijking volgens de parameters
	 * @param all: true = alle metingen, false = enkel de meting met het laagste ratio
	 */
//	public void setRatio(boolean all){
//		for (int i = 0; i < _data.length; i++) {
//			if (all || i == _rowLowestRatio){
//				_data[i].checkRatio(_data);
//			}
//		}
//	}
	public AdjustRoom[] getData(){
		return _data;
	}
	public void setData2() {
		if (_tabelID == 2){
			_data = Program.getVentilatie().getAdjustData(_parent.getFlowtype()).getAdjustRooms();
			_model.fireTableDataChanged();
		}
	}
	public void setData4(AdjustRoom[] roomList) {
		if (_tabelID == 4){
			_data = new AdjustRoom[roomList.length];
			for (int i = 0; i < roomList.length; i++) {
				_data[i] = roomList[i];
			}
			Arrays.sort(_data);
			for (int i = 0; i < _data.length; i++) {
				_data[i].setOrdening(i + 1);
			}		
			_model.fireTableDataChanged();
		}
	}
	private float getRatioAverage(int index, AdjustRoom[] rooms){
		float average = 0.0f;
		int number = 0;
		for (AdjustRoom adjustRoom : rooms) {
			float ratio = adjustRoom.getRatio(index);
			if (ratio > 0) {
				average += ratio;
				number++;
			}
		}
		if (number == 0) return 0.0f;
		else return average / number;
	}
	private String getTotal(int col){
		if (_data.length > 0){
			if (col == CLAIM){
				float flow = 0;
				for (AdjustRoom room : _data) {
					flow += room.getClaim() + room.getClaimApprox();
				}
				return VGM.getString(flow, 1);
			}
			else if (col == DESIGN){
				int flow = 0;
				for (AdjustRoom room : _data) {
					flow += room.getDesign();
				}
				return String.valueOf(flow);
			}
			else if (col == METER){
				float flow = 0;
				for (AdjustRoom room : _data) {
					flow += room.getMetering(_tabelID/2 - 1);
				}
				return VGM.getString(flow, 0);
			}
			else if (col == RATIO) {
//				System.out.println("AdjustTable.getTotal() tabel="+_number+", gemiddelde="+getRatioAverage(_number/2 - 1, _data));
				return VGM.getStringOrNone(getRatioAverage(_tabelID/2 - 1, _data), 2);
			}
			else if (col == METER2){
				float flow = 0;
				for (AdjustRoom room : _data) {
					flow += room.getMetering(2);
				}
				return VGM.getString(flow, 0);
			}
			else if (col == RATIO2) return VGM.getStringOrNone(getRatioAverage(2, _data), 2);
			else if (col == RATIO3) return VGM.getStringOrNone(getRatioAverage(3, _data), 2);
		}
		return "";
	}
	/**
	 * Berekening van het afsteldebiet (stap 2)
	 */
	public void calculateAdjustmentFlow(){
		LogPanel.title("Afstelling");
		float total = 0.0f;
		float[] temp = new float[_data.length];
		for (int i = 0; i < _data.length; i++) {
			temp[i] = _data[i].getMetering(0);
			total += _data[i].getMetering(0);
		}
		_data[0].setCalculate(temp[0]);
		
		for (int i = 1; i < _data.length; i++) {
			float R17 = _data[0].getDesign();
			float S17 = _data[i].getDesign();
			float T17 = temp[0];
			float U17 = temp[i];
			float x = (U17*R17-T17*S17)/(R17+(T17*S17/(total-U17)));					  
			LogPanel.line(_data[i].toString() + ": x=" + VGM.getString(x, 3) + ";D1*=" + VGM.getString(R17,3) +
					 ";D*=" + VGM.getString(S17,3) + ";D1=" + VGM.getString(T17,3) + ";D=" + VGM.getString(U17,3));
			temp[i] -= x;
			for (int j = 0; j < _data.length; j++) {
				if (j != i) temp[j] += temp[j] * x / (total - U17);//J18+x*J18/(total-$U19)
				LogPanel.start(_data[j].getName() + VGM.getString(_data[j].getCalculate(), 2));
			}
			_data[i].setCalculate(temp[i]);
			LogPanel.end("");
			LogPanel.line("");
		}
	}
	/**
	 * Berekening van voorstel tot ventilatorafstelling (stap 3)
	 * @return true als ventilatordebiet groter is dan 0
	 */
	public boolean calculateVentilator1(){
		AdjustData adjustData = Program.getVentilatie().getAdjustData(_parent.getFlowtype());
		if (adjustData.getVentilatorFlow() == 0.0f) return false;
		adjustData.setVentilatorCalcul1(adjustData.getVentilatorFlow() / getRatioAverage(0, adjustData.getAdjustRooms()));
		_model.fireTableDataChanged();
		return true;
	}
	/**
	 * Berekening van voorstel tot ventilatorafstelling (stap 3)
	 * Bepaling van het ventiel me de laagste verhouding meting/ontwerpdebiet
	 * @return true als ventilatordebiet groter is dan 0
	 */
	public boolean calculateVentilator2(){
		float min = 200.0f;
		_rowLowestRatio = -1;
		AdjustData adjustData = Program.getVentilatie().getAdjustData(_parent.getFlowtype());
		for (int i = 0; i < _data.length; i++) {
//			AdjustRoom room = adjustData.getAdjustRooms()[i];
			if (_data[i].getRatio(1) > 0 && _data[i].getRatio(1) < min) {
				min = _data[i].getRatio(1);
				_rowLowestRatio = i;
			}
		}
		if (adjustData.getVentilatorMeter1() == 0.0f) return false;
		adjustData.setVentilatorCalcul2(adjustData.getVentilatorMeter1() / min);
		_model.fireTableDataChanged();
		return true;
	}
//	public int getRowLowestRatio(){
//		return _rowLowestRatio;
//	}
	public boolean isRowLowestRatioMetered(){
		if (_rowLowestRatio >= 0 && _data[_rowLowestRatio].getMetering(2) > 0) return true;
		return false;
	}
	public void fireTableDataChanged(){
		_model.fireTableDataChanged();
	}
	/**
     * @Override: deze methode overschrijft de prepareRenderer methode van JTable 
     * De pare rijen worden blauw gekleurd, de selectie groen
     */
    public Component prepareRenderer(TableCellRenderer renderer, int row, int col) {
    	JComponent c = (JComponent) super.prepareRenderer(renderer, row, col);
    	if (row < _data.length){
       		if (isCellUserDefined(row, col) && !isCellSelected(row, col)){
    			c.setBackground(Program.preferences.editableCellColor);
    		}
       		else c.setBackground(Program.preferences.backgroundColor);
      		if (isCellPriority(row, col, false)) c.setBackground(Program.preferences.priorityCellColor);
//      			c.setBorder(BorderFactory.createLineBorder(Program.preferences.cellBorderColor));
//       		if (isCellBadRatio(row, col) && !isCellSelected(row, col))
//    			c.setBackground(Program.preferences.badRatioCellColor);
     		if (isRowSelected(row))  c.setBackground(Program.preferences.rowSelectionColor);
    		if (isCellSelected(row, col) && isCellEditable(row, col)) 
    			c.setBackground(Program.preferences.cellSelectionColor);
       		if (isCellBadRatio(row, col)){
       			c.setForeground(Program.preferences.badRatioCellColor);
    			c.setFont(c.getFont().deriveFont(Font.BOLD));
       		}
       		else {
       			c.setForeground(Color.BLACK);
    			c.setFont(c.getFont().deriveFont(Font.PLAIN));
       		}
    	}
    	if (row == _data.length) c.setBackground(Color.GRAY);  
    	else if (row == _data.length + 1) {
			c.setFont(c.getFont().deriveFont(Font.BOLD));
			c.setBackground(new Color(210, 210, 210)); 
   			c.setForeground(Color.BLACK);
		}
     	return c;
    }
    /**
     * Gaat na of de cel in de huidige stap moet ingevuld worden
     * @param row
     * @param col
     * @param editable: extra cellen die niet prioritair maar wel editeerbaar zijn
     * @return
     */
	private boolean isCellPriority(int row, int col, boolean editable) {
		if ((_parent.getStep() == 1 || _parent.getStep() < 4 && editable) && _tabelID == 1 && 
				(col == METER || col == RATIO)) {
			return true;
		}
		else if (_parent.getStep() == 2){
			if (_tabelID == 2 && col == METER && row < _data.length) return true;
		}
		else if (_parent.getStep() == 3 && !editable){
			if (_tabelID == 4 && col == ADJUST && row > 0 && row < _data.length) return true;
		}
		else if (_parent.getStep() == 4){
			if (_tabelID == 3 && col == METER && row == 1) return true;
		}
		else if (_parent.getStep() == 5){
			if (_tabelID == 4 && col == METER && row < _data.length) return true;
		}
		else if ((_parent.getStep() == 6 || (_parent.getStep() == 7 && editable)) && 
				_tabelID == 3 && col == METER2 && row == 1) {
			return true;
		}
		else if (_parent.getStep() == 7){
			if (_tabelID == 4 && col == METER2 && row == _rowLowestRatio) return true;
		}
		else if (_parent.getStep() == 8){
			if (_tabelID == 4 && col == METER2 && row != _rowLowestRatio) return true;
		}
		return false;
	}
	/**
	 * Is dit een cel die door de gebruiker moet ingevuld worden
	 * @param row
	 * @param col
	 * @return
	 */
	private boolean isCellUserDefined(int row, int col){
		if (_tabelID == 1 && (col == METER || col == RATIO)) return true;
		else if (_tabelID == 3 && row == 1 && (col == METER || col == METER2)) return true;
		else if (_tabelID == 2 && row < _data.length && col == METER) return true;
		else if (_tabelID == 4 && row < _data.length && (col == METER || col == METER2)) return true;
    	return false;
	}
	/**
	 * Is dit een cel met een slechte ratio in tabel4 bij de laatste meting
	 * @param row
	 * @param col
	 * @return
	 */
	private boolean isCellBadRatio(int row, int col){
		if (_tabelID == 4){
			if ((col == METER2 || col == RATIO2) && !_data[row].isClaimOK()) return true;
			if ((col == METER2 || col == RATIO3) && !_data[row].isDesignOK()) return true;
		}
		return false;
	}
	/**
	 * Listener naar de selecties in de tabel
	 * Naargelang welke stap reeds genomen is worden de knoppen
	 * aan of uit geschakeld
	 */
	private class TableSelectionListener implements ListSelectionListener {
		public void valueChanged(ListSelectionEvent e) {
			_parent.changeSelectedTabel(_tabelID);
			changeSelection(getSelectedRow(), getSelectedColumn(), false, false);
		}
	}
	@Override
	/**
	 * Door deze methode te overschrijven, kan bekomen worden dat in de 
	 * tekstvakken van de tabel tekst geselecteerd en dus overschreven wordt als er getypt wordt,
	 * op F2 wordt geduwd of als op de cel geklikt wordt
	 */
	public boolean editCellAt(int row, int column, EventObject e)
	{
		boolean result = super.editCellAt(row, column, e);

		final Component editor = getEditorComponent();

		if (editor != null	&& editor instanceof JTextComponent){
//			if (e == null)	((JTextComponent)editor).selectAll();
			//  Typing in the cell was used to activate the editor
			if (e instanceof KeyEvent) ((JTextComponent)editor).selectAll();
//				 &&	((KeyEvent)e).getKeyCode() != KeyEvent.VK_ENTER)	((JTextComponent)editor).selectAll();
			//  F2 was used to activate the editor
			if (e instanceof ActionEvent) ((JTextComponent)editor).selectAll();
			//  A mouse click was used to activate the editor.
			//  Generally this is a double click and the second mouse click is
			//  passed to the editor which would remove the text selection unless
			//  we use the invokeLater()
			if (e instanceof MouseEvent){
				SwingUtilities.invokeLater(new Runnable(){
					public void run() {
						((JTextComponent)editor).selectAll();
					}
				});
			}
		}
		return result;
	}
	public HeaderRenderer getHeaderRenderer(){
		return new HeaderRenderer();
	}
	public class HeaderRenderer extends DefaultTableCellRenderer {
		  public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
		      boolean hasFocus, int row, int column) {
		    if (table != null) {
		      JTableHeader header = table.getTableHeader();
		      if (header != null) {
		        setForeground(header.getForeground());
		        setBackground(header.getBackground());
		        setFont(header.getFont());
		        setText(value.toString());
		        setPreferredSize(new Dimension(1000, 30));
		      }
		    }
		    setBorder(UIManager.getBorder("TableHeader.cellBorder"));
		    setHorizontalAlignment(JLabel.CENTER);
		    return this;
		  }
		}
}
