package fi.jyu.mit.fxgui;


import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

import javax.swing.SwingConstants;

import javafx.application.Platform;
import javafx.beans.property.ListProperty;
import javafx.beans.property.SimpleListProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener;
import javafx.collections.ObservableList;
import javafx.fxml.FXML;
import javafx.geometry.Pos;
import javafx.scene.control.TableCell;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableRow;
import javafx.scene.control.TableView;
import javafx.scene.control.TextField;
import javafx.scene.input.KeyCode;

/**
 * StringGrid joka näyttää merkkijonotaulukon sisällön.
 * Taulukkoon voidaan jokaista riviä kohti tallentaa myös jokin olio.
 * 
 *  grid.add(har,rivi);  // rivillä sarakkeiden merkkijonot
 * 
 * Kullekin solulle voidaan antaa oma css-tyyli.  Ongelma: mikäli
 * ei kuunnella hiiren klikkausta otsikossa ja tehdä refresh, niin tämä
 * menee sekaisin jos rivit lajitellaan (jos eri riveillä eri css).
 * TYPE saa olla ?, mikäli tallennettavia olioita ei käytetä mihinkään
 * 
 * Soluihin pääsee käsiksi alkuperäisen (lajittelemattoman) taulukon
 * rivi- ja sarakeindekseillä.  Ellei erikseen mainita, parametreissa
 * olevat row- ja col-indeksit ovat nimenomaan alkueräisiä indeksejä.
 * 
 * Dataa voidaan lisätä myös ilman merkkijonoja.  
 * 
 *  grid.add(jasenet);
 * 
 * Tällöin on vähintään kerrottavat miten merkkijonot saadaan tietylle riville ja
 * sarekkeelle, esim tyyliin:
 * 
 *  grid.setOnCellString( (g, jasen, defValue, r, c) -> jasen.anna(c+eka) );
 *     
 * Mikäli halutaan lajitella sarakkeita muuta kuin merkkijonojärjestyksessä,
 * on kerrottava lajittelumerkkijono tyyliin:
 *     
 *  grid.setOnCellValue( (g, jasen, defValue, r, c) -> jasen.getAvain(c+eka) );
 *
 * Katso myös: <a href="https://tim.jyu.fi/view/kurssit/tie/ohj2/tyokalut/JavaFX/fxgui/StringGrid">StringGrid TIMissä</a>
 * 
 * @param <TYPE> minkä tyyppisiä tietoja liitetään riveihin
 *
 * @author vesal
 * @version 29.12.2015
 * @version 25.3.2015/vl - TYPE mukaan ja lisää ominaisuuksia
 */
public class StringGrid<TYPE> extends TableView<StringGrid.GridRowItem<TYPE>> {
    
    /**
     * Alkio yhdelle riville.
     * Pidetään yllä itse olioita, listaa merkkijoista,
     * alkuperäisestä rivinumerosta ja solu css:stä.
     * @param <TYPE> mikä tieto tallennetaan riviin
     */
    @SuppressWarnings("javadoc")
    public static class GridRowItem<TYPE> {
        private ObservableList<String> rowSts;
        private TYPE item;
        private int rowNr;     
        private HashMap<Integer, String> styleClasses;    
        
        /**
         * @param row mikä teksti tallennetaan
         * @param item mikä alkio tähämn kohti
         * @param rowNr mikä on alkuperäinen rivinumero
         */
        public GridRowItem(String[] row, TYPE item, int rowNr) {
            this.rowSts = FXCollections.observableArrayList();
            this.setRow(row);
            this.setItem(item);
            this.setRowNr(rowNr);
        }
        
        public void setItem(TYPE item) {
            this.item = item;
        }
        
        /**
         * @return kohdalla oleva alkio
         */
        public TYPE getItem() {
            return item;
        }

        public int getRowNr() {
            return rowNr;
        }

        public void setRowNr(int rowNr) {
            this.rowNr = rowNr;
        }

        public ObservableList<String> getRow() {
            return rowSts;
        }

