fix: SceneBuilder will not load missing files from recent projects.

app/src/main/java/com/oracle/javafx/scenebuilder/app/SceneBuilderApp.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2023, Gluon and/or its affiliates.
+ * Copyright (c) 2016, 2024, Gluon and/or its affiliates.
  * Copyright (c) 2012, 2014, Oracle and/or its affiliates.
  * All rights reserved. Use is subject to license terms.
  *
@@ -83,6 +83,7 @@
 import java.nio.file.Paths;
 import java.time.LocalDate;
 import java.util.*;
+import java.util.Map.Entry;
 import java.util.concurrent.CountDownLatch;
 import java.util.function.Consumer;
 import java.util.logging.Level;
@@ -94,6 +95,8 @@
  */
 public class SceneBuilderApp extends Application implements AppPlatform.AppNotificationHandler {
 
+    private static final Logger LOGGER = Logger.getLogger(SceneBuilderApp.class.getName());
+
     public enum ApplicationControlAction {
         ABOUT,
         CHECK_UPDATES,
@@ -496,8 +499,25 @@ private void createEmptyDocumentWindow() {
         newWindow.updateWithDefaultContent();
     }
 
+    /**
+     * By default all necessary actions to open a single file or a group of files take place in this method.
+     * If it is required to perform certain actions after successfully loading all files, please use {@code handleOpenFilesAction(List<String> files, Runnable onSuccess)} instead.
+     * 
+     * All error handling takes place here within, there is no way yet to access exceptional results and to work with them.
+     */
     @Override
     public void handleOpenFilesAction(List<String> files) {
+        handleOpenFilesAction(files, () -> { /* no operation in this case */ });
+    }
+
+    /**
+     * As file loading errors are handled within this method (all exceptions are handled within), it can be helpful to be able to run a certain action after successful file loading (e.g. closing a certain stage).
+     * For this case this method offers the argument {@code Runnable onSuccess} which will be executed after successful file open activity. The {@code Runnable onSuccess} is only ran once, despite how many files have been loaded.
+     *  
+     * @param files List of Strings denoting file paths to be opened
+     * @param onSuccess {@link Runnable} to be executed after all files have been opened successfully
+     */
+    public void handleOpenFilesAction(List<String> files, Runnable onSuccess) {
         assert files != null;
         assert files.isEmpty() == false;
 
@@ -510,21 +530,90 @@ public void handleOpenFilesAction(List<String> files) {
 
         // Fix for #45
         if (userLibrary.isFirstExplorationCompleted()) {
-            performOpenFiles(fileObjs);
+            performOpenFiles(fileObjs, onSuccess);
         } else {
             // open files only after the first exploration has finished
             userLibrary.firstExplorationCompletedProperty().addListener(new InvalidationListener() {
                 @Override
                 public void invalidated(Observable observable) {
                     if (userLibrary.isFirstExplorationCompleted()) {
-                        performOpenFiles(fileObjs);
                         userLibrary.firstExplorationCompletedProperty().removeListener(this);
+                        performOpenFiles(fileObjs, onSuccess);
                     }
                 }
             });
         }
     }
 
+    /**
+     * Opens the given list of files. For all resulting dialogs (success, error),
+     * the welcome dialog window is the configured owner.
+     * 
+     * @param files     List of files which SceneBuilder will attempt to open.
+     * @param onSuccess A runnable holding the action to be performed after
+     *                  successfully loading the files. This is only executed when
+     *                  all files have been opened without errors.
+     */
+    private void performOpenFiles(final List<File> files, Runnable onSuccess) {
+        var openResult = performOpenFiles(files);
+        handleFileOpenResult(openResult, onSuccess, WelcomeDialogWindowController.getInstance().getStage());
+    }
+
+    /**
+     * The onSuccess Runnable is only executed if the {@link FileOpenResult} has no
+     * errors at all.
+     * 
+     * @param result    {@link FileOpenResult} holding the list of files to be
+     *                  opened and a map of files with exceptions in case of an
+     *                  error.
+     * @param onSuccess A runnable holding the action to be performed on success.
+     * @param owner     Owner window ({@link Stage})
+     */
+    private void handleFileOpenResult(FileOpenResult result, Runnable onSuccess, Stage owner) {
+        if (result.hasErrors()) {
+            showFileOpenErrors(result, owner);
+        } else {
+            onSuccess.run();
+        }
+    }
+
+    /**
+     * For each file open error (when opened through the welcome dialog), the file
+     * name and the related exception text are presented to the user to confirm.
+     * 
+     * @param openResult {@link FileOpenResult} holding a map of files with
+     *                   exceptions.
+     * @param owner Owner {@link Stage}
+     */
+    private void showFileOpenErrors(FileOpenResult openResult, Stage owner) {
+        if (openResult.errors().isEmpty()) {
+            return;
+        }
+
+        Map<File, Exception> errors = openResult.errors();
+        for (Entry<File, Exception> error : errors.entrySet()) {
+            final File fxmlFile = error.getKey();
+            final Exception x = error.getValue();
+            final ErrorDialog errorDialog = new ErrorDialog(owner);
+            errorDialog.setMessage(I18N.getString("alert.open.failure1.message", displayName(fxmlFile.getPath())));
+            errorDialog.setDetails(I18N.getString("alert.open.failure1.details"));
+            errorDialog.setDebugInfoWithThrowable(x);
+            errorDialog.setTitle(I18N.getString("alert.open.failure.title"));
+            errorDialog.setDetailsTitle(I18N.getString("alert.open.failure.title")+": "+fxmlFile.getName());
+            errorDialog.showAndWait();
+        }
+    }
+
+    private Stage getOwnerWindow() {
+        Stage owner = null;
+        if (windowList.isEmpty()) {
+            owner = WelcomeDialogWindowController.getInstance().getStage();
+        } else {
+            owner = windowList.get(0).getStage();
+        }
+        return owner;
+    }
+
     @Override
     public void handleMessageBoxFailure(Exception x) {
         final ErrorDialog errorDialog = new ErrorDialog(null);
@@ -608,7 +697,8 @@ private void performOpenFile() {
         if (fxmlFiles != null) {
             assert fxmlFiles.isEmpty() == false;
             EditorController.updateNextInitialDirectory(fxmlFiles.get(0));
-            performOpenFiles(fxmlFiles);
+            FileOpenResult openResult = performOpenFiles(fxmlFiles);
+            showFileOpenErrors(openResult, getOwnerWindow());
         }
     }
 
@@ -656,12 +746,15 @@ public DocumentWindowController getFrontDocumentWindow() {
         return null;
     }
 
-    private void performOpenFiles(List<File> fxmlFiles) {
+    private FileOpenResult performOpenFiles(List<File> fxmlFiles) {
         assert fxmlFiles != null;
         assert fxmlFiles.isEmpty() == false;
 
+        LOGGER.log(Level.FINE, "Opening {0} files...", fxmlFiles.size());
         final Map<File, Exception> exceptions = new HashMap<>();
+        final List<File> openedFiles = new ArrayList<>();
         for (File fxmlFile : fxmlFiles) {
+            LOGGER.log(Level.FINE, "Attempting to open file {0}", fxmlFile);
             try {
                 final DocumentWindowController dwc
                         = lookupDocumentWindowControllers(fxmlFile.toURI().toURL());
@@ -673,47 +766,26 @@ private void performOpenFiles(List<File> fxmlFiles) {
                     var hostWindow = findFirstUnusedDocumentWindowController().orElse(makeNewWindow());
                     hostWindow.loadFromFile(fxmlFile);
                     hostWindow.openWindow();
+                    openedFiles.add(fxmlFile);
+                    LOGGER.log(Level.INFO, "Successfully opened file {0}", fxmlFile);
                 }
             } catch (Exception xx) {
+                LOGGER.log(Level.WARNING, "Failed to open file: %s".formatted(fxmlFile), xx);
                 exceptions.put(fxmlFile, xx);
             }
         }
-
-        switch (exceptions.size()) {
-            case 0: { // Good
-                // Update recent items with opened files
-                final PreferencesController pc = PreferencesController.getSingleton();
-                pc.getRecordGlobal().addRecentItems(fxmlFiles);
-                break;
-            }
-            case 1: {
-                final File fxmlFile = exceptions.keySet().iterator().next();
-                final Exception x = exceptions.get(fxmlFile);
-                final ErrorDialog errorDialog = new ErrorDialog(null);
-                errorDialog.setMessage(I18N.getString("alert.open.failure1.message", displayName(fxmlFile.getPath())));
-                errorDialog.setDetails(I18N.getString("alert.open.failure1.details"));
-                errorDialog.setDebugInfoWithThrowable(x);
-                errorDialog.setTitle(I18N.getString("alert.title.open"));
-                errorDialog.showAndWait();
-                break;
-            }
-            default: {
-                final ErrorDialog errorDialog = new ErrorDialog(null);
-                if (exceptions.size() == fxmlFiles.size()) {
-                    // Open operation has failed for all the files
-                    errorDialog.setMessage(I18N.getString("alert.open.failureN.message"));
-                    errorDialog.setDetails(I18N.getString("alert.open.failureN.details"));
-                } else {
-                    // Open operation has failed for some files
-                    errorDialog.setMessage(I18N.getString("alert.open.failureMofN.message",
-                            exceptions.size(), fxmlFiles.size()));
-                    errorDialog.setDetails(I18N.getString("alert.open.failureMofN.details"));
-                }
-                errorDialog.setTitle(I18N.getString("alert.title.open"));
-                errorDialog.showAndWait();
-                break;
-            }
+
+        // Update recent items with opened files
+        if (!openedFiles.isEmpty()) {
+            final PreferencesController pc = PreferencesController.getSingleton();
+            pc.getRecordGlobal().addRecentItems(openedFiles);
+        }
+        if (exceptions.size() > 0) {
+            LOGGER.log(Level.WARNING, "Failed to open {0} of {1} files!", new Object[] {exceptions.size(), fxmlFiles.size()});
+        } else {
+            LOGGER.log(Level.FINE, "Successfully opened all files.");
         }
+        return new FileOpenResult(fxmlFiles, exceptions);
     }
 
     private void performExit() {
@@ -1061,4 +1133,16 @@ public static void applyToAllDocumentWindows(Consumer<DocumentWindowController>
             consumer.accept(dwc);
         }
     }
+
+    /**
+     * Describes the result of FXML file loading process. As in general SceneBuilder
+     * can open multiple files at the same time. Hence this record can hold of the
+     * files supposed to be opened. In case of errors, the exceptions are stored in
+     * a map per file.
+     */
+    record FileOpenResult(List<File> filesToOpen, Map<File, Exception> errors) {
+        public boolean hasErrors() {
+            return !errors.isEmpty();
+        }
+    }
 }