javafx.scene.control.cell.ComboBoxTableCell Java Examples

@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void select() {
    TableView<?> tableView = (TableView<?>) getPrimaryStage().getScene().getRoot().lookup(".table-view");
    LoggingRecorder lr = new LoggingRecorder();
    Platform.runLater(() -> {
        Point2D point = getPoint(tableView, 2, 1);
        ComboBoxTableCell cell = (ComboBoxTableCell) getCellAt(tableView, 1, 2);
        RFXTableView rfxTableView = new RFXTableView(tableView, null, point, lr);
        rfxTableView.focusGained(null);
        cell.startEdit();
        tableView.edit(1, (TableColumn) tableView.getColumns().get(2));
        Person person = (Person) tableView.getItems().get(1);
        person.setLastName("Jones");
        cell.commitEdit("Jones");
        rfxTableView.focusLost(null);
    });
    List<Recording> recordings = lr.waitAndGetRecordings(1);
    Recording recording = recordings.get(0);
    AssertJUnit.assertEquals("recordSelect", recording.getCall());
    AssertJUnit.assertEquals("Jones", recording.getParameters()[0]);
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void selectEditable() {
    TableView<?> tableView = (TableView<?>) getPrimaryStage().getScene().getRoot().lookup(".table-view");
    LoggingRecorder lr = new LoggingRecorder();
    Platform.runLater(() -> {
        Point2D point = getPoint(tableView, 2, 1);
        ComboBoxTableCell cell = (ComboBoxTableCell) getCellAt(tableView, 1, 2);
        cell.setEditable(true);
        RFXTableView rfxTableView = new RFXTableView(tableView, null, point, lr);
        rfxTableView.focusGained(null);
        cell.startEdit();
        tableView.edit(1, (TableColumn) tableView.getColumns().get(2));
        Person person = (Person) tableView.getItems().get(1);
        person.setLastName("Jones");
        cell.commitEdit("Jones");
        rfxTableView.focusLost(null);
    });
    List<Recording> recordings = lr.waitAndGetRecordings(1);
    Recording recording = recordings.get(0);
    AssertJUnit.assertEquals("recordSelect", recording.getCall());
    AssertJUnit.assertEquals("Jones", recording.getParameters()[0]);
}
 

/**
 * Initializes the Order By table view. Configures the table columns to show the correct field values and allow the
 * sort order of each field to be changed with a ComboBox.
 */
private void initializeOrderByTableView() {
  // make the table columns stretch to fill the width of the table
  orderByTableView.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);

  // show the field name and sort order values in the column cells
  orderByFieldNameTableColumn.setCellValueFactory(cellData -> cellData.getValue().fieldNameProperty());
  orderBySortOrderTableColumn.setCellValueFactory(cellData -> cellData.getValue().sortOrderProperty());

  // show an editable ComboBox in the sort order column cells to change the sort order
  orderBySortOrderTableColumn.setCellFactory(col -> {
    ComboBoxTableCell<OrderByField, QueryParameters.SortOrder> ct = new ComboBoxTableCell<>();
    ct.getItems().addAll(QueryParameters.SortOrder.values());
    ct.setEditable(true);
    return ct;
  });

  // switch to edit mode when the user selects the Sort Order column
  orderByTableView.getSelectionModel().selectedItemProperty().addListener(e -> {
    List<TablePosition> tablePositions = orderByTableView.getSelectionModel().getSelectedCells();
    if (!tablePositions.isEmpty()) {
      tablePositions.forEach(tp -> orderByTableView.edit(tp.getRow(), orderBySortOrderTableColumn));
    }
  });
}
 