        public void setRow(String[] row) {
            this.rowSts.setAll(row);
        }

        public String getCellClass(int col) {
            if ( styleClasses == null ) return null;
            return styleClasses.get(col);
        }

        public void setCellClass(String cellClass, int col) {
            if ( styleClasses == null ) styleClasses = new HashMap<>();
            styleClasses.put(col, cellClass);
        }
        
        
        public String get(int col) {
            if ( col < 0 || col >= rowSts.size() ) return "";
            return rowSts.get(col);
        }
        
        public void set(int col, String s) {
            if ( col <0 || col >= rowSts.size() ) return;
            rowSts.set(col,s);
        }

    }

    
    /**
     * Rajapinta solun muokkaukselle
     * @param <TYPE> minkätyylisiä
     */
    public interface OnGridCell<TYPE> {
        /**
         * Metodi jota kutsutaan kun tarvitaan solun sisältöä
         * @param grid taulukko jota käytetään
         * @param item mikä alkio liitetty tähän
         * @param defValue solulle ehdotettu arvo
         * @param row taulukon rivi johon liittyy
         * @param column taulukon sarake johon liittyy
         * @return solulle haluttu arvo, null: käytetään oletusta
         */
        String onGetCell(StringGrid<TYPE> grid, TYPE item, String defValue, int row, int column);
    }
    
    
    /**
     * Rajapinta solun editoinnille
     * @param <TYPE> minkätyylisiä
     */
    public interface OnGridLiveEdit<TYPE> {
        /**
         * Metodi jota kutsutaan kun solua muokataan
         * @param grid taulukko jota muokattiin
         * @param item mikä alkio liitetty tähän
         * @param newValue solulle ehdotettu uusi arvo
         * @param row taulukon rivi jota muokattiin
         * @param column taulukon sarake jota mmuokattiin
         * @param textField tekstikenttä jota muokataan
         * @return solulle haluttu arvo, null: ei muutosta
         */
        String onEdit(StringGrid<TYPE> grid, TYPE item, String newValue, int row, int column, TextField textField);
    }
    
    
    private ListProperty<GridRowItem<TYPE>> rivitProp = new SimpleListProperty<>();
    private ObservableList<GridRowItem<TYPE>> tableRows = FXCollections.observableArrayList();
    private StringProperty rivitJono = new SimpleStringProperty();
    private String emptyStyleClass = null;
    private HashMap<Integer,Pos> alignments = new HashMap<>(); 
    
    /** Käsittelijä muokkauksille */
    protected OnGridCell<TYPE> onGridEdit;
    /** Käsittelijä reaaliaikaisille muokkauksille */
    protected OnGridLiveEdit<TYPE> onGridLiveEdit;
    /** Käsittelijä lajitteluarvolle */
    protected OnGridCell<TYPE> onCellValue;
    /** Käsittelijä solun merkkijonolle */
    protected OnGridCell<TYPE> onCellString;
    
    
    /**
     * Alustetaan taulukko
     */
    public StringGrid() {
        setItems(tableRows);
    }
    
    
    /**
     * @return mitä kutsutaan kun halutaan lajitteluarvo
     */
    public OnGridCell<TYPE> getOnCellValue() {
        return onCellValue;
    }

    
    /**
     *  @param onCellValue mitä kutsutaan kun halutaan näytettävä arvo
     */
    public void setOnCellValue(OnGridCell<TYPE> onCellValue) {
        this.onCellValue = onCellValue;
    }


    /**
     * @return mitä kutsutaan kun halutaan solun sisältöä merkkijonona
     */
    public OnGridCell<TYPE> getOnCellString() {
        return onCellString;
    }

    
    /**
     *  @param onCellString mitä kutsutaan kun halutaan lajitteluarvo
     */
    public void setOnCellString(OnGridCell<TYPE> onCellString) {
        this.onCellString = onCellString;
    }


    /**
     * @return muokkauksen käsittelijä
     */
    public OnGridCell<TYPE> getOnGridEdit() {
        return onGridEdit;
    }


