package usda.weru.mcrew;

import java.awt.*;
import javax.swing.*;
import java.util.*;

import java.awt.event.*;
import com.klg.jclass.table.*;
import com.klg.jclass.table.data.JCEditableVectorDataSource;
import org.apache.log4j.Logger;
import usda.weru.util.Caster;

/**
 * A basic implementation of the JDialog class.
 */
public class DisplayCalendar extends usda.weru.mcrew.gui.Calendar_n implements ComponentListener {

    private static final long serialVersionUID = 1L;

    private static final Logger LOGGER = Logger.getLogger(DisplayCalendar.class);

    /**
     *
     */
    public static final int OK_OPTION = 0;

    /**
     *
     */
    public static final int CANCEL_OPTION = 1;
    private int c_result = CANCEL_OPTION;

    /**
     *
     * @return
     */
    public int getResult() {
        return c_result;
    }
    private JCEditableVectorDataSource dataSource;
    /**
     * The table that holds the values for the various crop & operation data
     */
//	GregorianCalendar curDate;

    public JulianCalendar curDate = null;
    // These variables are used in UpdateCalendar() and need to be initialiized here
    int yr = 0;
    int daySet = 0;
    int desiredDay = 0;
    boolean flag = true;
    boolean longMonth = false;

    //this variable is used to determine which class is using the calander 
    //in order to determine which year range should be used
    String user;

    /**
     * The constructor for display calender object. It creates the tables and
     * the grids that holds the days of the month for each month forming the
     * actual yearly calendar.
     */
    public DisplayCalendar() {
        super(new JFrame());
        setTitle("Rotation Calendar");
        makeTable();

    }

    /**
     * Two argument contructor that helps build the calendar GUI which accepts
     * the value in date format in the table cell when clicked from this GUI
     * containing days of the month set under the weekday headers for all the
     * months in a year.
     *
     * @param top The frame that holds this GUI.
     * @param gc The gregorian(new) calendar object used to correlate between
     * julian(old) calendar dates & events with gregorian version of calendar
     * which is used as a reference calendar.
     */
    public DisplayCalendar(JFrame top, GregorianCalendar gc, String user) {

        super(top);
        this.user = user;
        curDate = (JulianCalendar) gc.clone();
        int mox = gc.get(Calendar.MONTH);
        int yrx = gc.get(Calendar.YEAR);
        JP_calendar.addComponentListener(this);
        setTitle("Rotation Calendar");
        makeTable();
        JCB_month.setSelectedIndex(mox);
        JTF_year.setText("" + yrx);
        lastYrStr = Integer.toString(yrx);
        updateCalendar(mox, "" + yrx);
        setModal(true);
//		setVisible(true);
        //}}
    }

    /**
     * This method controls the visibility of the calendar GUI.
     *
     * @param b Visible if true else hidden
     */
    @Override
    public void setVisible(boolean b) {
        c_result = CANCEL_OPTION;
        super.setVisible(b);
    }

    /**
     * This method displays the calendar GUI if run as a separate application in
     * which this becomes the starting point.
     *
     * @param args The parameter needed if anything needs to be initialised from
     * command prompt
     */
    static public void main(String[] args) {
        try {
            JulianCalendar jc = new JulianCalendar();
            DisplayCalendar dc = new DisplayCalendar(new JFrame("DisplayCalendar"), jc, "sim");
            dc.setModal(true);
            dc.setVisible(true);

        } catch (java.lang.Exception e) {
            LOGGER.error("Unexpected error.", e);
        }
    }

    @Override
    public void JLMonthDown_mouseClicked(java.awt.event.MouseEvent event) {
        int monidx = JCB_month.getSelectedIndex();
        if (monidx == 0) {
            monidx = 11;
            try {
                int yr = Integer.parseInt(JTF_year.getText().trim());
                yr--;

                if (this.user.equals("sim")) {

                } else {
                    yr = boundYear(yr);
                }
                JTF_year.setText("" + yr);
            } catch (NumberFormatException e) {
                LOGGER.warn("Unable to parse Integer: " + JTF_year.getText().trim(), e);
            }
        } else {
            monidx--;
        }
        JCB_month.setSelectedIndex(monidx);
        updateCalendar(monidx, JTF_year.getText().trim());
    }