public static void reset() {
    add(Node.class, JavaFXElement.class);
    add(TextInputControl.class, JavaFXTextInputControlElement.class);
    add(HTMLEditor.class, JavaFXHTMLEditor.class);
    add(CheckBox.class, JavaFXCheckBoxElement.class);
    add(ToggleButton.class, JavaFXToggleButtonElement.class);
    add(Slider.class, JavaFXSliderElement.class);
    add(Spinner.class, JavaFXSpinnerElement.class);
    add(SplitPane.class, JavaFXSplitPaneElement.class);
    add(ProgressBar.class, JavaFXProgressBarElement.class);
    add(ChoiceBox.class, JavaFXChoiceBoxElement.class);
    add(ColorPicker.class, JavaFXColorPickerElement.class);
    add(ComboBox.class, JavaFXComboBoxElement.class);
    add(DatePicker.class, JavaFXDatePickerElement.class);
    add(TabPane.class, JavaFXTabPaneElement.class);
    add(ListView.class, JavaFXListViewElement.class);
    add(TreeView.class, JavaFXTreeViewElement.class);
    add(TableView.class, JavaFXTableViewElement.class);
    add(TreeTableView.class, JavaFXTreeTableViewElement.class);
    add(CheckBoxListCell.class, JavaFXCheckBoxListCellElement.class);
    add(ChoiceBoxListCell.class, JavaFXChoiceBoxCellElement.class);
    add(ComboBoxListCell.class, JavaFXComboBoxCellElement.class);
    add(CheckBoxTreeCell.class, JavaFXCheckBoxTreeCellElement.class);
    add(ChoiceBoxTreeCell.class, JavaFXChoiceBoxCellElement.class);
    add(ComboBoxTreeCell.class, JavaFXComboBoxCellElement.class);
    add(TableCell.class, JavaFXTableViewCellElement.class);
    add(CheckBoxTableCell.class, JavaFXCheckBoxTableCellElement.class);
    add(ChoiceBoxTableCell.class, JavaFXChoiceBoxCellElement.class);
    add(ComboBoxTableCell.class, JavaFXComboBoxCellElement.class);
    add(TreeTableCell.class, JavaFXTreeTableCellElement.class);
    add(CheckBoxTreeTableCell.class, JavaFXCheckBoxTreeTableCell.class);
    add(ChoiceBoxTreeTableCell.class, JavaFXChoiceBoxCellElement.class);
    add(ComboBoxTreeTableCell.class, JavaFXComboBoxCellElement.class);
    add(WebView.class, JavaFXWebViewElement.class);
    add(GenericStyledArea.GENERIC_STYLED_AREA_CLASS, RichTextFXGenericStyledAreaElement.class);
}
 

@SuppressWarnings("rawtypes")
private StringConverter getConverter() {
    if (node instanceof ComboBoxListCell<?>) {
        return ((ComboBoxListCell) node).getConverter();
    } else if (node instanceof ComboBoxTableCell<?, ?>)
        return ((ComboBoxTableCell) node).getConverter();
    else if (node instanceof ComboBoxTreeCell<?>)
        return ((ComboBoxTreeCell) node).getConverter();
    else if (node instanceof ComboBoxTreeTableCell<?, ?>)
        return ((ComboBoxTreeTableCell) node).getConverter();
    return null;
}
 

@SuppressWarnings("unchecked")
@Override
public String _getValue() {
    @SuppressWarnings("rawtypes")
    ComboBoxTableCell cell = (ComboBoxTableCell) node;
    return cell.getConverter().toString(cell.getItem());
}
 

private void configureTasksTable() {

		taskNameColumn.setCellValueFactory(new PropertyValueFactory<>("name"));
		taskDescriptionColumn.setCellValueFactory(new PropertyValueFactory<>("description"));

		taskStatusColumn.setCellValueFactory(new PropertyValueFactory<>("status"));
		taskStatusColumn.setCellFactory(ComboBoxTableCell.forTableColumn(Task.Status.values()));

		taskStatusColumn.setOnEditCommit(edit -> {
			edit.getRowValue().setStatus(edit.getNewValue());
			projectTrackingService.save(edit.getRowValue());
		});
	}
 

private void configureTasksTable() {

		taskNameColumn.setCellValueFactory(new PropertyValueFactory<>("name"));
		taskDescriptionColumn.setCellValueFactory(new PropertyValueFactory<>("description"));

		taskStatusColumn.setCellValueFactory(new PropertyValueFactory<>("status"));
		taskStatusColumn.setCellFactory(ComboBoxTableCell.forTableColumn(Task.Status.values()));

		taskStatusColumn.setOnEditCommit(edit -> {
			edit.getRowValue().setStatus(edit.getNewValue());
			projectTrackingService.save(edit.getRowValue());
		});
	}
 