    /**
     * @param onGridEdit uusi käsittelijä muokkaukselle
     */
    public void setOnGridEdit(OnGridCell<TYPE> onGridEdit) {
        this.onGridEdit = onGridEdit;
    }


    /**
     * @return muokkauksen käsittelijä
     */
    public OnGridLiveEdit<TYPE> getOnGridLiveEdit() {
        return onGridLiveEdit;
    }


    /**
     * @param onGridLiveEdit uusi käsittelijä muokkaukselle
     */
    public void setOnGridLiveEdit(OnGridLiveEdit<TYPE> onGridLiveEdit) {
        this.onGridLiveEdit = onGridLiveEdit;
    }


    /**
     * Initializes the control.
     */
    @FXML
    public void initialize() {
        itemsProperty().bind(rivitProp);
        rivitProp.set(tableRows);
    }

    
    /**
     * Asetetaan taulukon sisältö.
     * @param data monirivinen lista, jossa 1. rivi on otsikot ja muut dataa. Alkiot eroteltu |-merkillä.
     */
    public void setRivit(String data) {
        this.rivitJono.set(data);
        String[] rows = data.split("\n");
        this.getColumns().clear();
        tableRows.clear();
        if ( rows.length == 0 ) return;
        String[] headings = rows[0].split("\\|");
        initTable(headings);
        for (int i=1; i<rows.length; i++) {
            add(null, rows[i].split("\\|"));
            // rivit.add(new GridItem<TYPE>(tiedot[i].split("\\|"),null, i-1));
        }
    }


    /**
     * Lisätään taulukkoon otsikot-mukaisesti sarakkeet ja 
     * @param headings sarakkaiden määrä ja otsikot tästä
     */
    public void initTable(String... headings) {
        tableRows.clear();
        alignments.clear();
        getColumns().clear();
        for (int i = 0; i < headings.length; i++) {
            TableColumn<GridRowItem<TYPE>, String> tc = new TableColumn<GridRowItem<TYPE>, String>(headings[i]);
            final int origCol = i;
            
            tc.setCellValueFactory((rivi) -> { 
                GridRowItem<TYPE> tableRow = rivi.getValue();
                String s = get(rivi.getValue().getRowNr(),origCol);
                if ( onCellString != null ) s = onCellString.onGetCell(this, tableRow.getItem(), s, tableRow.getRowNr(), origCol);
                if ( onCellValue == null )
                    return new SimpleStringProperty(s.replace(" ", "."));
                //  String onEdit(StringGrid<TYPE> grid, TYPE item, String newValue, int row, int column);
                String val = this.onCellValue.onGetCell(this, tableRow.getItem(), s, tableRow.getRowNr(), origCol);
                if ( val == null ) val = s;
                return new SimpleStringProperty(val.replace(" ", "."));
             });
            
            tc.setPrefWidth(90);
            tc.setId(""+i);
            getColumns().add(tc);
            // tc.setCellFactory(TextFieldTableCell.forTableColumn());
            tc.setCellFactory(column -> new StringGridCell<TYPE>(origCol)); 
            tc.setOnEditCommit( (t) -> { 
                StringGrid<TYPE> table = (StringGrid<TYPE>)t.getTableView();
                GridRowItem<TYPE> tableRow = table.getItems().get(t.getTablePosition().getRow());
                String s = t.getNewValue();
                if ( s == null ) return;
                int r = table.findRowNr(tableRow);
                if ( table.onGridEdit != null ) s = table.onGridEdit.onGetCell(table,tableRow.getItem(), s, r, origCol);
                if ( s == null ) return;
                tableRow.set(origCol, s);
                table.refresh();
                }
            );
        }
    }
    