    @Override
    public void JLMonthUp_mouseClicked(java.awt.event.MouseEvent event) {
        int monidx = JCB_month.getSelectedIndex();
        if (monidx == 11) {
            monidx = 0;
            try {
                int yr = Integer.parseInt(JTF_year.getText().trim());
                yr++;

                if (this.user.equals("sim")) {

                } else {
                    yr = boundYear(yr);
                }

                JTF_year.setText(" " + yr);
            } catch (NumberFormatException e) {
                LOGGER.warn("Unable to parse Integer: " + JTF_year.getText().trim(), e);
            }
        } else {
            monidx++;
        }

        JCB_month.setSelectedIndex(monidx);
        updateCalendar(monidx, JTF_year.getText().trim());
    }

    @Override
    public void JLYearDown_mouseClicked(java.awt.event.MouseEvent event) {
        try {
            int yr = Integer.parseInt(JTF_year.getText().trim());
            yr--;

            if (this.user.equals("sim")) {

            } else {
                yr = boundYear(yr);
            }
            JTF_year.setText("" + yr);
            int monidx = JCB_month.getSelectedIndex();
            updateCalendar(monidx, JTF_year.getText().trim());
        } catch (NumberFormatException e) {
            LOGGER.warn("Unable to parse Integer: " + JTF_year.getText().trim(), e);
        }
    }

    private int boundYear(int year) {
        if (year > 99) {
            return 99;
        } else if (year < 1) {
            return 1;
        } else {
            return year;
        }
    }

    String lastYrStr = "";

    @Override
    public void JTFYear_actionPerformed(java.awt.event.ActionEvent event) {
        //System.out.println("year entered...");
        try {
            int monidx = JCB_month.getSelectedIndex();
            int yr = Integer.parseInt(JTF_year.getText().trim());

            if (this.user.equals("sim")) {

            } else {
                yr = boundYear(yr);
            }
            String yrStr = Integer.toString(yr);
            updateCalendar(monidx, yrStr);
            lastYrStr = yrStr;
            if (!JTF_year.getText().equals(yrStr)) {
                JTF_year.setText(yrStr);
            }
        } catch (Exception e) {
            JTF_year.setText(lastYrStr);
        }
    }

    @Override
    public void JTFYear_focusLost(java.awt.event.FocusEvent event) {
        if (event.isTemporary()) {
            return;
        }
        JTFYear_actionPerformed(null);
    }

    @Override
    public void JLYearUp_mouseClicked(java.awt.event.MouseEvent event) {

        try {
            int yr = Integer.parseInt(JTF_year.getText().trim());
            yr++;
            if (this.user.equals("sim")) {

            } else {
                yr = boundYear(yr);
            }
            JTF_year.setText(" " + yr);
            int monidx = JCB_month.getSelectedIndex();
            updateCalendar(monidx, JTF_year.getText().trim());
        } catch (NumberFormatException e) {
            LOGGER.warn("Unable to parse Integer: " + JTF_year.getText().trim(), e);
        }

    }

    @Override
    public void JCB_month_itemStateChanged(java.awt.event.ItemEvent event) {
        if (event.getStateChange() != java.awt.event.ItemEvent.SELECTED) {
            return;
        }
        ////System.out.println("NC_miSC: " + event);
        int monidx = JCB_month.getSelectedIndex();
        //  //System.out.println("Month Selected:"+monidx);
        JCB_month.setSelectedIndex(monidx);
        updateCalendar(monidx, JTF_year.getText().trim());

    }

    private void setColumnWidths() {
        double width = jcTable.getWidth() / (double) 7;
        int fix = jcTable.getWidth() - (int) width * 7;
        for (int cdx = 0; cdx < 7; cdx++) {
            if (cdx == 0) {
                jcTable.setPixelWidth(cdx, (int) (width + fix));
            } else {
                jcTable.setPixelWidth(cdx, (int) width);
            }
        }
    }

    private void setRowHeights() {
        jcTable.setPixelHeight(-1, 25);

        double height = (jcTable.getHeight() - jcTable.getPixelHeight(-1)) / (double) 6;
        int fix = (jcTable.getHeight() - jcTable.getPixelHeight(-1)) - (int) height * 6;
        for (int cdx = 0; cdx < 6; cdx++) {
            if (cdx == 0) {
                jcTable.setPixelHeight(cdx, (int) (height + fix));
            } else {
                jcTable.setPixelHeight(cdx, (int) height);
            }
        }
    }
    //                       J   F  M   A    M    J    J   A   S    O
    private final int[] monArr = {0, // Jan
        31, // Feb
        59, // Mar
        90, // Apr
        120,// May
        151,// Jun
        181,// Jul
        212,// Aug
        243,// Sep
        273,// Oct
        304,// Nov
        334};// Dec