public ObjectTableView() {
    super(null);
    FXMLLoader loader = new FXMLLoader(getClass().getResource("/fxml/ObjectTableView.fxml"), bundle);
    loader.setRoot(this);
    loader.setController(this);

    try {
        loader.load();
    }
    catch (Exception ex) {
        LOG.log(Level.SEVERE, "Unable to load FXML", ex);
    }

    getSelectionModel().setSelectionMode(SelectionMode.SINGLE);

    showAllCheckBox.setAllowIndeterminate(true);

    visibleColumn.setCellFactory(CheckBoxTableCell.forTableColumn(visibleColumn));
    visibleColumn.setCellValueFactory(cell -> cell.getValue().visibleProperty());

    thumbColumn.setCellFactory(param -> new ImageViewTableCell<>());
    thumbColumn.setCellValueFactory(cell -> cell.getValue().thumbProperty());

    List<String> names = IteratorUtils.toList(Settings.recentNamesProperty.stream().map(NameColor::getName).iterator());
    nameColumn.setCellFactory(ComboBoxTableCell.forTableColumn(FXCollections.observableList(names)));
    nameColumn.setCellValueFactory(cell -> cell.getValue().nameProperty());

    itemsProperty().addListener((observable, oldValue, newValue) -> {
        ObservableList<ObservableValue<Boolean>> visibles = EasyBind.map(newValue, ObjectTag::visibleProperty);
        visibleCount = EasyBind.combine(visibles, stream -> stream.filter(b -> b).count());
        visibleCount.addListener((obs, oldCount, newCount) -> {
            if (newCount == 0) {
                showAllCheckBox.setIndeterminate(false);
                showAllCheckBox.setSelected(false);
            }
            else if (newCount < getItems().size()) {
                showAllCheckBox.setIndeterminate(true);
            }
            else {
                showAllCheckBox.setIndeterminate(false);
                showAllCheckBox.setSelected(true);
            }
        });
    });
}
 

public SQLColumnSettingsComponent() {
    columnsTable.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);

    value = new SQLColumnSettings();
    TableColumn<SQLRowObject,String> columnName=new TableColumn<SQLRowObject,String> (value.getColumnName(0));
    TableColumn<SQLRowObject,SQLExportDataType>  columnType=new TableColumn<SQLRowObject,SQLExportDataType> (value.getColumnName(1));
    TableColumn<SQLRowObject,String>  columnValue= new TableColumn<SQLRowObject,String> (value.getColumnName(2));

    columnName.setCellValueFactory(new PropertyValueFactory<>("Name")); //this is needed during connection to a database
    columnType.setCellValueFactory(new PropertyValueFactory<>("Type"));
    columnValue.setCellValueFactory(new PropertyValueFactory<>("Value"));

    columnsTable.getColumns().addAll(columnName,columnType,columnValue);  //added all the columns in the table
    setValue(value);
    columnsTable.setStyle("-fx-selection-bar: #3399FF; -fx-selection-bar-non-focused: #E3E3E3;"); //CSS color change on selection of row


    columnsTable.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
    columnName.setSortable(false);
    columnValue.setSortable(false);
    columnType.setSortable(false);

    columnName.setReorderable(false);
    columnValue.setReorderable(false);
    columnType.setReorderable(false);

    columnsTable.setPrefSize(550, 220);
    columnsTable.setFixedCellSize(columnsTable.getFixedCellSize()+20);
    columnsTable.setStyle("-fx-font: 10 \"Plain\"");

    //Setting action event on cells
    columnsTable.getSelectionModel().setCellSelectionEnabled(true);  //individual cell selection enabled
    columnsTable.setEditable(true);

    //Editors on each cell
  columnName.setCellFactory(TextFieldTableCell.<SQLRowObject>forTableColumn());
  columnName.setOnEditCommit(event -> {
    getValue().setValueAt(event.getNewValue(), event.getTablePosition().getRow(), 0);
    setValue(getValue()); //refresh the table
  });

  columnValue.setCellFactory(TextFieldTableCell.<SQLRowObject>forTableColumn());
  columnValue.setOnEditCommit(event -> {
    getValue().setValueAt(event.getNewValue().toUpperCase(), event.getTablePosition().getRow(), 2);
    setValue(getValue()); //refresh the table
  });

  ArrayList<SQLExportDataType> exportDataTypeValues=new ArrayList<SQLExportDataType>(Arrays.asList(SQLExportDataType.values()));

  columnType.setCellFactory(ComboBoxTableCell.forTableColumn(FXCollections.observableArrayList(SQLExportDataType.values())));
  columnType.setOnEditCommit(event -> {
    boolean selected = event.getNewValue().isSelectableValue();
    if(!selected){ //case of  invalid(Title) datatype selection
      getValue().setValueAt(exportDataTypeValues.get(exportDataTypeValues.indexOf(event.getNewValue())+1),event.getTablePosition().getRow(),1);
    }
    else {
      getValue().setValueAt(event.getNewValue(), event.getTablePosition().getRow(), 1);
    }
    setValue(getValue());
  });

    // Add buttons
    VBox buttonsPanel=new VBox(20);
    addColumnButton=new Button("Add");
    removeColumnButton=new Button("Remove");
    addColumnButton.setOnAction(this::actionPerformed);
    removeColumnButton.setOnAction(this::actionPerformed);
    buttonsPanel.getChildren().addAll(addColumnButton,removeColumnButton);


    this.setRight(buttonsPanel);
    this.setCenter(columnsTable);
    BorderPane.setMargin(buttonsPanel, new Insets(10));

}
 