    /**
     * Lisätään uusi alkio taulukkoon
     * @param obj mihin objektiin viitataan
     * @param items lisättävät merkkijonot
     */
    public void add(TYPE obj, String...items) {
        tableRows.add(new GridRowItem<TYPE>(items,obj, tableRows.size()));
        refresh();
    }
    
    
    /**
     * Lisätään uusi alkio taulukkoon.  Jotta tämä toimisi, pitää olla
     * tehtynä vähintään set setOnCellString
     * @param obj mihin objektiin viitataan
     */
    public void add(TYPE obj) {
        add(obj,new String[0]);
    }
    
    
    /**
     * Lisätään uudet jonot taulukkoon
     * @param items lisättävät merkkijonot
     */
    public void add(String...items) {
        add(null,items);
    }
    
    
    /**
     * Lisätään uudet alkiot taulukkoon.  Jotta tämä toimisi, pitää olla
     * tehtynä vähintään set setOnCellString
     * @param objs mitkä oliot lisätään
     */
    public void add(Collection<TYPE> objs) {
        for (TYPE obj: objs) add(obj);
    }
    
    
    /**
     * Lisätään uudet alkiot taulukkoon.  Jotta tämä toimisi, pitää olla
     * tehtynä vähintään set setOnCellString
     * @param objs mitkä oliot lisätään
     */
    @SuppressWarnings("unchecked")
    public void add(TYPE... objs) {
        for (TYPE obj: objs) add(obj);
    }
    
    
    /**
     * Poistaa kaikki rivit;
     */
    public void clear() {
        tableRows.clear();
        refresh();
    }


    /**
     * @return rivijonon sisältö.  
     */
    public String getRivit() {
        // return rivitJono.get();
        StringBuilder tulos = new StringBuilder();
        String erotin = "";
        for (TableColumn<GridRowItem<TYPE>, ?> tc : getColumns() ) {
            tulos.append(erotin + tc.getText());
            erotin = "|";
        }
        tulos.append("\n");
        int len = tableRows.size();
        for (int i=0; i<len; i++) {
            GridRowItem<TYPE> rivi = findTableRow(i);
            if ( rivi == null ) continue;
            erotin = "";
            for (String s: rivi.getRow()) {
                tulos.append(erotin + s);
                erotin = "|";
            }
            tulos.append("\n");
        }
        return tulos.toString();
    }

    
    /**
     * Asettaa sarakkeet lajiteltavaksi
     * @param col mikä sarake, -1 on kaikki
     * @param sortable lajiteltava vai ei
     */
    public void setSortable(int col, boolean sortable) {
        for (TableColumn<GridRowItem<TYPE>, ?> tc : getColumns() ) {
            if ( col == -1 || tc.getId().equals(""+col))
                tc.setSortable(sortable);
        }
    }
    
    
    /**
     * Asetetaan valitulle sarakkeelle numeerinen järjestely
     * @param col mille sarakkeelle;
     */
    public void setColumnSortOrderNumber(int col) {
        if ( col < 0 || col >= getColumns().size() ) return;
        @SuppressWarnings("unchecked")
        TableColumn<GridRowItem<TYPE>, String> tc = (TableColumn<GridRowItem<TYPE>, String>) getColumns().get(col); 
        tc.setCellValueFactory((rivi) -> {
            int r = rivi.getValue().getRowNr();
            String s = get(r,col);
            s = "00000000000"+s;
            s = s.substring(s.length()-10, s.length());
            return new SimpleStringProperty(s);
        });
        alignments.put(col, Pos.CENTER_RIGHT);
    }
    
    
    /**
     * Asettaa sarakkeen leveyden
     * @param col mikä sarake, -1 on kaikki
     * @param width mikä on leveys
     */
    public void setColumnWidth(int col, double width) {
        for (TableColumn<GridRowItem<TYPE>, ?> tc : getColumns() ) {
            if ( col == -1 || tc.getId().equals(""+col)) {
                tc.setPrefWidth(width);
                tc.setMaxWidth(width);
                tc.setMinWidth(width);
            }
        }
    }
    
    
    /**
     * Sarakkeen solujen sijoitus
     * @param col mistä sarakkeesta
     * @return mihin reunaan solut sijoitetaan
     */
    public Pos getAlignment(int col) {
        Pos result = alignments.get(col);
        if ( result == null ) return Pos.CENTER_LEFT;
        return result;
    }
    
    
    /**
     * Sarakkeen solujen sijoitus
     * @param col minkä sarakkeen sijoitus
     * @param align mihin keskitetään, esim. Pos.CENTER_CENTER
     */
    public void setAlignment(int col, Pos align) {
        alignments.put(col, align);
    }

    
    /**
     * Sarakkeen solujen sijoitus Swing-vakioiden avulla
     * @param col minkä sarakkeen sijoitus
     * @param align mihin keskitetään, esim. SwingConstants.RIGHT
     */
    public void setAlignment(int col, int align) {
        switch (align) {
        case SwingConstants.RIGHT:
           setAlignment(col, Pos.CENTER_RIGHT);
           break;
        case SwingConstants.CENTER:
            setAlignment(col, Pos.CENTER);
            break;
        default:
            setAlignment(col, Pos.CENTER_LEFT);
        }
    }

    
    /**
     * @return jonon sisältö ominaisuutena
     */
    public StringProperty getRivitProperty() {
        return rivitJono;
    }
    
    
    /**
     * Pakotetaan luomaan cellit uudelleen
    public void forceRefresh() {
        getProperties().put(TableViewSkinBase.RECREATE, Boolean.TRUE);
    }
    */

    
    /**
     * @param tableRow mitä riviä etsitään 
     * @return rivin alkuperäinen rivi-indeksi
     */
    protected int findRowNr(GridRowItem<TYPE> tableRow) {
        if ( tableRow == null ) return -1;
        return tableRow.getRowNr();
    }
    

