Allow reordering of custom entry types fields

src/main/java/org/jabref/gui/DragAndDropDataFormats.java

@@ -11,6 +11,7 @@
  */
 public class DragAndDropDataFormats {
 
+    public static final DataFormat FIELD = new DataFormat("dnd/org.jabref.model.entry.field.Field");
     public static final DataFormat GROUP = new DataFormat("dnd/org.jabref.model.groups.GroupTreeNode");
     public static final DataFormat LINKED_FILE = new DataFormat("dnd/org.jabref.model.entry.LinkedFile");
     public static final DataFormat ENTRIES = new DataFormat("dnd/org.jabref.model.entry.BibEntries");

src/main/java/org/jabref/gui/customentrytypes/CustomEntryTypeDialogViewModel.java

@@ -3,9 +3,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
@@ -34,7 +32,6 @@
 import org.jabref.model.entry.types.UnknownEntryType;
 import org.jabref.preferences.PreferencesService;
 
-import com.tobiasdiez.easybind.EasyBind;
 import de.saxsys.mvvmfx.utils.validation.FunctionBasedValidator;
 import de.saxsys.mvvmfx.utils.validation.ValidationMessage;
 import de.saxsys.mvvmfx.utils.validation.ValidationStatus;
@@ -55,18 +52,14 @@ public Field fromString(String string) {
         }
     };
 
-    private final ListProperty<BibEntryType> entryTypes;
-    private final ListProperty<Field> fields;
-    private final ObjectProperty<BibEntryType> selectedEntryTypes = new SimpleObjectProperty<>();
-    private final ListProperty<FieldViewModel> fieldsForType;
+    private final ObservableList<Field> fieldsForAdding;
+    private final ObjectProperty<CustomEntryTypeViewModel> selectedEntryTypes = new SimpleObjectProperty<>();
     private final ObjectProperty<Field> selectedFieldToAdd = new SimpleObjectProperty<>();
     private final StringProperty entryTypeToAdd = new SimpleStringProperty("");
     private final ObservableList<BibEntryType> allEntryTypes;
-    private final ObservableList<FieldViewModel> allFieldsForType = FXCollections.observableArrayList(extractor -> new Observable[] {extractor.fieldName(), extractor.fieldType()});
     private final ObjectProperty<Field> newFieldToAdd = new SimpleObjectProperty<>();
     private final BibDatabaseMode mode;
-    private final Map<BibEntryType, List<FieldViewModel>> typesWithFields = new HashMap<>();
-    private final List<BibEntryType> typesToRemove = new ArrayList<>();
+    private final ListProperty<CustomEntryTypeViewModel> entryTypesWithFields = new SimpleListProperty<>(FXCollections.observableArrayList(extractor -> new Observable[] {extractor.entryType(), extractor.fields()}));
 
     private final PreferencesService preferencesService;
     private final BibEntryTypesManager entryTypesManager;
@@ -83,36 +76,30 @@ public CustomEntryTypeDialogViewModel(BibDatabaseMode mode, PreferencesService p
         allTypes.addAll(entryTypesManager.getAllCustomTypes(mode));
 
         allEntryTypes = FXCollections.observableArrayList(allTypes);
-        entryTypes = new SimpleListProperty<>(allEntryTypes);
-
-        fields = new SimpleListProperty<>(FXCollections.observableArrayList(FieldFactory.getCommonFields()));
+        fieldsForAdding = new SimpleListProperty<>(FXCollections.observableArrayList(FieldFactory.getStandardFielsdsWithBibTexKey()));
 
         for (BibEntryType entryType : allTypes) {
-            List<FieldViewModel> fields = entryType.getAllFields().stream().map(bibField -> new FieldViewModel(bibField.getField(), entryType.isRequired(bibField.getField()), bibField.getPriority(), entryType)).collect(Collectors.toList());
-            typesWithFields.put(entryType, fields);
+            CustomEntryTypeViewModel viewModel = new CustomEntryTypeViewModel(entryType);
+            this.entryTypesWithFields.add(viewModel);
         }
 
-        this.fieldsForType = new SimpleListProperty<>(allFieldsForType);
-
-        EasyBind.subscribe(selectedEntryTypes, type -> {
-            if (type != null) {
-                allFieldsForType.setAll(typesWithFields.get(type));
-            }
-        });
-
         Predicate<String> notEmpty = input -> (input != null) && !input.trim().isEmpty();
         entryTypeValidator = new FunctionBasedValidator<>(entryTypeToAdd, notEmpty, ValidationMessage.error(Localization.lang("Entry type cannot be empty. Please enter a name.")));
         fieldValidator = new FunctionBasedValidator<>(newFieldToAdd,
-                input -> input != null && !input.getDisplayName().isEmpty(),
-                ValidationMessage.error(Localization.lang("Field cannot be empty. Please enter a name.")));
+                                                      input -> (input != null) && !input.getDisplayName().isEmpty(),
+                                                      ValidationMessage.error(Localization.lang("Field cannot be empty. Please enter a name.")));
+    }
+
+    public ListProperty<CustomEntryTypeViewModel> entryTypes() {
+        return this.entryTypesWithFields;
     }
 