@FXML
public void initialize() {
    updateCol.setCellValueFactory(param -> param.getValue().updateProperty());
    lockedCol.setCellValueFactory(param -> param.getValue().lockedProperty());
    typeCol.setCellValueFactory(param -> param.getValue().typeProperty());
    addrCol.setCellValueFactory(param -> param.getValue().addrProperty());
    descCol.setCellValueFactory(param -> param.getValue().descProperty());
    valueCol.setCellValueFactory(param -> param.getValue().valueProperty());

    updateCol.setCellFactory(param -> new CheckBoxTableCell<>());
    lockedCol.setCellFactory(param -> new CheckBoxTableCell<>());
    typeCol.setCellFactory(param -> new ComboBoxTableCell<>(DataType.values()) {
        {
            setItem(DataType.INT);
        }
    });
    addrCol.setCellFactory(TextFieldTableCell.forTableColumn());
    descCol.setCellFactory(TextFieldTableCell.forTableColumn());
    valueCol.setCellFactory(param -> new SpinnerTableCell<>(valueCol, new HexSpinner() {
                {
                    setEditable(true);
                    setSize(16);
                }
            }) {
                @Override
                protected void updateItem(Long item, boolean empty) {
                    super.updateItem(item, empty);
                    if (item == null || empty) {
                        return;
                    }
                    WatchlistModel model = getTableRow().getItem();
                    if (model == null) {
                        return;
                    }
                    getSpinner().setSize(model.getSize() * 2);
                }
            }
    );

    watchlistTable.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> removeButton.setDisable(newValue == null));
}
 