    /**
     * Valitaan taulukosta tietty rivi. Mikäli rivi liian iso, valitaan viimeinen, mikäli
     * liian pieni, valitaan ensimmäinen (indeksi 0);
     * @param rowvisible mikä rivi näkyvissä olevalla järjestyksellä 
     */
    public void selectRow(int rowvisible) {
        int newrow = rowvisible;
        int rowcount = getItems().size(); 
        if ( rowvisible >= rowcount ) newrow = rowcount -1;
        getFocusModel().focus(newrow);
        getSelectionModel().select(newrow);
    }

    
    /**
     * @return alkuperäinen rivinumero valitulle riville
     */
    public int getRowNr() {
        // int r = getSelectionModel().getSelectedIndex();
        GridRowItem<TYPE> rivi = getSelectionModel().getSelectedItem();
        return findRowNr(rivi);
    }
    
    
    /**
     * @return valittu sarake alkuperäisissä koordinaateissa
     */
    public int getColumnNr() {
        @SuppressWarnings("unchecked")
        TableColumn<GridRowItem<TYPE>, String> tc = getFocusModel().getFocusedCell().getTableColumn();
        if ( tc == null ) return -1;
        return Integer.parseInt(tc.getId());
    }
    
    
    /**
     * Etsitään rivi, jolla pyydetty indeksi
     * @param row mikä rivi etsitään
     * @return rivi tai null jos ei löydy
     */
    private GridRowItem<TYPE> findTableRow(int row) {
        for (GridRowItem<TYPE> r: tableRows)
            if ( r.getRowNr() == row ) return r;
        return null;
    }
    
    
    /**
     * Asetetaan solun arvo
     * @param s uusi arvo solulle
     * @param row rivi
     * @param col sarake
     */
    public void set(String s, int row, int col) {
        GridRowItem<TYPE> rivi = findTableRow(row);
        if ( rivi == null ) return;
        rivi.set(col,s);
        refresh(); 
    }
    
    
    /**
     * Palautetaan solun arvo
     * @param row miltä riviltä alkuperäisillä indekseillä
     * @param col mistä sarakkeesta
     * @return solun arvo, "" jos väärät indeksit
     */
    public String get(int row, int col) {
        GridRowItem<TYPE> rivi = findTableRow(row);
        if ( rivi == null ) return "";
        String s = rivi.get(col);
        if ( onCellString == null ) return s;
        String val = onCellString.onGetCell(this, rivi.getItem(), s, row, col);
        if ( val == null ) val = s;
        if ( val == null ) val = "";
        return val;    
    }
    
    
    /**
     * Asetetaan solun arvo
     * @param obj mitä olioita rivi edustaa
     * @param row rivi
     */
    public void setObject(TYPE obj, int row) {
        GridRowItem<TYPE> rivi = findTableRow(row);
        if ( rivi == null ) return;
        rivi.setItem(obj);
        refresh(); 
    }
    
    
    /**
     * Palautetaan riviä vastaava olio
     * @param row miltä riviltä alkuperäisillä indekseillä
     * @return riviä vastaava olio, null jos väärät indeksit
     */
    public TYPE getObject(int row) {
        GridRowItem<TYPE> rivi = findTableRow(row);
        if ( rivi == null ) return null;
        return rivi.getItem();
    }
    
    
    /**
     * Palautetaan valittua riviä vastaava olio
     * @return riviä vastaava olio, null jos ei valittua
     */
    public TYPE getObject() {
        GridRowItem<TYPE> rivi = getSelectionModel().getSelectedItem();
        if ( rivi == null ) return null;
        return rivi.getItem();
    }
    
    
    /**
     * Asetetaan solun uusi tyyli 
     * @param s uusi tyylinimi solulle.  Voi olla montakin pilkulla tai välilyönnille eroteltua nimeä.
     * @param row rivi
     * @param col sarake
     */
    public void setStyleClass(String s, int row, int col) {
        GridRowItem<TYPE> rivi = findTableRow(row);
        if ( rivi == null ) return;
        rivi.setCellClass(s, col);
        refresh(); 
    }
    
    
    /**
     * Solun asetetut tyylit 
     * @param row rivi
     * @param col sarake
     * @return null jos ei tyyliä, muuten tyylin nimi tai nimet kuten annettu
     */
    public String getStyleClass(int row, int col) {
        GridRowItem<TYPE> rivi = findTableRow(row);
        if ( rivi == null ) return null;
        return rivi.getCellClass(col);
    }
    