    private final int[] endDates = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

    private int calcJulDate(int mon, int day, int yr) {

        int rtn = yr * 365 + ((yr - 1) / 4);// - ((yr - 1900) / 100);
        rtn += monArr[mon];
        rtn += (((yr % 4) == 0) && mon > 1) ? 1 : 0;
        rtn += day - 1;
        //System.out.println(yr + " " + (mon+1) + " " + day);
        //return ((int)toJulian(new int[]{yr, mon, day}));
        return rtn;
    }

    public int JGREG = 15 + 31 * (10 + 12 * 1582);
    public double HALFSECOND = 0.5;

    public double toJulian(int[] ymd) {
        int year = ymd[0];
        int month = ymd[1]; // jan=1, feb=2,...
        int day = ymd[2];
        int julianYear = year;
        if (year < 0) {
            julianYear++;
        }
        int julianMonth = month;
        if (month > 2) {
            julianMonth++;
        } else {
            julianYear--;
            julianMonth += 13;
        }

        double julian = (java.lang.Math.floor(365.25 * julianYear)
                + java.lang.Math.floor(30.6001 * julianMonth) + day);

        if (day + 31 * (month + 12 * year) >= JGREG) {
            // change over to Gregorian calendar
            int ja = (int) (0.01 * julianYear);
            julian += 2 - ja + (0.25 * ja);
        }
        return java.lang.Math.floor(julian);
    }

    private String getCellContents(int rdx, int cdx) {
        Vector<Vector<String>> cells = Caster.<Vector<Vector<String>>>cast(dataSource.getCells());
        Vector<String> row = cells.get(rdx);
        return row.get(cdx);
    }

    private void setSelectedCell() {
        String temp = "" + curDate.get(GregorianCalendar.DAY_OF_MONTH);
        Vector<Vector<String>> cells = Caster.<Vector<Vector<String>>>cast(dataSource.getCells());
        outerLoop:
        for (int rdx = 0; rdx < 6; rdx++) {
            Vector<String> row = cells.get(rdx);
            for (int cdx = 0; cdx < 7; cdx++) {
                String cellStr = row.get(cdx);
                // //System.out.println("DC_sSC: " + rdx + " " + cdx + " |" + cellStr + "|" + temp + "|");
                if (temp.equals(cellStr)) {
                    jcTable.setSelection(rdx, cdx, rdx, cdx);
                    jcTable.setCurrentCell(new JCCellPosition(rdx, cdx));
                    break outerLoop;
                }
            }
        }
    }