public void init() {
        TableColumn<SettlementBase, String> nameCol = new TableColumn<>(headers[0]);
        nameCol.setCellValueFactory(cellData -> cellData.getValue().nameProperty());
        //nameCol.setCellFactory(TextFieldTableCell.forTableColumn());
        nameCol = setCellFactory(nameCol);
        nameCol.setMinWidth(150);

        templateCol = new TableColumn<>(headers[1]);
        templateCol.setCellValueFactory(cellData -> cellData.getValue().templateProperty());
        templateCol.setCellFactory(ComboBoxTableCell.forTableColumn(
        		templates.get(0).getTemplateName(),
        		templates.get(1).getTemplateName(),
        		templates.get(2).getTemplateName(),
        		templates.get(3).getTemplateName(),
        		templates.get(4).getTemplateName(),
        		templates.get(5).getTemplateName()));
        templateCol.setMinWidth(250);

        settlerCol = new TableColumn<>(headers[2]);
        settlerCol.setCellValueFactory(cellData -> cellData.getValue().settlerProperty());
        //settlerCol.setCellFactory(TextFieldTableCell.forTableColumn());
        settlerCol = setCellFactory(settlerCol);
        settlerCol.setMinWidth(50);

        //private ValidationSupport validationSupport = new ValidationSupport();
		//validationSupport.registerValidator(TextField, Validator.createEmptyValidator("Text is required"));

        botCol = new TableColumn<>(headers[3]);
        botCol.setCellValueFactory(cellData -> cellData.getValue().botProperty());
        //botCol.setCellFactory(TextFieldTableCell.forTableColumn());
        botCol = setCellFactory(botCol);
        botCol.setMinWidth(50);

        TableColumn<SettlementBase, String> sponsorCol = new TableColumn<>(headers[4]);
        sponsorCol.setCellValueFactory(cellData -> cellData.getValue().sponsorProperty());
        sponsorCol.setCellFactory(ComboBoxTableCell.forTableColumn(
        		SPONSORS[0].toString(),
        		SPONSORS[1].toString(),
        		SPONSORS[2].toString(),
        		SPONSORS[3].toString(),
        		SPONSORS[4].toString(),
        		SPONSORS[5].toString(),
        		SPONSORS[6].toString(),
        		SPONSORS[7].toString()
//        		SPONSORS[8].toString()    		
        		));
        sponsorCol.setMinWidth(300);


        latCol = new TableColumn<>(headers[5]);
        latCol.setCellValueFactory(cellData -> cellData.getValue().latitudeProperty());
        //latCol.setCellFactory(TextFieldTableCell.forTableColumn());
        latCol = setCellFactory(latCol);
        latCol.setMinWidth(70);


        longCol = new TableColumn<>(headers[6]);
        longCol.setCellValueFactory(cellData -> cellData.getValue().longitudeProperty());
        //longCol.setCellFactory(TextFieldTableCell.forTableColumn());
        longCol = setCellFactory(longCol);
        longCol.setMinWidth(70);

        table_view.getColumns().addAll(nameCol, templateCol ,settlerCol ,botCol ,sponsorCol ,latCol, longCol);
        table_view.getItems().addAll(generateDataInMap());

		// attach a list change listener to allData
		addListChangeListener();
    }
 

/**
 * Initializes the Highlighting tab.
 */
private void initializeHighlightingTab() {

    // Disable tab if there is nothing to show.
    if (registers.size() < 1 || RAMs.size() < 1) {
        highlightingTab.setDisable(true);
        return;
    }

    // Making column widths adjust properly
    highlightingTable.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);

    // updates selectedSet, disables/enables buttons
    highlightingTable.getSelectionModel().selectedItemProperty().addListener(
            new ChangeListener<RegisterRAMPair>() {
                @Override
                public void changed(ObservableValue<? extends RegisterRAMPair> selected,
                                    RegisterRAMPair oldSet, RegisterRAMPair newSet) {
                    highlightingSelectedSet = newSet;
                    updateHighlightingClickables();
                }
            });

    // Accounts for width changes.
    highlightingTable.widthProperty().addListener(
            new ChangeListener<Number>() {
                @Override
                public void changed(ObservableValue<? extends Number> observableValue, Number oldValue, Number newValue) {
                    Double newWidth = (Double) newValue;
                    Double sum = registerColumn.getWidth()
                            + RAMColumn.getWidth()
                            + dynamicColumn.getWidth();
                    Double perc = sum / oldValue.doubleValue() * .94;

                    registerColumn.setPrefWidth(newWidth * perc *
                            registerColumn.getWidth() / sum);
                    RAMColumn.setPrefWidth(newWidth * perc *
                            RAMColumn.getWidth() / sum);
                    dynamicColumn.setPrefWidth(newWidth * perc *
                            dynamicColumn.getWidth() / sum);
                }
            });

    // Callbacks
    Callback<TableColumn<RegisterRAMPair, Register>, TableCell<RegisterRAMPair, Register>>
            cellComboRegisterFactory =
            new Callback<TableColumn<RegisterRAMPair, Register>, TableCell<RegisterRAMPair, Register>>() {
                @Override
                public TableCell<RegisterRAMPair, Register> call(
                        TableColumn<RegisterRAMPair, Register> setStringTableColumn) {
                    return new ComboBoxTableCell<>(registers);
                }
            };

    Callback<TableColumn<RegisterRAMPair, RAM>, TableCell<RegisterRAMPair, RAM>>
            cellComboRAMFactory = setStringTableColumn -> new ComboBoxTableCell<>(RAMs);

    Callback<TableColumn<RegisterRAMPair, Boolean>, TableCell<RegisterRAMPair, Boolean>>
            cellCheckBoxFactory = setStringTableColumn -> {
                CheckBoxTableCell<RegisterRAMPair, Boolean> cbtc =
                        new CheckBoxTableCell<>();
                cbtc.setAlignment(Pos.CENTER);
                return cbtc;
            };

    // SetCellValueFactories
    registerColumn.setCellValueFactory(new PropertyValueFactory<>("register"));
    RAMColumn.setCellValueFactory(new PropertyValueFactory<>("ram"));
    dynamicColumn.setCellValueFactory(new PropertyValueFactory<>("dynamic"));

    // Register Factories and setOnEditCommits
    registerColumn.setCellFactory(cellComboRegisterFactory);
    registerColumn.setOnEditCommit(text -> text.getRowValue().setRegister(
            text.getNewValue()));

    RAMColumn.setCellFactory(cellComboRAMFactory);
    RAMColumn.setOnEditCommit(text -> text.getRowValue().setRam(
            text.getNewValue()));

    dynamicColumn.setCellFactory(cellCheckBoxFactory);
    dynamicColumn.setOnEditCommit(text -> text.getRowValue().setDynamic(
            text.getNewValue()));

    // Load in Rows
    ObservableList<RegisterRAMPair> data = highlightingTable.getItems();
    ObservableList<RegisterRAMPair> regRamPairs = mediator.getRegisterRAMPairs();
    for (RegisterRAMPair rrp : regRamPairs) {
        data.add(rrp.clone());
    }
    highlightingTable.setItems(data);
}
 

