@@ -144,7 +144,7 @@
     colour. A channel that cannot be calculated (for example spin-flip on a
     non-magnetic model) is shown as measured data only.
   - Each channel is fitted, drawn and reported with the resolution of its own
-    file (see "Variable resolution" below).
+    file (see "Variable resolution" above).
   - **Limitation:** Bayesian sampling of polarized experiments is not
     supported yet.
   - Project save/load now fully supports polarized experiments.
 
@@ -5,6 +5,7 @@
 from easyreflectometry import Project as ProjectLib
 from PySide6.QtCore import Property
 from PySide6.QtCore import QObject
+from PySide6.QtCore import QUrl
 from PySide6.QtCore import Signal
 from PySide6.QtCore import Slot
 from PySide6.QtQml import QJSValue
@@ -21,6 +22,37 @@ def _from_qml(value):
     return value
 
 
+def _local_path(path) -> str:
+    """A local file path from a QML file-dialog entry (`QUrl`), a file URL or a path.
+
+    `str()` of a `QUrl` is its Python repr, and `generalizePath` does not undo
+    percent-encoding (spaces, non-ASCII names), so URLs go through Qt.
+    """
+    if isinstance(path, QUrl):
+        return path.toLocalFile()
+    path = str(path)
+    if path.startswith('file:'):
+        return QUrl(path).toLocalFile()
+    return IO.generalizePath(path)
+
+
+# The library's caveat for a file without a resolution column merged with
+# files that have one, in the words of the user guide.
+_NO_RESOLUTION_WARNING = 'carry no q-resolution'
+_NO_RESOLUTION_MESSAGE = (
+    'the file has no q-resolution column while the other data of this experiment do; '
+    'its points are given a percentage (dq/q) resolution instead.'
+)
+
+
+def _user_warning_text(message) -> str:
+    """The library's warning text, reworded for the dialog where it names internals."""
+    text = str(message)
+    if _NO_RESOLUTION_WARNING in text:
+        return _NO_RESOLUTION_MESSAGE
+    return text
+
+
 # Spin channels accepted by the polarized import, in canonical order.
 _CHANNELS = ('pp', 'pm', 'mp', 'mm')
 
@@ -118,40 +150,67 @@ def appendToCurrent(self, paths) -> None:
         are merged into the current experiment and keep their own resolution,
         so the fit smears each point with the width it was measured with.
 
