A Reminder App using JavaFX - Java Source Code
AppGui.java
package com.javaquizplayer.examples.reminderapp;
import javafx.scene.Parent;
import javafx.scene.layout.VBox;
import javafx.scene.layout.HBox;
import javafx.scene.text.Text;
import javafx.scene.paint.Color;
import javafx.scene.control.TableView;
import javafx.scene.control.TableColumn;
import javafx.scene.control.ListView;
import javafx.scene.control.DatePicker;
import javafx.scene.control.Dialog;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import jfxtras.scene.control.LocalDatePicker;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.cell.CheckBoxTableCell;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.beans.value.ObservableValue;
import javafx.beans.value.ChangeListener;
import javafx.beans.property.SimpleBooleanProperty;
import javax.annotation.PostConstruct;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Optional;
import java.util.TimerTask;
import java.util.Timer;
import org.springframework.dao.DataAccessException;
/*
* Class builds the GUI for the app.
* Gets the app's data from the database and shows in the reminders table.
* Starts a Timer and schedules its reminder notification task.
* Has functions to add, delete and update reminders.
*/
public class AppGui {
private TableView<Reminder> table;
private ListView<String> list;
private LocalDatePicker localDatePicker;
private Text actionStatus;
private HBox hbPane;
private Timer timer;
private DataAccessException dataAccessException;
private DataAccess dataAccess;
private CheckRemindersTask remindersTask;
private ReminderDialog reminderDialog;
/*
* Constructor.
* Constructs the app's GUI.
*/
public AppGui(DataAccess dataAccess, CheckRemindersTask remindersTask, ReminderDialog reminderDialog) {
this.dataAccess = dataAccess;
this.remindersTask = remindersTask;
this.reminderDialog = reminderDialog;
// List view and calendar
list = new ListView<String>(ReminderGroup.getAsFormattedStrings());
list.getSelectionModel().selectedIndexProperty().addListener(
new ListSelectChangeListener());
localDatePicker = new LocalDatePicker();
// VBox with list and calendar
VBox vbox1 = new VBox(15);
vbox1.getChildren().addAll(list, localDatePicker);
// Buttons in a hbox
Button newBtn = new Button("New");
newBtn.setOnAction(actionEvent -> newReminderRoutine());
Button updBtn = new Button("Update");
updBtn.setOnAction(actionEvent -> updateReminderRoutine());
Button delBtn = new Button("Delete");
delBtn.setOnAction(actionEvent -> deleteReminderRoutine());
HBox btnHb = new HBox(10);
btnHb.getChildren().addAll(newBtn, updBtn, delBtn);
// Table view, columns and properties (row and column)
table = new TableView<Reminder>();
TableColumn<Reminder, String> nameCol = new TableColumn<>("Name");
nameCol.setCellValueFactory(new PropertyValueFactory<Reminder, String>("name"));
nameCol.setMaxWidth(1f * Integer.MAX_VALUE * 45); // 45% of table width
TableViewRowAndCellFactories cellFactories = new TableViewRowAndCellFactories();
TableColumn<Reminder, LocalDate> dateCol = new TableColumn<>("Date");
dateCol.setMaxWidth(1f * Integer.MAX_VALUE * 15);
dateCol.setCellValueFactory(new PropertyValueFactory<Reminder, LocalDate>("date"));
dateCol.setCellFactory(column -> cellFactories.getTableCellWithDateFormatting());
TableColumn<Reminder, LocalTime> timeCol = new TableColumn<>("Time");
timeCol.setMaxWidth(1f * Integer.MAX_VALUE * 12);
timeCol.setCellValueFactory(new PropertyValueFactory<Reminder, LocalTime>("time"));
timeCol.setCellFactory(column -> cellFactories.getTableCellWithTimeFormatting());
TableColumn<Reminder, Boolean> priorityCol = new TableColumn<>("Priority");
priorityCol.setMaxWidth(1f * Integer.MAX_VALUE * 12);
priorityCol.setCellValueFactory(new PropertyValueFactory<Reminder, Boolean>("priority"));
priorityCol.setCellFactory(column -> {
CheckBoxTableCell<Reminder, Boolean> cell = new CheckBoxTableCell<>();
cell.setAlignment(Pos.CENTER);
return cell;
});
TableColumn<Reminder, Boolean> completedCol = new TableColumn<>("Completed");
completedCol.setMaxWidth(1f * Integer.MAX_VALUE * 15);
completedCol.setCellValueFactory(new PropertyValueFactory<Reminder, Boolean>("completed"));
completedCol.setCellFactory(column -> {
CheckBoxTableCell<Reminder, Boolean> cell = new CheckBoxTableCell<>();
cell.setAlignment(Pos.CENTER);
return cell;
});
table.getColumns().addAll(nameCol, dateCol,timeCol, priorityCol, completedCol);
table.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
table.setPrefWidth(600);
table.setRowFactory(tableView -> cellFactories.getTooltipTableRow());
// Table row item double-click mouse event
table.setOnMousePressed(mouseEvent -> {
if ((mouseEvent.isPrimaryButtonDown()) &&
(mouseEvent.getClickCount() == 2)) {
updateReminderRoutine();
}
});
// Status message text
actionStatus = new Text();
actionStatus.setFill(Color.FIREBRICK);
// Vbox with buttons hbox, table view and status text
VBox vbox2 = new VBox(15);
vbox2.getChildren().addAll(btnHb, table, actionStatus);
// Hbox with vbox1 and vbox2
hbPane = new HBox(15);
hbPane.setPadding(new Insets(15));
hbPane.setAlignment(Pos.CENTER);
hbPane.getChildren().addAll(vbox1, vbox2);
}
/*
* Gets all reminders from database and populates the table.
* Initiates the reminder timer task.
*/
@PostConstruct
private void init() {
try {
dataAccess.loadRemindersFromDb();
}
catch(DataAccessException ex) {
dataAccessException = ex;
return;
}
table.setItems(dataAccess.getAllReminders());
list.getSelectionModel().selectFirst();
table.requestFocus();
table.getSelectionModel().selectFirst();
initiateReminderTimer();
actionStatus.setText("Welcome to Reminders!");
}
private void initiateReminderTimer() {
timer = new Timer();
long zeroDelay = 0L;
long period = 60000L; // 60 * 1000 = 1 min
// The timer runs once (first time) for the overdue reminders
// and subsequently the scheduled task every (one) minute
timer.schedule(remindersTask, zeroDelay, period);
}
/*
* The following three get methods are referred from the AppStarter class.
*/
public DataAccessException getAppDatabaseException() {
return dataAccessException;
}
public Parent getView() {
return hbPane;
}
public Timer getTimer() {
return timer;
}
/*
* Reminder group list's item selection change listener class.
* On selecting a group the group's reminders are shown in the table.
* For example, selecting Priority shows only the reminders with
* priority == true.
*/
private class ListSelectChangeListener implements ChangeListener<Number> {
@Override
public void changed(ObservableValue<? extends Number> ov,
Number oldVal, Number newVal) {
int ix = newVal.intValue();
if (ix >= 0) {
String groupStr = list.getItems().get(ix);
ReminderGroup group = ReminderGroup.getGroup(groupStr);
actionStatus.setText("");
table.setItems(dataAccess.getTableDataForGroup(group));
table.requestFocus();
table.getSelectionModel().selectFirst();
}
}
}
/*
* Routine for new reminder button action.
* The new reminder is edited in the ReminderDialog
* and is inserted in the table and the database.
*/
private void newReminderRoutine() {
LocalDate reminderDate = localDatePicker.getLocalDate();
reminderDate =
(reminderDate == null || reminderDate.isBefore(LocalDate.now()))
? LocalDate.now() : reminderDate;
Dialog<Reminder> dialog = reminderDialog.create(reminderDate);
Optional<Reminder> result = dialog.showAndWait();
if (result.isPresent()) {
try {
dataAccess.addReminder(result.get());
}
catch(DataAccessException ex) {
String msg = "A database error occurred while inserting the new reminder, exiting the app.";
AppStarter.showExceptionAlertAndExitTheApp(ex, msg);
}
refreshTable();
actionStatus.setText("New reminder added.");
table.getSelectionModel().selectLast();
}
else {
table.requestFocus();
}
}
/*
* Refreshes the table with the updated rows after a
* reminder is added, updated or deleted.
*/
private void refreshTable() {
table.setItems(dataAccess.getAllReminders());
list.getSelectionModel().selectFirst();
table.requestFocus();
}
/*
* Routine for update reminder button action.
* The selected reminder in the table is edited in the
* ReminderDialog and is updated in the table and the database.
*/
public void updateReminderRoutine() {
Reminder rem = table.getSelectionModel().getSelectedItem();
if ((table.getItems().isEmpty()) || (rem == null)) {
return;
}
int ix = dataAccess.getAllReminders().indexOf(rem);
Dialog<Reminder> dialog = reminderDialog.create(rem);
Optional<Reminder> result = dialog.showAndWait();
if (result.isPresent()) {
try {
dataAccess.updateReminder(ix, result.get());
}
catch(DataAccessException ex) {
String msg = "A database error occurred while updating the reminder, exiting the app.";
AppStarter.showExceptionAlertAndExitTheApp(ex, msg);
}
refreshTable();
actionStatus.setText("Reminder updated.");
table.getSelectionModel().select(ix);
}
else {
table.requestFocus();
}
}
/*
* Routine for delete reminder button action.
* Deletes the selected reminder from table and the database.
*/
private void deleteReminderRoutine() {
Reminder rem = table.getSelectionModel().getSelectedItem();
if (table.getItems().isEmpty() || rem == null) {
return;
}
Alert confirmAlert = getConfirmAlertForDelete(rem);
Optional<ButtonType> result = confirmAlert.showAndWait();
if ((result.isPresent()) && (result.get() == ButtonType.OK)) {
try{
dataAccess.deleteReminder(rem);
}
catch(DataAccessException ex) {
String msg = "A database error occurred while deleting the reminder, exiting the app.";
AppStarter.showExceptionAlertAndExitTheApp(ex, msg);
}
refreshTable();
actionStatus.setText("Reminder deleted.");
table.getSelectionModel().selectFirst();
}
else {
table.requestFocus();
}
}
private Alert getConfirmAlertForDelete(Reminder rem) {
Alert alert = new Alert(AlertType.CONFIRMATION);
alert.setHeaderText(null);
alert.setTitle("Reminder");
alert.setContentText("Delete reminder? " + rem);
return alert;
}
}
Reminder.java
package com.javaquizplayer.examples.reminderapp;
import javafx.beans.property.SimpleObjectProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.SimpleBooleanProperty;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
/*
* Class represents a reminder.
*
* NOTE: The reminder's time is captured as LocalTime which is truncated to
* the minutes.For example, 10:23:47.31987 is truncated to 10:23.
* See the time attribute's setter method below.
* Also, see the overridden equals method.
*/
public class Reminder {
private SimpleStringProperty name;
private SimpleStringProperty notes;
private SimpleObjectProperty<LocalDate> date;
private SimpleObjectProperty<LocalTime> time;
private SimpleBooleanProperty priority;
private SimpleBooleanProperty completed;
public Reminder () {
name = new SimpleStringProperty();
notes = new SimpleStringProperty("");
date = new SimpleObjectProperty<LocalDate>();
time = new SimpleObjectProperty<LocalTime>();
priority = new SimpleBooleanProperty();
completed = new SimpleBooleanProperty(false);
}
public String getName() {
return name.get();
}
public SimpleStringProperty nameProperty() {
return name;
}
public void setName(String s) {
name.set(s);
}
public String getNotes() {
return notes.get();
}
public void setNotes(String s) {
notes.set(s);
}
public LocalDate getDate() {
return date.get();
}
public SimpleObjectProperty<LocalDate> dateProperty() {
return date;
}
public void setDate(LocalDate d) {
date.set(d);
}
public LocalTime getTime() {
return time.get();
}
public SimpleObjectProperty<LocalTime> timeProperty() {
return time;
}
public void setTime(LocalTime t) {
// time is stored truncated to minutes
time.set(t.truncatedTo(ChronoUnit.MINUTES));
}
public boolean getPriority() {
return priority.get();
}
public SimpleBooleanProperty priorityProperty() {
return priority;
}
public void setPriority(boolean b) {
priority.set(b);
}
public boolean getCompleted() {
return completed.get();
}
public SimpleBooleanProperty completedProperty() {
return completed;
}
public void setCompleted(boolean b) {
completed.set(b);
}
@Override
public String toString() {
return name.get();
}
/*
* Reminders are equal when their names are same on the same date.
*/
@Override
public boolean equals(Object obj) {
if (obj instanceof Reminder) {
Reminder r = (Reminder) obj;
if ((r.getName().equals(name.get())) &&
(r.getDate().isEqual(date.get()))) {
return true;
}
}
return false;
}
}
ReminderGroup.java
package com.javaquizplayer.examples.reminderapp;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.EnumSet;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
/*
* Enum defines the reminder groups. This enum also stores the enum constant
* formatted strings as a List<String> and a Map<String, ReminderGroup> for
* populating a ListView and lookup respectively. The formatted string
* for a constant is for example, "Completed" and COMPLETED respectively.
*/
public enum ReminderGroup {
REMINDERS,
TODAY,
OVERDUE,
COMPLETED,
PRIORITY;
/* Map with group formatted string as key and enum constant as value */
private static final Map<String, ReminderGroup> map = new HashMap<>();
/* List with group as formatted strings */
private static final List<String> list = new ArrayList<>();
static {
for(ReminderGroup group : EnumSet.allOf(ReminderGroup.class)) {
String str = getEnumString(group);
map.put(str, group);
list.add(str);
}
}
/*
* Formats enum's string, for example: from REMINDERS to Reminders.
*/
private static String getEnumString(ReminderGroup group) {
String s = group.toString().toLowerCase();
return (s.substring(0, 1).toUpperCase() + s.substring(1, s.length()));
}
public static ReminderGroup getGroup(String s) {
return map.get(s);
}
public static ObservableList<String> getAsFormattedStrings() {
return FXCollections.observableList(list);
}
}
TableViewRowAndCellFactories.java
package com.javaquizplayer.examples.reminderapp;
import java.time.LocalDate;
import java.time.LocalTime;
import javafx.scene.control.TableRow;
import javafx.scene.control.TableCell;
import javafx.scene.control.Tooltip;
import java.time.format.DateTimeFormatter;
import javafx.geometry.Pos;
/*
* Class has methods to return row and cell factories to show
* tooltip for each row and format date and time coulmns. These
* are applied the table view's and its respective columns in the app.
*/
public class TableViewRowAndCellFactories {
/*
* Returns TableCell with custom date formatting: dd.MMM.yyyy (10.MAR.2017)
*/
public TableCell<Reminder, LocalDate> getTableCellWithDateFormatting() {
TableCell<Reminder, LocalDate> cell = new TableCell<Reminder, LocalDate>() {
@Override
protected void updateItem(LocalDate date, boolean empty) {
super.updateItem(date, empty);
if (date == null || empty) {
setText(null);
}
else {
setText(date.format(DateTimeFormatter.ofPattern("dd.MMM.yyyy")));
}
}
};
cell.setAlignment(Pos.CENTER);
return cell;
}
/*
* Returns TableCell with custom time formatting: HH:mm (10:25)
*/
public TableCell<Reminder, LocalTime> getTableCellWithTimeFormatting() {
TableCell<Reminder, LocalTime> cell = new TableCell<Reminder, LocalTime>() {
@Override
protected void updateItem(LocalTime time, boolean empty) {
super.updateItem(time, empty);
if (time == null || empty) {
setText(null);
}
else {
setText(time.format(DateTimeFormatter.ofPattern("HH:mm")));
}
}
};
cell.setAlignment(Pos.CENTER);
return cell;
}
/*
* Returns TableRow with tooltip - reminder notes text (upto 100 chars).
*/
public TableRow<Reminder> getTooltipTableRow() {
TableRow<Reminder> row = new TableRow<Reminder>() {
@Override
public void updateItem(Reminder rem, boolean empty) {
super.updateItem(rem, empty);
if (empty) {
setTooltip(null);
}
else {
String notes = rem.getNotes();
if ((notes == null) || (notes.isEmpty())) {
setTooltip(null);
}
else {
notes =
(notes.length() > 100) ?
notes.substring(0, 100) + "..." :
notes;
setTooltip(new Tooltip(notes));
}
}
}
};
return row;
}
}
ReminderDialog.java
package com.javaquizplayer.examples.reminderapp;
import javafx.scene.layout.VBox;
import javafx.scene.layout.HBox;
import javafx.scene.control.Dialog;
import javafx.scene.control.TextField;
import javafx.scene.control.TextArea;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.ButtonBar.ButtonData;
import javafx.scene.control.Tooltip;
import javafx.scene.control.DatePicker;
import javafx.scene.control.DateCell;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.TextFormatter;
import javafx.event.ActionEvent;
import javafx.geometry.Pos;
import javafx.geometry.Insets;
import jfxtras.scene.control.LocalTimePicker;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Optional;
/*
* Class has methods to create dialogs to accept Reminder info.
* There are two methods: for creating a new reminder and update an existing one.
* The methods return respective dialog to the app. The reminder data is
* validated before returning the reminder value to the application.
*/
public class ReminderDialog {
private DataAccess dataAccess;
private boolean newReminder; // indicates if a reminder is new or not
/* Reminder name - maximum and minimum characters allowed. */
private static final int NAME_MAX_CHARS = 25;
private static final int NAME_MIN_CHARS = 5;
/* Reminder notes - maximum characters allowed. */
private static final int NOTES_MAX_CHARS = 200;
public ReminderDialog(DataAccess dataAccess) {
this.dataAccess = dataAccess;
}
/*
* Returns a dialog for new Reminders. The method accepts the
* selected date from the LocalDatePicker in the app.
*/
public Dialog<Reminder> create(LocalDate reminderDate) {
newReminder = true;
Dialog<Reminder> dialog = getDialog("New Reminder");
TextField textFld = getTextField("");
CheckBox priorityCheckBox = getPriorityCheckbox(false);
TextArea textArea = getTextArea("");
DatePicker datePicker = getDatePicker(reminderDate);
LocalTimePicker timePicker = getTimePicker(LocalTime.now());
Optional<CheckBox> completedCheckBoxOpt = Optional.empty();
HBox hb = getHBoxWithWidgets(textFld, priorityCheckBox);
VBox vb = getVBoxWithWidgets(hb, textArea, datePicker, timePicker, completedCheckBoxOpt);
dialog.getDialogPane().setContent(vb);
ButtonType okButtonType = getDialogButtonType(dialog);
String oldName = "";
LocalDate oldDate = null;
Button okButton = getOkButton(dialog, okButtonType, oldName, textFld, oldDate, datePicker, timePicker);
setResultConverterOnDialog(dialog, textFld, textArea, datePicker, timePicker, priorityCheckBox, completedCheckBoxOpt, okButtonType);
return dialog;
}
private Dialog<Reminder> getDialog(String title) {
Dialog<Reminder> dialog = new Dialog<>();
dialog.setTitle(title);
dialog.setResizable(false);
return dialog;
}
private TextField getTextField(String name) {
TextField textFld = new TextField(name);
textFld.setPrefColumnCount(20);
textFld.setTooltip(new Tooltip("Reminder name must be " + NAME_MIN_CHARS + " to " + NAME_MAX_CHARS + " characters"));
textFld.setPromptText("Reminder name (" + NAME_MIN_CHARS + " to " + NAME_MAX_CHARS + " chars)");
return textFld;
}
private TextArea getTextArea(String text) {
TextArea textArea = new TextArea(text);
textArea.setPromptText("Notes upto " + NOTES_MAX_CHARS + " characters.");
textArea.setTooltip(new Tooltip("Reminder notes upto " + NOTES_MAX_CHARS + " characters"));
textArea.setPrefRowCount(3);
textArea.setPrefColumnCount(20);
textArea.setWrapText(true);
// The text formatter limits the number of characters entered in
// the notes text area to NOTES_MAX_CHARS.
// The text formatter has a filter as constructor parameter (is of type
// UnaryOperator<TextFormatter.Change>).
textArea.setTextFormatter(new TextFormatter<String>(change ->
change.getControlNewText().length() <= NOTES_MAX_CHARS ? change : null));
return textArea;
}
private CheckBox getPriorityCheckbox(boolean isChecked) {
CheckBox checkBox = new CheckBox("Priority");
checkBox.setSelected(isChecked);
return checkBox;
}
private CheckBox getCompletedCheckbox(boolean isChecked) {
CheckBox checkBox = new CheckBox("Completed");
checkBox.setSelected(isChecked);
return checkBox;
}
private DatePicker getDatePicker(LocalDate date) {
DatePicker datePicker = new DatePicker(date);
datePicker.setTooltip(new Tooltip("Reminder date: click the icon to open calendar"));
datePicker.setEditable(false);
datePicker.setDayCellFactory(dtPicker -> {
return getCellWithDateDisabledBeforeToday();
});
return datePicker;
}
private DateCell getCellWithDateDisabledBeforeToday() {
DateCell cell = new DateCell() {
@Override
public void updateItem(LocalDate date, boolean empty) {
super.updateItem(date, empty);
if ((! empty) && (date.isBefore(LocalDate.now()))) {
setDisable(true);
}
}
};
return cell;
}
private LocalTimePicker getTimePicker(LocalTime time) {
LocalTimePicker timePicker = new LocalTimePicker(time);
timePicker.setTooltip(new Tooltip("Reminder time: slide knobs to set the hour and minutes"));
return timePicker;
}
private HBox getHBoxWithWidgets(TextField textFld, CheckBox checkBox) {
HBox hb = new HBox(15);
hb.setAlignment(Pos.BASELINE_CENTER);
hb.getChildren().addAll(textFld, checkBox);
return hb;
}
private VBox getVBoxWithWidgets(HBox hb, TextArea text, DatePicker datePicker, LocalTimePicker timePicker, Optional%lt;CheckBox> checkBoxOptional) {
VBox vb = new VBox(15);
vb.setPadding(new Insets(15));
if (checkBoxOptional.isPresent()) {
vb.getChildren().addAll(hb, text, datePicker, timePicker, checkBoxOptional.get());
}
else {
// Completed check box doesn't exist in case of a new reminder
vb.getChildren().addAll(hb, text, datePicker, timePicker);
}
return vb;
}
private ButtonType getDialogButtonType(Dialog dialog) {
ButtonType okButtonType = new ButtonType("Okay", ButtonData.OK_DONE);
dialog.getDialogPane().getButtonTypes().add(okButtonType);
return okButtonType;
}
/*
* Constructs the 'Okay' button for the dialog and registers an ActionEvent
* event filter with it. The event handler validates the input data.
* In case the input data is not valid, the event is stopped from further
* propagation (doesn't allow the click okay button action).
*/
private Button getOkButton(Dialog dialog, ButtonType okButtonType, String oldName, TextField textFld, LocalDate oldDate, DatePicker datePicker, LocalTimePicker timePicker) {
Button okButton = (Button) dialog.getDialogPane().lookupButton(okButtonType);
okButton.addEventFilter(ActionEvent.ACTION, event -> {
if (! validate(oldName, textFld.getText(), oldDate, datePicker.getValue(), timePicker.getLocalTime())) {
showValidationAlertDialog();
event.consume();
}
});
return okButton;
}
/*
* Reminder validation in this dialog.
* The name must be between NAME_MIN_CHARS and NAME_MAX_CHARS characters
* and unique for a date. Date and time must be in future for new reminders.
*/
private boolean validate(String oldName, String name, LocalDate oldDate, LocalDate date, LocalTime time) {
name = name.trim();
if ((name.length() < NAME_MIN_CHARS) ||
(name.length() > NAME_MAX_CHARS)) {
return false;
}
if ((newReminder) &&
(LocalDate.now().isEqual(date)) &&
(LocalTime.now().isAfter(time))) {
return false;
}
if ((! newReminder) &&
(name.equals(oldName)) &&
(date.isEqual(oldDate))) {
return true;
}
for (Reminder r : dataAccess.getAllReminders()) {
if ((r.getName().equals(name)) && (r.getDate().isEqual(date))) {
return false;
}
}
return true;
}
private void showValidationAlertDialog() {
Alert alert = new Alert(AlertType.NONE);
alert.setTitle("Reminder");
alert.getDialogPane().getButtonTypes().add(ButtonType.OK);
String s = "Name must be " + NAME_MIN_CHARS + " to " + NAME_MAX_CHARS + " characters and should be unique within a date.";
String s1 = (newReminder) ? " The date and time must be in future." : "";
alert.setContentText(s + s1);
alert.show();
}
private void setResultConverterOnDialog(Dialog dialog, TextField textFld, TextArea textArea, DatePicker datePicker, LocalTimePicker timePicker, CheckBox priority, Optional<CheckBox> completedOpt, ButtonType okButtonType) {
// The result converter returns the entered Reminder instance in case
// of 'Okay' button is clicked, or null in case the dialog is cancelled.
// The reminder is built from the dialog's widget values after validation.
// This reminder instance is returned by the dialog as an Optional in the app.
dialog.setResultConverter(buttonType -> {
if (buttonType == okButtonType) {
Reminder rem = new Reminder();
rem.setName(textFld.getText().trim());
rem.setNotes(textArea.getText().trim());
rem.setDate(datePicker.getValue());
rem.setTime(timePicker.getLocalTime());
rem.setPriority(priority.isSelected());
if (completedOpt.isPresent()) {
rem.setCompleted(completedOpt.get().isSelected());
}
else {
// Completed checkbox doesn't exist in case of a new reminder
rem.setCompleted(false);
}
return rem;
}
return null;
});
}
/*
* Returns a dialog for updating reminders. The method accepts the
* reminder being updated.
*/
public Dialog<Reminder> create(Reminder rem) {
newReminder = false;
String oldName = rem.getName();
LocalDate oldDate = rem.getDate();
Dialog<Reminder> dialog = getDialog("Reminder");
TextField textFld = getTextField(oldName);
CheckBox priorityCheckBox = getPriorityCheckbox(rem.getPriority());
TextArea textArea = getTextArea(rem.getNotes());
DatePicker datePicker = getDatePicker(oldDate);
LocalTimePicker timePicker = getTimePicker(rem.getTime());
CheckBox completedCheckBox = getCompletedCheckbox(rem.getCompleted());
Optional<CheckBox> completedCheckBoxOpt = Optional.of(completedCheckBox);
HBox hb = getHBoxWithWidgets(textFld, priorityCheckBox);
VBox vb = getVBoxWithWidgets(hb, textArea, datePicker, timePicker, completedCheckBoxOpt);
dialog.getDialogPane().setContent(vb);
ButtonType okButtonType = getDialogButtonType(dialog);
Button okButton = getOkButton(dialog, okButtonType, oldName, textFld, oldDate, datePicker, timePicker);
setResultConverterOnDialog(dialog, textFld, textArea, datePicker, timePicker, priorityCheckBox, completedCheckBoxOpt, okButtonType);
return dialog;
}
}
CheckRemindersTask.java
package com.javaquizplayer.examples.reminderapp;
import java.time.LocalTime;
import java.time.LocalDate;
import java.time.format.FormatStyle;
import java.time.format.DateTimeFormatter;
import java.awt.Toolkit;
import java.awt.geom.Point2D;
import java.util.List;
import java.util.ArrayList;
import java.util.TimerTask;
import java.util.stream.Collectors;
import java.util.function.Predicate;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.ButtonType;
import javafx.stage.Screen;
import javafx.geometry.Rectangle2D;
import javafx.application.Platform;
import javafx.collections.ObservableList;
/*
* Class extends TimerTask and overrides its run() method.
* The class is the input task for the Timer which schedules the
* tasks and is initiated from the app. The tasks:
* (i) one task at the start of the app and (ii) subsequent tasks
* at one minute interval thru the duration of the app.
* The first task notifies all the overdue reminders. The later
* tasks notify the due reminder at that minute.
* The reminder notification is shown in an Alert.
*/
public class CheckRemindersTask extends TimerTask {
private DataAccess dataAccess;
/*
* The predicate initially is set to this value, which is applied only once.
* The second and subsequent execution of the timer task uses
* ReminderPredicates.now. See the run() method.
*/
private Predicate<Reminder> predicate = ReminderPredicates.OVER_DUE;
private List<Point2D.Double> alertPositions;
private int nextAlertPosIndex;
public CheckRemindersTask(DataAccess dataAccess) {
this.dataAccess = dataAccess;
createAlertPositions();
nextAlertPosIndex = 0;
}
/*
* When a reminder is due a notification is shown in an alert.
* When there are multiple alerts at the same minute they are
* positioned on the screen without overlapping each other.
* The positions are pre-defined and stored in a collection.
*/
private void createAlertPositions() {
Rectangle2D r2d = Screen.getPrimary().getVisualBounds();
double x = r2d.getWidth() / 5;
double y = r2d.getHeight() / 5;
Point2D.Double position = null;
alertPositions = new ArrayList<Point2D.Double>();
for (int i = 0; i < 10; i++) {
position = new Point2D.Double(x, y);
alertPositions.add(position);
x += 25; y += 25;
}
}
/*
* Filters all the reminders with supplied criteria (predicate)
* and shows the reminder alerts in the app.
*/
@Override
public void run() {
List<Reminder> dueRems = getDueRems();
showNotifications(dueRems);
predicate = ReminderPredicates.DUE_NOW;
}
private List<Reminder> getDueRems() {
ObservableList<Reminder> rems = dataAccess.getAllReminders();
return rems.stream()
.filter(predicate)
.collect(Collectors.toList());
}
/*
* Show notifications;
* muliple alerts at the same time at different positions.
* The alerts are displayed at 3 second interval.
*/
private void showNotifications(List<Reminder> remsNow) {
for (Reminder r : remsNow) {
Platform.runLater(() -> showReminderAlert(r));
try {
Thread.sleep(3000); // 3 seconds
}
catch (InterruptedException e) {
}
}
}
private void showReminderAlert(Reminder rem) {
Alert alert = new Alert(AlertType.NONE); // a modal alert
// Format alert content
String name = rem.getName();
alert.setTitle("Reminder - " + name);
alert.getDialogPane().getButtonTypes().add(ButtonType.OK);
String content = name + " " +
(rem.getPriority() ? "[Priority]" : "") + "\n" +
rem.getDate().format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG)) +
" " +
rem.getTime().format(DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT));
alert.setContentText(content);
// Get alert's position
Point2D.Double p = getNextAlertPosition();
alert.setX(p.getX());
alert.setY(p.getY());
// Display alert
alert.show();
Toolkit.getDefaultToolkit().beep();
}
private Point2D.Double getNextAlertPosition() {
Point2D.Double p = alertPositions.get(nextAlertPosIndex);
nextAlertPosIndex =
(nextAlertPosIndex == 9) ? nextAlertPosIndex = 0 : ++nextAlertPosIndex;
return p;
}
}
ReminderPredicates.java
package com.javaquizplayer.examples.reminderapp;
import java.util.function.Predicate;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
/*
* Class has definitions of Predicates used in this app. These are defined as
* public static members and are used in various classes.
*/
public class ReminderPredicates {
public static final Predicate<Reminder> ALL = r -> true;
public static final Predicate<Reminder> COMPLETED =
r -> (r.getCompleted() == true);
public static final Predicate<Reminder> PRIORITY =
r -> (r.getPriority() == true);
public static final Predicate<Reminder> TODAYS = r ->
r.getDate().isEqual(LocalDate.now());
private static final Predicate<Reminder> PAST_DAYS = r ->
r.getDate().isBefore(LocalDate.now());
private static final Predicate<Reminder> OVER_DUE_TODAYS_TIME = r ->
r.getTime().isBefore(LocalTime.now());
public static final Predicate<Reminder> OVER_DUE =
COMPLETED.negate()
.and(PAST_DAYS
.or(TODAYS
.and(OVER_DUE_TODAYS_TIME)));
private static final Predicate<Reminder> TIME_NOW = r ->
r.getTime().equals(LocalTime.now().truncatedTo(ChronoUnit.MINUTES));
public static final Predicate<Reminder> DUE_NOW =
TODAYS.and(TIME_NOW).and(COMPLETED.negate());
}
DataAccess.java
package com.javaquizplayer.examples.reminderapp;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.function.Predicate;
/*
* Class is a data accessor for the app. Interacts with the database access
* program DatabaseJdbcAccess. Maintains the reminders data in a collection.
* Has methods to get all, add, update and delete reminders used by the app.
* Also, has a method to return reminders for a given ReminderGroup.
*/
public class DataAccess {
private DatabaseJdbcAccess dbAccess;
private ObservableList<Reminder> remData;
public DataAccess(DatabaseJdbcAccess databaseJdbcAccess) {
dbAccess = databaseJdbcAccess;
}
/*
* This method retrieves all the reminders from the database at the start
* of the application. The reminders are populated in the GUI and also
* stored locally in this class as a collection.
*/
public void loadRemindersFromDb() {
remData = FXCollections.observableList(dbAccess.getAllReminders());
}
public ObservableList<Reminder> getAllReminders() {
return remData;
}
public void addReminder(Reminder rem) {
remData.add(rem);
dbAccess.addReminder(rem);
}
public void updateReminder(int ix, Reminder rem) {
Reminder old = remData.get(ix);
remData.set(ix, rem);
dbAccess.updateReminder(old, rem);
}
public void deleteReminder(Reminder rem) {
remData.remove(rem);
dbAccess.deleteReminder(rem);
}
public ObservableList<Reminder> getTableDataForGroup(ReminderGroup group) {
Predicate<Reminder> remPredicate = null;
switch (group) {
case PRIORITY:
remPredicate = ReminderPredicates.PRIORITY;
break;
case COMPLETED:
remPredicate = ReminderPredicates.COMPLETED;
break;
case TODAY:
remPredicate = ReminderPredicates.TODAYS;
break;
case OVERDUE:
remPredicate = ReminderPredicates.OVER_DUE;
break;
default:
remPredicate = ReminderPredicates.ALL;
}
List<Reminder> result = remData.stream()
.filter(remPredicate)
.collect(Collectors.toList());
return FXCollections.observableList(result);
}
}
AppConfig.java
package com.javaquizplayer.examples.reminderapp;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
@Configuration
@Import(DatabaseJdbcConfig.class)
public class AppConfig {
@Bean
public AppGui appGui(DataAccess dataAccess, CheckRemindersTask checkRemindersTask, ReminderDialog reminderDialog) {
return new AppGui(dataAccess, checkRemindersTask, reminderDialog);
}
@Bean
public ReminderDialog reminderDialog(DataAccess dataAccess) {
return new ReminderDialog(dataAccess);
}
@Bean
public CheckRemindersTask checkRemindersTask(DataAccess dataAccess) {
return new CheckRemindersTask(dataAccess);
}
@Bean
public DataAccess dataAccess(DatabaseJdbcAccess databaseJdbcAccess) {
return new DataAccess(databaseJdbcAccess);
}
}
DatabaseJdbcConfig.java
package com.javaquizplayer.examples.reminderapp;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.SingleConnectionDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class DatabaseJdbcConfig {
private static final String JDBC_DRIVER = "org.hsqldb.jdbc.JDBCDriver";
/* ifexists=true connection property disallows creating a new database.*/
private static final String CONNECTION_URL =
"jdbc:hsqldb:file:db/remindersDB;ifexists=true;";
@Bean
public DataSource dataSource() {
// SingleConnectionDataSource wraps a single JDBC Connection
// which is not closed after use.
SingleConnectionDataSource ds = new SingleConnectionDataSource();
ds.setDriverClassName(JDBC_DRIVER);
ds.setUrl(CONNECTION_URL);
ds.setUsername(""); ds.setPassword("");
return ds;
}
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
@Bean
public DatabaseJdbcAccess databaseJdbcAccess(JdbcTemplate jdbcTemplate) {
return new DatabaseJdbcAccess(jdbcTemplate);
}
}
DatabaseJdbcAccess.java
package com.javaquizplayer.examples.reminderapp;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Date;
import java.sql.Time;
import java.util.List;
import java.time.LocalDate;
import java.time.LocalTime;
/*
* Class has methods to get all, add, update and delete reminders from the
* database. Shutsdown the database.
*
* NOTE: The database date and time column types are compatible with java.sql.Date
* and Time respectively. The app captures date and time as java.time.LocalDate
* and LocalTime respectively. These are converted to and from using the methods
* in java.sql.Date and Time (for example, Date.valueOf(LocalDate) and
* Date.toLocalDate()).
*/
public class DatabaseJdbcAccess {
private JdbcTemplate jdbcTemplate;
private static final String GET_ALL_REMINDERS = "SELECT * FROM REMINDERS_TABLE";
private static final String INSERT_REMINDER =
"INSERT INTO REMINDERS_TABLE VALUES (?, ?, ?, ?, ?, ?)";
private static final String UPDATE_REMINDER =
"UPDATE REMINDERS_TABLE SET name=?, notes=?, date=?, time=?, priority=?, completed=? WHERE name=? AND date=?";
private static final String DELETE_REMINDER =
"DELETE FROM REMINDERS_TABLE WHERE name=? AND date=?";
public DatabaseJdbcAccess(JdbcTemplate template) {
jdbcTemplate = template;
}
public List<Reminder> getAllReminders() {
return jdbcTemplate.query(GET_ALL_REMINDERS,
new RowMapper<Reminder>() {
@Override
public Reminder mapRow(ResultSet rs, int rowNum)
throws SQLException {
Reminder r = new Reminder();
r.setName(rs.getString("name"));
r.setNotes(rs.getString("notes"));
r.setDate(rs.getDate("date").toLocalDate());
r.setTime(rs.getTime("time").toLocalTime());
r.setPriority(rs.getBoolean("priority"));
r.setCompleted(rs.getBoolean("completed"));
return r;
}
}
);
}
public void addReminder(Reminder r) {
jdbcTemplate.update(INSERT_REMINDER,
r.getName(),
r.getNotes(),
Date.valueOf(r.getDate()),
Time.valueOf(r.getTime()),
r.getPriority(),
r.getCompleted()
);
}
public void updateReminder(Reminder old, Reminder r) {
jdbcTemplate.update(UPDATE_REMINDER,
r.getName(),
r.getNotes(),
Date.valueOf(r.getDate()),
Time.valueOf(r.getTime()),
r.getPriority(),
r.getCompleted(),
old.getName(),
Date.valueOf(old.getDate())
);
}
public void deleteReminder(Reminder r) {
jdbcTemplate.update(DELETE_REMINDER,
r.getName(),
Date.valueOf(r.getDate())
);
}
public void shutdownDatabase() {
// SHUTDOWN is a HSQLDB command to close the database.
jdbcTemplate.execute("SHUTDOWN");
}
}
AppStarter.java
package com.javaquizplayer.examples.reminderapp;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.dao.DataAccessException;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.Parent;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import java.util.Timer;
import java.awt.Toolkit;
/*
* The reminder app's starter program.
* Loads the Spring's application context and launches the main GUI.
*/
public class AppStarter extends Application {
private AbstractApplicationContext context;
public static void main(String... args) {
Application.launch(args);
}
/*
* Loads the spring application context from the Java-based configuration.
* Gets the main GUI and displays.
* In case of an initial database exception, shows an alert and
* terminates the app.
*/
@Override
public void start(Stage primaryStage) {
context = new AnnotationConfigApplicationContext(AppConfig.class);
AppGui appGui = context.getBean(AppGui.class);
Parent mainView = appGui.getView();
primaryStage.setScene(new Scene(mainView, 925, 450)); // w x h
primaryStage.setResizable(false);
primaryStage.setTitle("Reminders App");
primaryStage.show();
// Check if any database exception while loading initial data.
// Exit the app in such case.
DataAccessException ex = appGui.getAppDatabaseException();
if (ex != null) {
String msg = "There is an error while loading reminders from the database, exiting the app.";
showExceptionAlertAndExitTheApp(ex, msg);
}
}
/*
* NOTE: this method is commonly acccessed from the AppGui class.
*/
public static void showExceptionAlertAndExitTheApp(Exception ex, String msg) {
System.out.println("#### Error Message: " + ex.getMessage());
Toolkit.getDefaultToolkit().beep();
Alert alert = new Alert(AlertType.ERROR);
alert.setTitle("Reminders - Error");;
alert.setContentText(msg);
alert.showAndWait();
Platform.exit();
}
/*
* Shutsdown the database.
* Terminates the timer discarding the scheduled tasks.
* Closes this application context destroying all beans.
*/
@Override
public void stop() {
context.getBean(DatabaseJdbcAccess.class).shutdownDatabase();
Timer timer = context.getBean(AppGui.class).getTimer();
if (timer != null) {
timer.cancel();
}
context.close();
}
}
Return to top
This page uses Java code formatting from http://hilite.me/.