/**
 * Initializes the Punctuation tab.
 */
private void initializePunctuationTab() {

    // Making column widths adjust properly
    leftPunctuationTable.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
    rightPunctuationTable.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);

    // Callbacks
    Callback<TableColumn<PunctChar, String>, TableCell<PunctChar, String>>
            cellStrFactory = setStringTableColumn -> {
        EditingStrCell<PunctChar> esc = new EditingStrCell<>();
        esc.setAlignment(Pos.CENTER);
        esc.setFont(new Font("Courier", 18));
        return esc;
    };

    Callback<TableColumn<PunctChar, Use>, TableCell<PunctChar, Use>> cellComboFactory1
            = setStringTableColumn -> new ComboBoxTableCell<>(Use.values());

    Callback<TableColumn<PunctChar, Use>, TableCell<PunctChar, Use>>
        cellComboFactory2 =
            setStringTableColumn -> new ComboBoxTableCell<>(Use.values());

    // Set cellValue Factory
    leftASCIIColumn.setCellValueFactory(new PropertyValueFactory<>("Char"));
    leftTypeColumn.setCellValueFactory(new PropertyValueFactory<>("Use"));
    rightASCIIColumn.setCellValueFactory(new PropertyValueFactory<>("Char"));
    rightTypeColumn.setCellValueFactory(new PropertyValueFactory<>("Use"));

    // Set cell factory and onEditCommit
    leftASCIIColumn.setCellFactory(cellStrFactory);
    rightASCIIColumn.setCellFactory(cellStrFactory);
    // no on edit necessary

    leftTypeColumn.setCellFactory(cellComboFactory1);
    leftTypeColumn.setOnEditCommit(text -> text.getRowValue().setUse(
            text.getNewValue()));
    rightTypeColumn.setCellFactory(cellComboFactory2);
    rightTypeColumn.setOnEditCommit(text -> text.getRowValue().setUse(
            text.getNewValue()));

    // Put values into table
    ObservableList<PunctChar> leftData = leftPunctuationTable.getItems();
    ObservableList<PunctChar> rightData = rightPunctuationTable.getItems();
    PunctChar[] originalPunctChars = mediator.getMachine().getPunctChars();
    int leftSize = (originalPunctChars.length) / 2;
    int rightSize = originalPunctChars.length - leftSize;
    for (int i = 0; i < leftSize + rightSize; i++) {
        if (i < leftSize) {
            leftData.add(originalPunctChars[i].copy());
        } else {
            rightData.add(originalPunctChars[i].copy());
        }
    }
    leftPunctuationTable.setItems(leftData);
    rightPunctuationTable.setItems(rightData);

    // for disabling appropriately
    punctuationTab.disableProperty().bind(mediator.getDesktopController().inDebugOrRunningModeProperty());
}
 