    /**
     * * TODO **
     */
    private void updateCalendar(int monidx, String yrStr) {

        try {
            yr = Integer.parseInt(yrStr);
            if (this.user.equals("sim")) {

            } else {
                yr = boundYear(yr);
            }
        } catch (NumberFormatException e) {
            return;
        }
        // The Desired day is set to the first day already selected when the Calendar first comes up.
        if (flag == true) {
            flag = false;
            desiredDay = curDate.get(Calendar.DAY_OF_MONTH);
        }

        /**
         * If day 31 is selected in March month and we go to April, then it gets
         * changed to 30 Similarly if we change to Feb from a day > 28/29 we go
         * to 28/29 depending on if its a leap year.
         */
        daySet = curDate.get(Calendar.DAY_OF_MONTH);
        //System.out.println("Month is:"+monidx+" Day desired:"+desiredDay+" Day set:"+daySet);
        int leapYr = ((yr % 4) == 0) ? 1 : 0;
        if ((monidx == 3) || (monidx == 5) || (monidx == 8) || (monidx == 10)) {
            longMonth = false;
        } else {
            longMonth = true;
        }

        if (longMonth == true) {
            if (desiredDay == 31 || daySet != desiredDay) {
                curDate.set(Calendar.DAY_OF_MONTH, desiredDay);
            }
        } else if (desiredDay == 31) {
            curDate.set(Calendar.DAY_OF_MONTH, 30);
        } else if (daySet != desiredDay) {
            curDate.set(Calendar.DAY_OF_MONTH, desiredDay);
        }
        //The settings for the month February are set at the end, after bypassing all other conditions
        if (monidx == 1 && desiredDay > 28) {
            if (leapYr == 1) {
                curDate.set(Calendar.DAY_OF_MONTH, 29);
            } else {
                curDate.set(Calendar.DAY_OF_MONTH, 28);
            }
        }

        for (int rdx = 0; rdx < 6; rdx++) {
            for (int cdx = 0; cdx < 7; cdx++) {
                dataSource.setTableDataItem("", rdx, cdx);
            }
        }

        /* edit by: alexblum
        Java calendar instance used to construct the month required
        for the current table JCEditableVectorDataSource "dataSource" being viewed. 
        ...
        This appears to create the correct starting and end dates needed
        to build the and fill the object dataSource
        ...
        the java calendar object's built in methods are used to leverage
        the correct "week" index start day of each month
        ...
        monidx: 0 = jan, 1 = feb, 2 = march, ..., 11 = dec
         */
        Calendar cal = new GregorianCalendar(yr, monidx, 1);
        //System.out.println("monid: " +monidx);
        int numberOfDays = endDates[monidx];
        //check if we are in a leap year... +1 for feb! 
        if(isLeapYear(yr) && monidx == 1){
            numberOfDays++;
        }
        //System.out.println(numberOfDays);
        //int weeks = cal.getActualMaximum(Calendar.WEEK_OF_MONTH);

        int startDay = cal.get(Calendar.DAY_OF_WEEK);
        //System.out.println("startDate: " + startDay);
        int i = startDay - 1;
        for (int day = 1; day <= numberOfDays; day++) {
            //System.out.println(day);
            dataSource.setTableDataItem("" + day, i / 7, i % 7);
            i = i + 1;
        }

        //previous calendar rewrite code... 
        //does not work
        /*
        int sdow = calcJulDate(monidx, 1, yr) % 7;
        System.out.println(sdow);
        int edom = endDates[monidx];
        if (((yr % 4) == 0) && monidx == 1) {
            edom++;
        }
        for (int ddx = 0; ddx < edom; ddx++) {
            int rdx = (ddx + sdow) / 7;
            int cdx = (ddx + sdow) % 7;
            dataSource.setTableDataItem("" + (ddx + 1), rdx, cdx);
        }
         */
        setSelectedCell();
    }

    boolean isLeapYear(int year) {
        boolean isLeapYear;
        // divisible by 4
        isLeapYear = (year % 4 == 0);

        // divisible by 4 and not 100
        isLeapYear = isLeapYear && (year % 100 != 0);

        // divisible by 4 and not 100 unless divisible by 400
        isLeapYear = isLeapYear || (year % 400 == 0);

        return isLeapYear;
    }

    private void makeTable() {
        int cntCols = 7;
        int cntRows = 6;

        String[][] tableData = new String[cntRows][];

        for (int rdx = 0; rdx < cntRows; rdx++) {
            String[] rowStr = new String[cntCols];
            for (int cdx = 0; cdx < cntCols; cdx++) {
                rowStr[cdx] = "";
            }
            tableData[rdx] = rowStr;
        }

        JP_calendar.setLayout(new java.awt.GridLayout());
        // Create table object

        jcTable.addMouseListener(new MyMouseAdapter(this));

        // Create a vector data source to contain our data
        dataSource = new JCEditableVectorDataSource();

        jcTable.setColumnLabelDisplay(true);
        jcTable.setRowLabelDisplay(false);
        jcTable.setDataSource(dataSource);
        jcTable.setTrackCursor(false);

        dataSource.setNumRows(cntRows);
        dataSource.setNumColumns(cntCols);
        dataSource.setColumnLabels(new String[]{"Sun", "Mon", "Tue", "Wed",
            "Thu", "Fri", "Sat"});

        dataSource.setCells(tableData);

        jcTable.setDoubleBuffered(true);
        jcTable.setAutoScroll(JCTableEnum.AUTO_SCROLL_BOTH);
        jcTable.setAllowCellResize(JCTableEnum.RESIZE_NONE);

        JCCellStyle cs = new JCCellStyle(jcTable.getDefaultLabelStyle());
        cs.setBackground(new Color(255, 255, 210));
        cs.setForeground(Color.black);
        cs.setHorizontalAlignment(JCTableEnum.CENTER);
        cs.setVerticalAlignment(JCTableEnum.CENTER);
        cs.setClipHints(JCTableEnum.SHOW_NONE);
        cs.setCellBorderSides(JCTableEnum.BORDERSIDE_ALL);
        cs.setEditable(false);
        cs.setTraversable(true);

        jcTable.setCellStyle(JCTableEnum.ALLCELLS, JCTableEnum.ALLCELLS, cs);

        JCCellStyle headerStyleModel = new JCCellStyle(jcTable.getDefaultLabelStyle());
        headerStyleModel.setFont(new Font("Dialog", Font.BOLD, 11));
        headerStyleModel.setHorizontalAlignment(JCTableEnum.CENTER);
        headerStyleModel.setVerticalAlignment(JCTableEnum.CENTER);
        headerStyleModel.setCellBorderSides(JCTableEnum.BORDERSIDE_ALL);
        jcTable.setCellStyle(-1, JCTableEnum.ALLCELLS, headerStyleModel);
        jcTable.setVertSBDisplay(JCTableEnum.SBDISPLAY_NEVER);
        jcTable.setHorizSBDisplay(JCTableEnum.SBDISPLAY_NEVER);

        jcTable.addTraverseCellListener(new MyTraverseCellListener());

        setColumnWidths();
        setRowHeights();

        jcTable.setSelectionPolicy(JCTableEnum.SELECT_SINGLE);

        JP_calendar.add(jcTable);
        repaint();
    }