    /**
     * Lisätään styles listaan jonosta luokat jotka erotettu pilkuilla tai välilyönneillä
     * @param styles mihin listaan lisätään
     * @param newClasses mitä tyylejä lisätään
     */
    public static void addStyleClasses(ObservableList<String> styles, String newClasses) {
        if ( newClasses == null ) return;
        for (String sc: newClasses.split("[, ]"))
            if ( !sc.isEmpty() && !styles.contains(sc) )
                styles.add(sc);
    }
    
    
    /**
     * @return mikä luokka tyhjille soluille joissa ei ole omaa dataa
     */
    public String getEmptyStyleClass() {
        return emptyStyleClass;
    }

 
    /**
     * @param emptyStyleClass tyhjien solujen luokka (tai luokat eroteltuina pilkulla tai välilöynnillä)
     */
    public void setEmptyStyleClass(String emptyStyleClass) {
        this.emptyStyleClass = emptyStyleClass;
        refresh();
    }

    
    /**
     * Estetään sarakkeiden järjestäminen.
     * Surkea häck, kopioitu 
     * http://stackoverflow.com/questions/10598639/how-to-disable-column-reordering-in-a-javafx2-tableview
     * Eli jos järjestys muuttuu, palautetaan se heti.
     */
    public void disableColumnReOrder() {
        final ArrayList<TableColumn<GridRowItem<TYPE>,?>> columns = new ArrayList<>();
        columns.addAll(getColumns());
        getColumns().addListener(new ListChangeListener<Object>() {
            public boolean suspended;

            @Override
            public void onChanged(Change<?> change) {
                change.next();
                if (change.wasReplaced() && !suspended) {
                    this.suspended = true;
                    getColumns().setAll(columns);
                    this.suspended = false;
                }
            }
        });        
    }
    
    
    /**
     * Luokka yhdelle solulle
     * @param <TYPE> minkä tyyppisiin alkioihin viitataan
     */
    protected static class StringGridCell<TYPE> extends TableCell<GridRowItem<TYPE>, String> {
        
        private TextField textField;
        private int origCol;