/**
 * Initializes the controller class.
 */
@Override
public void initialize(URL url, ResourceBundle rb) {
    table.setColumnResizePolicy(TableView.UNCONSTRAINED_RESIZE_POLICY);
    name.prefWidthProperty().bind(table.widthProperty().subtract(2).multiply(.15));
    type.prefWidthProperty().bind(table.widthProperty().subtract(2).multiply(.16));
    numBits.prefWidthProperty().bind(table.widthProperty().subtract(2).multiply(.17));
    defaultValue.prefWidthProperty().bind(table.widthProperty().subtract(2).multiply(.20));
    relativity.prefWidthProperty().bind(table.widthProperty().subtract(2).multiply(.18));
    signed.prefWidthProperty().bind(table.widthProperty().subtract(2).multiply(.14));

    selectedField = null;
    deleteButton.setDisable(true);
    duplicateButton.setDisable(true);
    valuesButton.setDisable(true);

    final ObservableList<Field.Relativity> relBoxOptions = FXCollections.observableArrayList();
    
    relBoxOptions.addAll(Field.Relativity.absolute, Field.Relativity.pcRelativePreIncr,
            Field.Relativity.pcRelativePostIncr);
    
    final ObservableList<Field.Type> typeBoxOptions = FXCollections.observableArrayList();
    
    typeBoxOptions.addAll(Field.Type.required, Field.Type.optional, Field.Type.ignored);
    
    Callback<TableColumn<Field, String>, TableCell<Field, String>> cellStrFactory =
            setStringTableColumn -> new cpusim.gui.util.EditingStrCell<>();
    Callback<TableColumn<Field,Integer>, TableCell<Field,Integer>> cellIntFactory =
            setIntegerTableColumn -> new EditingNonNegativeIntCell<>();
    Callback<TableColumn<Field,Long>, TableCell<Field,Long>> cellLongFactory =
            setLongTableColumn -> new EditingLongCell<>();
    Callback<TableColumn<Field,Field.Relativity>,
            TableCell<Field,Field.Relativity>> cellRelFactory =
            setStringTableColumn -> new ComboBoxTableCell<>(relBoxOptions);
    Callback<TableColumn<Field,Boolean>,TableCell<Field, Boolean>> cellBoolFactory =
            booleanTableColumn -> new CheckBoxTableCell<>();
    Callback<TableColumn<Field,Field.Type>,
            TableCell<Field, Field.Type>> cellTypeFactory =
            setStringTableColumn -> new ComboBoxTableCell<>(typeBoxOptions);

    name.setCellValueFactory(new PropertyValueFactory<>("name"));
    type.setCellValueFactory(new PropertyValueFactory<>("type"));
    numBits.setCellValueFactory(new PropertyValueFactory<>("numBits"));
    defaultValue.setCellValueFactory(new PropertyValueFactory<>("defaultValue"));
    relativity.setCellValueFactory(new PropertyValueFactory<>("relativity"));
    signed.setCellValueFactory(new PropertyValueFactory<>("signed"));
    
    //Add for Editable Cell of each field, in String or in Integer
    name.setCellFactory(cellStrFactory);
    name.setOnEditCommit(
            text -> {
                String newName = text.getNewValue();
                String oldName = text.getOldValue();
                ( text.getRowValue()).setName(newName);
                try{
                    Validate.namedObjectsAreUniqueAndNonempty(table.getItems().toArray());
                } catch (ValidationException ex) {
                    (text.getRowValue()).setName(oldName);
                }
                updateTable();
            }
    );

    type.setCellFactory(cellTypeFactory);
    type.setOnEditCommit(text -> text.getRowValue().setType(text.getNewValue()));

    numBits.setCellFactory(cellIntFactory);
    numBits.setOnEditCommit(text -> text.getRowValue().setNumBits(text.getNewValue
            ()));

    defaultValue.setCellFactory(cellLongFactory);
    defaultValue.setOnEditCommit(text ->
            text.getRowValue().setDefaultValue(text.getNewValue()));

    relativity.setCellFactory(cellRelFactory);
    relativity.setOnEditCommit(text -> text.getRowValue().setRelativity(text.getNewValue()));

    signed.setCellFactory(cellBoolFactory);
    signed.setOnEditCommit(text -> text.getRowValue().setSigned(text.getNewValue()));

    table.getSelectionModel().selectedItemProperty().addListener((ov, t, t1) -> {
        deleteButton.setDisable(false);
        duplicateButton.setDisable(false);
        valuesButton.setDisable(false);
        selectedField = t1;
    });
            
    table.setItems(allFields);
}
 