    class MyTraverseCellListener implements JCTraverseCellListener {

        private void setSelectedCell() {
            String temp = "" + curDate.get(GregorianCalendar.DAY_OF_MONTH);
            Vector<Vector<String>> cells = Caster.<Vector<Vector<String>>>cast(dataSource.getCells());
            outerLoop:
            for (int rdx = 0; rdx < 6; rdx++) {
                Vector<String> row = cells.get(rdx);
                for (int cdx = 0; cdx < 7; cdx++) {
                    String cellStr = row.get(cdx);
                    //System.out.println("DC_sSC: " + rdx + " " + cdx + " |" + cellStr + "|" + temp + "|");
                    if (temp.equals(cellStr)) {
                        jcTable.setSelection(rdx, cdx, rdx, cdx);
                        jcTable.setCurrentCell(new JCCellPosition(rdx, cdx));
                        break outerLoop;
                    }
                }
            }
        }

        @Override
        public void afterTraverseCell(JCTraverseCellEvent e) {
            if (e.isCancelled()) {
                //setSelectedCell();
                return;
            }
//			setSelectedCell();
        }

        @Override
        public void traverseCell(JCTraverseCellEvent e) {
            if (e.getNextRow() < 0) {
                e.setCancelled(true);
                return;
            }

            if (getCellContents(e.getNextRow(), e.getNextColumn()).trim().equals("")) {
                e.setCancelled(true);
                return;
            }
        }
    }

    @Override
    public void OK_actionPerformed(java.awt.event.ActionEvent event) {
        Collection<JCCellRange> scc = Caster.<Collection<JCCellRange>>cast(jcTable.getSelectedCells());
        JCCellRange jccr = (JCCellRange) scc.toArray()[0];

        try {
            curDate.set(Calendar.ERA, GregorianCalendar.AD);
            curDate.set(Calendar.MONTH, JCB_month.getSelectedIndex());
            curDate.set(Calendar.DAY_OF_MONTH, Integer.parseInt((String) dataSource.getTableDataItem(jccr.start_row, jccr.start_column)));
            curDate.set(Calendar.YEAR, Integer.parseInt(JTF_year.getText().trim()));
            c_result = OK_OPTION;
            dispose();
        } catch (NumberFormatException e) {
            JOptionPane.showMessageDialog(null, "Error parsing day or year",
                    "Error updating date", JOptionPane.ERROR_MESSAGE);
        }

    }

    @Override
    public void Cancel_actionPerformed(java.awt.event.ActionEvent event) {
        c_result = CANCEL_OPTION;
        curDate = null;
        dispose();
    }

    /**
     *
     * @param e
     */
    @Override
    public void componentResized(ComponentEvent e) {
        setColumnWidths();
        setRowHeights();
    }

    /**
     *
     * @param e
     */
    @Override
    public void componentMoved(ComponentEvent e) {
    }