        /**
         * @param col mitä saraketta solu vastaa
         */
        public StringGridCell(int col) {
            origCol = col;
        }
        
        
        /**
         * @return taulukko, johon kuulutaan
         */
        public StringGrid<TYPE> getTable() {
           return (StringGrid<TYPE>)getTableView(); 
        }
        
        
        /**
         * @return antaa kohdalla olevan tietueen
         */
        protected GridRowItem<TYPE> getRowItem() {
            @SuppressWarnings("unchecked")
            TableRow<GridRowItem<TYPE>> row = getTableRow();
            if ( row == null ) return null;
            return row.getItem();
        }

        
        /**
         * @return antaa kohdalla olevan tietueen kentän sisällön merkkijonona
         */
        protected String getCellString() {
            GridRowItem<TYPE> tableRow = getRowItem();
            if ( tableRow == null ) return getItem();
            StringGrid<TYPE> table = getTable();
            return table.get(tableRow.getRowNr(), origCol);
        }

        
        @Override
        public void startEdit() {
            if ( isEmpty()) return;
            super.startEdit();
            createTextField();
            setText(null);
            setGraphic(textField);
            textField.setText(getCellString());
            Platform.runLater(() -> textField.requestFocus());
            textField.selectAll();
        }


        @Override
        public void cancelEdit() {
            super.cancelEdit();
            setText(getCellString());
            setGraphic(null);
        }


        @Override
        protected void updateItem(String s, boolean empty) {
            setAlignment(getTable().getAlignment(origCol));

            super.updateItem(getCellString(), empty);
            if (isEditing()) {
                if (textField != null) textField.setText(getCellString());
                setText(null);
                setGraphic(textField);
                return;
            }              
            
            if ( empty ) {
                addStyleClasses(getStyleClass(),getTable().getEmptyStyleClass());
                return;
            }

            @SuppressWarnings("unchecked")
            TableRow<GridRowItem<TYPE>> row = getTableRow();
            if ( row != null && row.getItem() != null) {
                String styleClass = row.getItem().getCellClass(origCol);
                addStyleClasses(getStyleClass(),styleClass);
                setText(getCellString());
            }
            // setStyle("-fx-background-color: yellow;-fx-text-fill:blue");
        }    

        @SuppressWarnings("unchecked")
        private void createTextField() {
            if ( textField != null ) return;
            textField = new TextField();
            textField.setMinWidth(this.getWidth() - this.getGraphicTextGap() * 2);
            textField.focusedProperty().addListener( (arg0, arg1,arg2) -> {
                if (!arg2) {
                    commitEdit(textField.getText());
                }
            });
            textField.setOnAction(e -> commitEdit(textField.getText()));
            textField.setOnKeyReleased(e -> {
                if ( e == null ) return;
                if ( textField == null ) return;
                GridRowItem<TYPE> tietue = getRowItem();
                String s = textField.getText();
                StringGrid<TYPE> table = getTable();
                if ( table.getOnGridLiveEdit() != null ) {
                    int r = table.findRowNr(tietue);
                    s = table.getOnGridLiveEdit().onEdit(table, tietue.getItem(), s, r, origCol, textField);
                }
                if ( s != null ) tietue.set(origCol, s);
            });
            textField.setOnKeyPressed(t -> {
                if (t.getCode() == KeyCode.ENTER) {
                    commitEdit(textField.getText());
                    cancelEdit();
                    t.consume();
                } else if (t.getCode() == KeyCode.ESCAPE) {
                    cancelEdit();
                    t.consume();
                } else if (t.getCode() == KeyCode.TAB) {
                    // commitEdit(textField.getText()); // ei tarvii kun tallennetetaan muutenkin
                    cancelEdit();
                    t.consume();
                    StringGrid<TYPE> table = getTable();
                    if ( t.isShiftDown() )
                        table.getFocusModel().focusLeftCell();
                    else 
                        table.getFocusModel().focusRightCell();
                    
                    table.edit(getTableRow().getIndex(), table.getFocusModel().getFocusedCell().getTableColumn());
                }
            });
        }
    
    }
    
}