@Override
 public TableCell<Person, String> call(TableColumn<Person, String> param) {

     return new ComboBoxTableCell<Person, String>(new DefaultStringConverter()) {      
     	
     	{
         	ContextMenu cm = new ContextMenu();
         	MenuItem deletePersonsMenuItem = new MenuItem("Delete");
         	deletePersonsMenuItem.setOnAction( PersonTypeCellFactory.this.deletePersonsHandler );
         	cm.getItems().add(deletePersonsMenuItem);
         	this.setContextMenu(cm);    
         	
         	this.getItems().addAll( "Friend", "Co-worker", "Other" );
         	
         	this.setEditable(true);
     	}
     	
         @Override
         public void updateItem(String arg0, boolean empty) {
         	
             super.updateItem(arg0, empty);
             
             if( !empty ) {
                 this.setText( arg0 );
             } else {
                 this.setText( null );  // clear from recycled obj
             }
         }

@SuppressWarnings("unchecked")
@Override
public void commitEdit(String newValue) {
	super.commitEdit(newValue);
	TableRow<Person> row = this.getTableRow();
	Person p = row.getItem();
	
	String msg = p.validate();
	if( logger.isLoggable(Level.FINE) ) {
		logger.fine("[COMMIT EDIT] validate=" + msg);
	}
		
	if( msg == null || msg.isEmpty() ) {
		if( logger.isLoggable(Level.FINE) ) {
			logger.fine("[COMMIT EDIT] validation passed");
		}
		Task<Void> task = new Task<Void>() {
			@Override
			protected Void call() {
				dao.updatePerson(p);  // updates AR too
				return null;
			}
		};
		new Thread(task).start();
	} else {
		
		System.out.println("layoutBounds=" + this.getLayoutBounds());
		System.out.println("boundsInLocal=" + this.getBoundsInLocal());
		System.out.println("boundsInParent=" + this.getBoundsInParent());
		System.out.println("boundsInParent (Scene)=" + this.localToScene(this.getBoundsInParent()));
		System.out.println("boundsInParent (Screen)=" + this.localToScreen(this.getBoundsInParent()));

		System.out.println("row layoutBounds=" + row.getLayoutBounds());
		System.out.println("row boundsInLocal=" + row.getBoundsInLocal());
		System.out.println("row boundsInParent=" + row.getBoundsInParent());
		System.out.println("row boundsInParent (Scene)=" + row.localToScene(this.getBoundsInParent()));
		System.out.println("row boundsInParent (Screen)=" + row.localToScreen(this.getBoundsInParent()));

		VBox vbox = new VBox();
		vbox.setPadding(new Insets(10.0d));
		vbox.setStyle("-fx-background-color: white; -fx-border-color: red");
		vbox.getChildren().add( new Label(msg));
		//vbox.setEffect(new DropShadow());
		
		Popup popup = new Popup();
		popup.getContent().add( vbox );
		popup.setAutoHide(true);
		popup.setOnShown((evt) -> {
			
			System.out.println("vbox layoutBounds=" + vbox.getLayoutBounds());
			System.out.println("vbox boundsInLocal=" + vbox.getBoundsInLocal());
			System.out.println("vbox boundsInParent=" + vbox.getBoundsInParent());
			System.out.println("vbox boundsInParent (Scene)=" + vbox.localToScene(this.getBoundsInParent()));
			System.out.println("vbox boundsInParent (Screen)=" + vbox.localToScreen(this.getBoundsInParent()));

		});
		popup.show( row, 
				row.localToScreen(row.getBoundsInParent()).getMinX(), 
				row.localToScreen(row.getBoundsInParent()).getMaxY());					
	}
}
     };
 }