+        `paths` is a list of `QUrl` (a QML file dialog's `selectedFiles`), file
+        URLs or local paths.
+
         A file that cannot be added (a polarized experiment, a file holding
-        several datasets, a parse error) is reported through `loadFailed` and
-        skipped; the others are still added. A file without a resolution column
-        mixed with files that have one is added with an assumed resolution and
-        reported through `loadWarning`.
+        several datasets, a parse error) is skipped; the others are still added.
+        A file without a resolution column mixed with files that have one is
+        added with an assumed resolution. All refusals and caveats of one call
+        are reported together: through `loadFailed` when any file was refused,
+        otherwise through `loadWarning`.
         """
         paths = _from_qml(paths)
-        if isinstance(paths, str):
-            paths = paths.split(',')
+        if isinstance(paths, (str, QUrl)):
+            paths = paths.split(',') if isinstance(paths, str) else [paths]
 
+        failures = []
+        caveats = []
         q_range_changed = False
         for path in paths:
-            if not path:
+            if not path or (isinstance(path, QUrl) and path.isEmpty()):
                 continue
-            generalized = IO.generalizePath(str(path))
+            generalized = _local_path(path)
             name = os.path.basename(generalized)
+            # catch_warnings swaps the process-wide warning state; the Experimental
+            # data group is disabled while a fit runs, so no worker thread is
+            # warning concurrently when this is reached from the GUI.
             try:
                 with warnings.catch_warnings(record=True) as caught:
                     warnings.simplefilter('always')
                     changed = self._project_logic.append_to_current_experiment(generalized)
             except Exception as error:  # noqa: BLE001 - any refusal reaches the user, not the event loop
                 console.error(f'Adding {generalized} to the current experiment failed: {error}')
-                self.loadFailed.emit(f'{name}: {error}')
+                failures.append(f'{name}: {error}')
                 continue
             for caught_warning in caught:
                 if issubclass(caught_warning.category, UserWarning):
                     console.info(f'{name}: {caught_warning.message}')
-                    self.loadWarning.emit(f'{name}: {caught_warning.message}')
+                    caveats.append(f'{name}: {_user_warning_text(caught_warning.message)}')
+                else:
+                    # Not meant for the user (e.g. deprecations): hand it back to
+                    # the normal warning machinery instead of swallowing it.
+                    warnings.warn_explicit(
+                        caught_warning.message,
+                        caught_warning.category,
+                        caught_warning.filename,
+                        caught_warning.lineno,
+                    )
             if changed:
                 q_range_changed = True
             self.experimentChanged.emit()
             self.externalExperimentChanged.emit()
         if q_range_changed:
             self.qRangeUpdated.emit()
+        # One message per call: the GUI shows a single dialog, so per-file
+        # emissions would leave only the last one visible.
+        if failures:
+            message = '\n'.join(failures)
+            if caveats:
+                message += '\n\nAdded with a warning:\n' + '\n'.join(caveats)
+            self.loadFailed.emit(message)
+        elif caveats:
+            self.loadWarning.emit('\n'.join(caveats))
 
     @Slot('QVariant', result='QVariantList')
     def suggestPolarizedChannels(self, paths) -> list:
 
@@ -450,6 +450,8 @@ def prepare_threaded_sample(self, minimizers_logic: 'Minimizers') -> 'MultiFitte
         :return: The fitter, or None when sampling cannot start.
         """
         try:
+            # `prepare_sample` refuses the same cases (FitScopeError, reported
+            # below); these checks stay for the GUI wording ("tick Fit ...").
             if not self._ordered_experiments():
                 self._fail_before_start('No experiments to sample')
                 return None
 
@@ -1514,6 +1514,10 @@ def _get_aligned_analysis_values(self, experiment_index: int, channel: str = '')
         # The curve the fit compares these points to: smeared with the
         # resolution the dataset (or spin channel) was measured with, not the
         # model's. They differ for every dataset of a model but the first.
+        # Evaluated on all measured q and masked afterwards: a per-point
+        # (Pointwise) resolution is exact only on its own q array, and a merged
+        # dataset can hold one q twice with different widths, which a subset
+        # would interpolate to the same width.
         resolution_function = getattr(exp_data, 'resolution_function', None)
         if model_index is None:
             calc_data = None
@@ -1523,21 +1527,21 @@ def _get_aligned_analysis_values(self, experiment_index: int, channel: str = '')
             # the measured points alone rather than another channel's curve.
             try:
                 calc_data = self._project_lib.model_data_for_model_at_index(
-                    model_index, q_filtered, channel=channel, resolution_function=resolution_function
+                    model_index, q_values, channel=channel, resolution_function=resolution_function
                 )
             except Exception as exception:  # noqa: BLE001 - any backend refusal means "no curve"
                 console.debug(f'No calculated curve for channel {channel}: {exception}')
                 calc_data = None
         else:
             calc_data = self._project_lib.model_data_for_model_at_index(
-                model_index, q_filtered, resolution_function=resolution_function
+                model_index, q_values, resolution_function=resolution_function
             )
 
         calc_values = np.asarray(getattr(calc_data, 'y', np.empty(0)), dtype=float)
         calc_q_values = np.asarray(getattr(calc_data, 'x', np.empty(0)), dtype=float)
         has_calculated = True