-    public ListProperty<BibEntryType> entryTypes() {
-        return this.entryTypes;
+    public ObservableList<Field> fields() {
+        return this.fieldsForAdding;
     }
 
-    public ListProperty<Field> fields() {
-        return this.fields;
+    public ObservableList<FieldViewModel> fieldsForSelectedType() {
+        return this.selectedEntryTypes.getValue().fields();
     }
 
     public enum FieldType {
@@ -138,28 +125,24 @@ public String toString() {
 
     public void addNewField() {
         Field field = newFieldToAdd.getValue();
-        FieldViewModel model = new FieldViewModel(field, true, FieldPriority.IMPORTANT, selectedEntryTypes.getValue());
-        typesWithFields.computeIfAbsent(selectedEntryTypes.getValue(), key -> new ArrayList<>()).add(model);
-        allFieldsForType.add(model);
+        FieldViewModel model = new FieldViewModel(field, true, FieldPriority.IMPORTANT);
+        this.selectedEntryTypes.getValue().addField(model);
         newFieldToAddProperty().setValue(null);
     }
 
     public void addNewCustomEntryType() {
         EntryType newentryType = new UnknownEntryType(entryTypeToAdd.getValue());
         BibEntryType type = new BibEntryType(newentryType, new ArrayList<>(), Collections.emptyList());
+        CustomEntryTypeViewModel viewModel = new CustomEntryTypeViewModel(type);
+        this.entryTypesWithFields.add(viewModel);
         this.allEntryTypes.add(type);
         this.entryTypeToAdd.setValue("");
-        this.typesWithFields.put(type, new ArrayList<>());
     }
 
-    public ObjectProperty<BibEntryType> selectedEntryTypeProperty() {
+    public ObjectProperty<CustomEntryTypeViewModel> selectedEntryTypeProperty() {
         return this.selectedEntryTypes;
     }
 
-    public ListProperty<FieldViewModel> fieldsforTypesProperty() {
-        return this.fieldsForType;
-    }
-
     public ObjectProperty<Field> selectedFieldToAddProperty() {
         return this.selectedFieldToAdd;
     }
@@ -180,22 +163,19 @@ public ValidationStatus fieldValidationStatus() {
         return fieldValidator.getValidationStatus();
     }
 
-    public void removeEntryType(BibEntryType focusedItem) {
-        typesToRemove.add(focusedItem);
-        typesWithFields.remove(focusedItem);
-        allEntryTypes.remove(focusedItem);
+    public void removeEntryType(CustomEntryTypeViewModel focusedItem) {
+        entryTypesWithFields.remove(focusedItem);
     }
 
     public void removeField(FieldViewModel focusedItem) {
-        typesWithFields.computeIfAbsent(selectedEntryTypes.getValue(), key -> new ArrayList<>()).remove(focusedItem);
-        allFieldsForType.remove(focusedItem);
+        this.selectedEntryTypes.getValue().removeField(focusedItem);
     }
 
     public void apply() {
 
-        for (var typeWithField : typesWithFields.entrySet()) {
-            BibEntryType type = typeWithField.getKey();
-            List<FieldViewModel> allFields = typeWithField.getValue();
+        for (var typeWithField : entryTypesWithFields) {
+            BibEntryType type = typeWithField.entryType().getValue();
+            List<FieldViewModel> allFields = typeWithField.fields();
 
             List<OrFields> requiredFields = allFields.stream().filter(field -> field.getFieldType() == FieldType.REQUIRED).map(FieldViewModel::getField).map(OrFields::new).collect(Collectors.toList());
             List<BibField> otherFields = allFields.stream().filter(field -> field.getFieldType() == FieldType.OPTIONAL).map(bibField -> new BibField(bibField.getField(), bibField.getFieldPriority())).collect(Collectors.toList());
@@ -204,13 +184,9 @@ public void apply() {
             entryTypesManager.addCustomOrModifiedType(newType, mode);
         }
 
-        for (var type : typesToRemove) {
-            entryTypesManager.removeCustomOrModifiedEntryType(type, mode);
-        }
         preferencesService.saveCustomEntryTypes();
         // Reload types from preferences to make sure any modifications are present when reopening the dialog
-        entryTypesManager.addCustomOrModifiedTypes(
-                preferencesService.loadBibEntryTypes(BibDatabaseMode.BIBTEX),
-                preferencesService.loadBibEntryTypes(BibDatabaseMode.BIBLATEX));
+        entryTypesManager.addCustomOrModifiedTypes(preferencesService.loadBibEntryTypes(BibDatabaseMode.BIBTEX),
+                                                   preferencesService.loadBibEntryTypes(BibDatabaseMode.BIBLATEX));
     }
 }

src/main/java/org/jabref/gui/customentrytypes/CustomEntryTypeViewModel.java

@@ -0,0 +1,46 @@
+package org.jabref.gui.customentrytypes;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+import org.jabref.model.entry.BibEntryType;
+
+public class CustomEntryTypeViewModel {
+
+    private final ObjectProperty<BibEntryType> entryType = new SimpleObjectProperty<>();
+    private final ObservableList<FieldViewModel> fields;
+
+    public CustomEntryTypeViewModel(BibEntryType entryType) {
+        this.entryType.set(entryType);
+
+        List<FieldViewModel> allFieldsForType = entryType.getAllFields().stream().map(bibField -> new FieldViewModel(bibField.getField(), entryType.isRequired(bibField.getField()), bibField.getPriority())).collect(Collectors.toList());
+        fields = FXCollections.observableArrayList(allFieldsForType);
+    }
+
+    public void addField(FieldViewModel field) {
+        this.fields.add(field);
+    }
+
+    public ObservableList<FieldViewModel> fields() {
+        return this.fields;
+    }
+
+    public ObjectProperty<BibEntryType> entryType() {
+        return this.entryType;
+    }
+
+    public void removeField(FieldViewModel focusedItem) {
+        this.fields.remove(focusedItem);
+    }
+
+    @Override
+    public String toString() {
+        return "CustomEntryTypeViewModel [entryType=" + entryType + ", fields=" + fields + "]";
+    }
+
+}

src/main/java/org/jabref/gui/customentrytypes/CustomizeEntryTypeDialogView.java

@@ -6,39 +6,48 @@
 
 import javafx.application.Platform;
 import javafx.beans.property.ReadOnlyStringWrapper;
+import javafx.collections.ObservableList;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.ButtonBar.ButtonData;
 import javafx.scene.control.ButtonType;
 import javafx.scene.control.ComboBox;
 import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableRow;
 import javafx.scene.control.TableView;
 import javafx.scene.control.TextField;
+import javafx.scene.input.ClipboardContent;
+import javafx.scene.input.DragEvent;
+import javafx.scene.input.Dragboard;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.TransferMode;
 
+import org.jabref.gui.DragAndDropDataFormats;
 import org.jabref.gui.customentrytypes.CustomEntryTypeDialogViewModel.FieldType;
 import org.jabref.gui.icon.IconTheme;
 import org.jabref.gui.util.BaseDialog;
 import org.jabref.gui.util.RadioButtonCell;
 import org.jabref.gui.util.ValueTableCellFactory;
+import org.jabref.gui.util.ViewModelTableRowFactory;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.database.BibDatabaseMode;
-import org.jabref.model.entry.BibEntryType;
 import org.jabref.model.entry.BibEntryTypesManager;
 import org.jabref.model.entry.field.Field;
 import org.jabref.preferences.PreferencesService;
 
 import com.airhacks.afterburner.views.ViewLoader;
+import com.tobiasdiez.easybind.EasyBind;
 import de.saxsys.mvvmfx.utils.validation.visualization.ControlsFxVisualizer;
 
 public class CustomizeEntryTypeDialogView extends BaseDialog<Void> {
 
     private final BibDatabaseMode mode;
     private final BibEntryTypesManager entryTypesManager;
 
-    @FXML private TableView<BibEntryType> entryTypes;
-    @FXML private TableColumn<BibEntryType, String> entryTypColumn;
-    @FXML private TableColumn<BibEntryType, String> entryTypeActionsColumn;
+    @FXML private TableView<CustomEntryTypeViewModel> entryTypes;
+    @FXML private TableColumn<CustomEntryTypeViewModel, String> entryTypColumn;
+    @FXML private TableColumn<CustomEntryTypeViewModel, String> entryTypeActionsColumn;
     @FXML private TextField addNewEntryType;
     @FXML private TableView<FieldViewModel> fields;
     @FXML private TableColumn<FieldViewModel, String> fieldNameColumn;
@@ -88,14 +97,14 @@ private void setupTable() {
 
         // Table View must be editable, otherwise the change of the Radiobuttons does not propagate the commit event
         fields.setEditable(true);
-        entryTypColumn.setCellValueFactory(cellData -> new ReadOnlyStringWrapper(cellData.getValue().getType().getDisplayName()));
+        entryTypColumn.setCellValueFactory(cellData -> new ReadOnlyStringWrapper(cellData.getValue().entryType().get().getType().getDisplayName()));
         entryTypes.itemsProperty().bind(viewModel.entryTypes());
         entryTypes.getSelectionModel().selectFirst();
 
         entryTypeActionsColumn.setSortable(false);
         entryTypeActionsColumn.setReorderable(false);
-        entryTypeActionsColumn.setCellValueFactory(cellData -> new ReadOnlyStringWrapper(cellData.getValue().getType().getDisplayName()));
-        new ValueTableCellFactory<BibEntryType, String>()
+        entryTypeActionsColumn.setCellValueFactory(cellData -> new ReadOnlyStringWrapper(cellData.getValue().entryType().get().getType().getDisplayName()));
+        new ValueTableCellFactory<CustomEntryTypeViewModel, String>()
                 .withGraphic(item -> IconTheme.JabRefIcons.DELETE_ENTRY.getGraphicNode())
                 .withTooltip(name -> Localization.lang("Remove entry type") + " " + name)
                 .withOnMouseClickedEvent(item -> evt -> viewModel.removeEntryType(entryTypes.getSelectionModel().getSelectedItem()))
@@ -128,7 +137,69 @@ private void setupTable() {
                 .install(fieldTypeActionColumn);
 
         viewModel.newFieldToAddProperty().bindBidirectional(addNewField.valueProperty());
-        fields.itemsProperty().bindBidirectional(viewModel.fieldsforTypesProperty());
+
+        // Here we would need to select the fields
+        EasyBind.subscribe(viewModel.selectedEntryTypeProperty(), type -> {
+            if (type != null) {
+                fields.getItems().clear();
+                fields.setItems(viewModel.fieldsForSelectedType());
+            }
+        });
+
+        new ViewModelTableRowFactory<FieldViewModel>()
+                                                      .setOnDragDetected(this::handleOnDragDetected)
+                                                      .setOnDragDropped(this::handleOnDragDropped)
+                                                      .setOnDragOver(this::handleOnDragOver)
+                                                      .install(fields);
+
+    }
+
+    private void handleOnDragOver(FieldViewModel originalItem, DragEvent event) {
+        if ((event.getGestureSource() != originalItem) && event.getDragboard().hasContent(DragAndDropDataFormats.FIELD)) {
+            event.acceptTransferModes(TransferMode.MOVE);
+        }
+    }
+
+    private void handleOnDragDetected(TableRow<FieldViewModel> row, FieldViewModel fieldViewModel, MouseEvent event) {
+        // Start drag'n'drop
+        row.startFullDrag();
+
+        Field field = fields.getSelectionModel().getSelectedItem().getField();
+
+        ClipboardContent content = new ClipboardContent();
+        Dragboard dragboard = fields.startDragAndDrop(TransferMode.MOVE);
+        content.put(DragAndDropDataFormats.FIELD, field);
+        dragboard.setContent(content);
+        event.consume();
+    }
+
+    private void handleOnDragDropped(TableRow<FieldViewModel> row, FieldViewModel originalItem, DragEvent event) {
+        boolean success = false;
+        Dragboard dragboard = event.getDragboard();
+
+        ObservableList<FieldViewModel> items = fields.itemsProperty().get();
+
+        if (dragboard.hasContent(DragAndDropDataFormats.FIELD)) {
+
+            Field field = (Field) dragboard.getContent(DragAndDropDataFormats.FIELD);
+            FieldViewModel transferedItem = null;
+            int draggedIdx = 0;
+            for (int i = 0; i < items.size(); i++) {
+                if (items.get(i).getField().equals(field)) {
+                    draggedIdx = i;
+                    transferedItem = items.get(i);
+                    break;
+                }
+            }
+            int thisIdx = items.indexOf(originalItem);
+            items.set(draggedIdx, originalItem);
+            items.set(thisIdx, transferedItem);
+            success = true;
+        }
+
+        event.setDropCompleted(success);
+        event.consume();
+
     }
 
     @FXML