    /**
     *
     * @param e
     */
    @Override
    public void componentShown(ComponentEvent e) {
    }

    /**
     *
     * @param e
     */
    @Override
    public void componentHidden(ComponentEvent e) {
    }

    /**
     * This is an inner class that recognizes the mouse click events from the
     * calendar GUI to get the selected dates in a date format to be assigned to
     * a specific cell in the date column in the main MCREW table.
     */
    public class MyMouseAdapter extends MouseAdapter {

        DisplayCalendar nc = null;
        int pressState = 0;

        MyMouseAdapter(DisplayCalendar nc) {
            this.nc = nc;
        }

        /**
         * The method that recognises the mouse events from the calendar GUI to
         * get the selected dates.
         *
         * @param ev The event generated from the mouse click.
         */
        @Override
        public void mouseClicked(MouseEvent ev) {
            //System.out.println("mouse clicked... resetting?");
            Collection<JCCellRange> scc = Caster.<Collection<JCCellRange>>cast(nc.jcTable.getSelectedCells());
            JCCellRange jccr = (JCCellRange) scc.toArray()[0];

            if (pressState == InputEvent.BUTTON1_DOWN_MASK && ev.getClickCount() > 1) //if(ev.getModifiers() == InputEvent.BUTTON1_MASK)
            {
                try {
                    String value = (String) nc.dataSource.getTableDataItem(jccr.start_row, jccr.start_column);
                    if (value == "") {
                        int monidx = JCB_month.getSelectedIndex();
                        updateCalendar(monidx, JTF_year.getText().trim());
                        //System.out.println("Double Click:Empty selection");
                        return;
                    }
                    curDate.set(Calendar.ERA, GregorianCalendar.AD);
                    curDate.set(Calendar.MONTH, JCB_month.getSelectedIndex());
                    curDate.set(Calendar.DAY_OF_MONTH, Integer.parseInt((String) nc.dataSource.getTableDataItem(jccr.start_row, jccr.start_column)));
                    desiredDay = Integer.parseInt((String) nc.dataSource.getTableDataItem(jccr.start_row, jccr.start_column));
                    //System.out.println("Date:"+curDate.get(Calendar.DAY_OF_MONTH)+"Gregorian:"+curDate.get(GregorianCalendar.DAY_OF_MONTH));
                    curDate.set(Calendar.YEAR, Integer.parseInt(JTF_year.getText().trim()));
                    OK_actionPerformed(null);
                    nc.dispose();
                } catch (NumberFormatException e) {
                    JOptionPane.showMessageDialog(null, "Error parsing day or year",
                            "Error updating date", JOptionPane.ERROR_MESSAGE);
                    curDate.set(Calendar.DAY_OF_MONTH, desiredDay);
                }
            } // If only the date is changed with a single mouse click,then this selection should be
            // preserved so that if we change the month after this, the date change will be preserved.
            else if (pressState == InputEvent.BUTTON1_DOWN_MASK && ev.getClickCount() == 1) {

                try {
                    String value = (String) nc.dataSource.getTableDataItem(jccr.start_row, jccr.start_column);
                    if (value == "") {
                        int monidx = JCB_month.getSelectedIndex();
                        updateCalendar(monidx, JTF_year.getText().trim());
                        //System.out.println("Single Click:Empty selection");
                        return;
                    }
                    curDate.set(Calendar.ERA, GregorianCalendar.AD);
                    curDate.set(Calendar.DAY_OF_MONTH, Integer.parseInt((String) nc.dataSource.getTableDataItem(jccr.start_row, jccr.start_column)));
                    desiredDay = Integer.parseInt(value);
                    jcTable.setCurrentCell(new JCCellPosition(jccr.start_row, jccr.start_column));
                } catch (NumberFormatException e) {
                    JOptionPane.showMessageDialog(null, "Error parsing day or year",
                            "Error updating date", JOptionPane.ERROR_MESSAGE);
                    curDate.set(Calendar.DAY_OF_MONTH, desiredDay);
                }

            } else {
                jcTable.setCurrentCell(new JCCellPosition(jccr.start_row, jccr.start_column));
                //System.out.println("Mouse clicked");
            }
            pressState = 0;
        }
        
        @Override
        public void mousePressed(MouseEvent me)
        {
            pressState = me.getModifiersEx();
        }
    }

}