-        if calc_values.size == q_filtered.size and calc_values.size > 0:
-            calculated_filtered = calc_values
+        if calc_values.size == q_values.size and calc_values.size > 0:
+            calculated_filtered = calc_values[q_mask]
         elif calc_q_values.size == calc_values.size and calc_values.size > 1:
             # Calculated on its own q grid: interpolate onto the measured q.
             calculated_filtered = np.interp(q_filtered, calc_q_values, calc_values)
@@ -1547,9 +1551,9 @@ def _get_aligned_analysis_values(self, experiment_index: int, channel: str = '')
             # report "no curve" so plots and residuals leave it out.
             if calc_values.size:
                 self._warn_once(
-                    ('misaligned', experiment_index, channel, calc_values.size, q_filtered.size),
+                    ('misaligned', experiment_index, channel, calc_values.size, q_values.size),
                     f'Calculated curve for experiment {experiment_index} has {calc_values.size} values '
-                    f'for {q_filtered.size} measured points and no q to align them; it is not shown.',
+                    f'for {q_values.size} measured points and no q to align them; it is not shown.',
                 )
             has_calculated = False
             calculated_filtered = np.full(q_filtered.size, np.nan)
 
@@ -383,14 +383,22 @@ EaComponents.ApplicationWindow {
         enabled: target !== null
         ignoreUnknownSignals: true
         function onLoadFailed(message) {
-            engineRejectionDialog.title = qsTr("Cannot import the data")
-            engineRejectionDialog.message = message
-            engineRejectionDialog.open()
+            showLoadMessage(qsTr("Cannot import the data"), message)
         }
         // Imported, but with an assumption the user should know about (e.g. a
         // file without a resolution column merged with files that have one).
         function onLoadWarning(message) {
-            engineRejectionDialog.title = qsTr("Data imported with a warning")
+            showLoadMessage(qsTr("Data imported with a warning"), message)
+        }
+        // An import of several files reports file by file: add to a dialog
+        // that is still open rather than replacing what it shows, and keep
+        // its first title (a refusal outranks a later warning).
+        function showLoadMessage(title, message) {
+            if (engineRejectionDialog.visible) {
+                engineRejectionDialog.message += '\n\n' + message
+                return
+            }
+            engineRejectionDialog.title = title
             engineRejectionDialog.message = message
             engineRejectionDialog.open()
         }
 
@@ -57,6 +57,28 @@ def test_each_dataset_is_drawn_with_its_own_resolution(self, qcore_application,
             expected = project.model_data_for_experiment_at_index(index, q_range=q).y
             np.testing.assert_allclose(drawn, expected, rtol=1e-12)
 
+    def test_a_narrowed_q_range_keeps_the_widths_of_overlapping_measurements(self, qcore_application, tmp_path):
+        # Two measurements of one contrast on the same q grid with very different
+        # widths: the merged dataset holds every q twice. Restricting the q range
+        # must not change the curve at the points that remain.
+        q = np.array([0.01, 0.03, 0.05, 0.08, 0.10, 0.15, 0.20, 0.25, 0.30])
+        project = Project()
+        project.default_model()
+        project.load_new_experiment(_write_file(tmp_path / 'sharp.txt', q, 0.002))
+        project.append_to_experiment_at_index(0, _write_file(tmp_path / 'broad.txt', q, 0.08))
+        merged = project.experiments[0]
+        full = np.asarray(project.model_data_for_experiment_at_index(0).y)
+        project.q_min = 0.03
+        project.q_max = 0.25
+        plotting = Plotting1d(project_lib=project, parent=None)
+
+        points = plotting._get_aligned_analysis_values(0)
+
+        x = np.asarray(merged.x)
+        mask = (x >= 0.03) & (x <= 0.25)
+        np.testing.assert_allclose([point['q'] for point in points], x[mask])
+        np.testing.assert_allclose([point['calculated'] for point in points], full[mask], rtol=1e-12)
+
     def test_the_second_dataset_is_not_drawn_with_the_models_resolution(self, qcore_application, tmp_path):
         project = two_datasets_on_one_model(tmp_path)
         plotting = Plotting1d(project_lib=project, parent=None)
@@ -221,6 +243,84 @@ def test_a_failing_file_is_reported_and_the_others_still_load(self, qcore_applic
         assert len(failures) == 1 and failures[0].startswith('missing.txt:')
         assert project.experiments[0].x.size == 2 * q.size
 
+    def test_files_from_the_qml_dialog_are_added(self, qcore_application, tmp_path):
+        # A QML FileDialog's selectedFiles reaches the slot as a list of QUrl;
+        # names with spaces, commas and non-ASCII characters must survive.
+        from PySide6.QtCore import QUrl
+
+        project = Project()
+        project.default_model()
+        q = np.linspace(0.01, 0.2, 10)
+        project.load_new_experiment(_write_file(tmp_path / 'first.txt', q, 0.01))
+        backend = self._backend(project)
+        failures = []
+        backend.loadFailed.connect(failures.append)
+        names = ['angle 2, run 7.txt', 'Messung ß µ.txt']
+        urls = [
+            QUrl.fromLocalFile(str(_write_file(tmp_path / name, q + 0.001 * (i + 1), 0.02)))
+            for i, name in enumerate(names)
+        ]
+
+        backend.appendToCurrent(urls)
+
+        assert failures == []
+        assert project.experiments[0].x.size == 3 * q.size
+
+    def test_a_file_url_string_is_added(self, qcore_application, tmp_path):
+        from PySide6.QtCore import QUrl
+
+        project = Project()
+        project.default_model()
+        q = np.linspace(0.01, 0.2, 10)
+        project.load_new_experiment(_write_file(tmp_path / 'first.txt', q, 0.01))
+        backend = self._backend(project)
+        failures = []
+        backend.loadFailed.connect(failures.append)
+        url = QUrl.fromLocalFile(str(_write_file(tmp_path / 'with space.txt', q + 0.001, 0.02))).toString()
+
+        backend.appendToCurrent([url])
+
+        assert failures == []
+        assert project.experiments[0].x.size == 2 * q.size
+
+    def test_refusals_and_warnings_of_one_call_are_reported_together(self, qcore_application, tmp_path):
+        # The GUI shows one dialog: per-file emissions would leave only the last visible.
+        project = Project()
+        project.default_model()
+        q = np.linspace(0.01, 0.2, 10)
+        project.load_new_experiment(_write_file(tmp_path / 'first.txt', q, 0.01))
+        backend = self._backend(project)
+        failures, cautions = [], []
+        backend.loadFailed.connect(failures.append)
+        backend.loadWarning.connect(cautions.append)
+
+        backend.appendToCurrent(
+            [
+                str(tmp_path / 'missing_a.txt'),
+                str(self._three_column(tmp_path / 'plain.txt', q + 0.005)),
+                str(tmp_path / 'missing_b.txt'),
+            ]
+        )
+
+        assert cautions == []
+        assert len(failures) == 1
+        assert 'missing_a.txt:' in failures[0] and 'missing_b.txt:' in failures[0]
+        assert 'plain.txt:' in failures[0]
+
+    def test_the_warning_is_worded_for_the_user(self, qcore_application, tmp_path):
+        project = Project()
+        project.default_model()
+        q = np.linspace(0.01, 0.2, 10)
+        project.load_new_experiment(_write_file(tmp_path / 'measured.txt', q, 0.01))
+        backend = self._backend(project)
+        cautions = []
+        backend.loadWarning.connect(cautions.append)
+
+        backend.appendToCurrent([str(self._three_column(tmp_path / 'plain.txt', q + 0.005))])
+
+        assert len(cautions) == 1
+        assert 'PercentageFwhm' not in cautions[0] and cautions[0].count('plain.txt') == 1
+
     def test_appending_to_a_polarized_experiment_is_refused(self, qcore_application, tmp_path):
         from easyreflectometry.data import DataSet1D
         from easyreflectometry.data import PolarizedDataSet