darfix 4.2.0__py3-none-any.whl → 4.3.0__py3-none-any.whl

orangecontrib/darfix/widgets/{datasetWidgetBase.py → dataset_widget_base.py}

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
+from ewoksorange.gui.owwidgets.threaded import OWEwoksWidgetOneThread
 from silx.gui import qt
 
 from darfix import dtypes
@@ -27,6 +27,8 @@ class DatasetWidgetBase(OWEwoksWidgetOneThread, openclass=True):
         self.task_executor.finished.connect(self.__onFinishTask)
         self.task_executor.started.connect(self.__onStartEwoksTask)
 
+        self.__widgetToDisableWhenRunning = self.mainArea
+
         self.__datasetMenu: qt.QMenu = self.menuBar().addMenu("&Dataset")
 
         loadAction = self.__datasetMenu.addAction("Load")
@@ -65,12 +67,22 @@ class DatasetWidgetBase(OWEwoksWidgetOneThread, openclass=True):
             self.setDataset(dataset)
 
     def __onFinishTask(self):
-        if self.mainArea is not None:
-            self.mainArea.setEnabled(True)
+        if self.__widgetToDisableWhenRunning is not None:
+            self.__widgetToDisableWhenRunning.setEnabled(True)
 
     def __onStartEwoksTask(self):
-        if self.mainArea is not None:
-            self.mainArea.setDisabled(True)
+        if self.__widgetToDisableWhenRunning is not None:
+            self.__widgetToDisableWhenRunning.setDisabled(True)
 
     def getDatasetMenu(self) -> qt.QMenu:
         return self.__datasetMenu
+
+    def setWidgetToDisableWhenRunning(self, widget: qt.QWidget | None):
+        """
+        Set Widget to disable when a task is running.
+
+        Set to `None` if nothing to disable.
+
+        Default widget is `self.mainArea`
+        """
+        self.__widgetToDisableWhenRunning = widget

orangecontrib/darfix/widgets/dimensions.py

@@ -4,7 +4,7 @@ import logging
 from typing import Any
 
 from ewokscore.missing_data import is_missing_data
-from ewoksorange.gui.parameterform import block_signals
+from ewoksorange.gui.widgets.parameter_form import block_signals
 from silx.gui import qt
 
 from darfix import dtypes
@@ -12,11 +12,11 @@ from darfix.core.dataset import ImageDataset
 from darfix.core.dimension import Dimension
 from darfix.core.dimension import find_dimensions_from_metadata
 from darfix.core.fscan_parser import fscan_get_dimensions
-from darfix.gui.dimensionsWidget import DimensionItem
-from darfix.gui.dimensionsWidget import DimensionWidget
-from darfix.tasks.dimensiondefinition import DimensionDefinition
-from darfix.tasks.dimensiondefinition import get_dimensions_error
-from orangecontrib.darfix.widgets.datasetWidgetBase import DatasetWidgetBase
+from darfix.gui.dimensions_widget import DimensionItem
+from darfix.gui.dimensions_widget import DimensionWidget
+from darfix.tasks.dimension_definition import DimensionDefinition
+from darfix.tasks.dimension_definition import get_dimensions_error
+from orangecontrib.darfix.widgets.dataset_widget_base import DatasetWidgetBase
 
 _logger = logging.getLogger(__file__)
 

orangecontrib/darfix/widgets/grainplot.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 from darfix import dtypes
 from darfix.core.grainplot import GrainPlotMaps
-from darfix.gui.grainplot.grainPlotWidget import GrainPlotWidget
-from darfix.tasks.grainplot import GrainPlot
-from orangecontrib.darfix.widgets.datasetWidgetBase import DatasetWidgetBase
+from darfix.gui.grain_plot.grain_plot_widget import GrainPlotWidget
+from darfix.tasks.grain_plot import GrainPlot
+from orangecontrib.darfix.widgets.dataset_widget_base import DatasetWidgetBase
 
 
 class GrainPlotWidgetOW(DatasetWidgetBase, ewokstaskclass=GrainPlot):

orangecontrib/darfix/widgets/hdf5dataselection.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
-from functools import partial
 from typing import Any
 
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
+from ewoksorange.gui.owwidgets.threaded import OWEwoksWidgetOneThread
 from silx.gui import qt
 
+from darfix.core.data_selection import get_default_output_directory
 from darfix.gui.data_selection.scan_selection_widgets import ScanSelectionWidget
 from darfix.gui.data_selection.scan_selection_widgets import (
     ScanSelectionWidgetWithPositioners,
 )
+from darfix.gui.data_selection.working_dir_selection_widget import (
+    WorkingDirSelectionWidget,
+)
 from darfix.gui.utils.message import show_error_msg
 from darfix.tasks.hdf5_data_selection import HDF5DataSelection
 
@@ -59,8 +62,8 @@ class HDF5DataSelectionWidgetOW(
         layout.addWidget(self._darkDataGroup)
 
         workingDirLayout = qt.QFormLayout()
-        self._workingDirLineEdit = qt.QLineEdit()
-        workingDirLayout.addRow("Working directory", self._workingDirLineEdit)
+        self._workingDirSelection = WorkingDirSelectionWidget()
+        workingDirLayout.addRow("Working directory", self._workingDirSelection)
         self._workflowTitleLineEdit = qt.QLineEdit()
         workingDirLayout.addRow("Workflow title", self._workflowTitleLineEdit)
         layout.addLayout(workingDirLayout)
@@ -76,14 +79,22 @@ class HDF5DataSelectionWidgetOW(
         self._loadInputs(self.get_task_input_values())
 
         # connect signal / slot
-        self.task_executor.finished.connect(
-            self.information,
-        )
-        self.task_executor.finished.connect(lambda: self.mainArea.setEnabled(True))
-        self.task_executor.started.connect(
-            partial(self.information, "Downloading dataset. This can take a while...")
+        self.task_executor.finished.connect(self._onTaskFinished)
+        self.task_executor.started.connect(self._onTaskStarted)
+        self._rawDataSelection.sigNewFileSelected.connect(self._onNewFileSelected)
+
+    def _onNewFileSelected(self):
+        self._workingDirSelection.setDefaultDir(
+            get_default_output_directory(self._rawDataSelection.getFilePath())
         )
-        self.task_executor.started.connect(lambda: self.mainArea.setDisabled(True))
+
+    def _onTaskStarted(self):
+        self.information("Downloading dataset. This can take a while...")
+        self.mainArea.setDisabled(True)
+
+    def _onTaskFinished(self):
+        self.information()
+        self.mainArea.setEnabled(True)
 
     def task_output_changed(self) -> None:
         if self.task_succeeded:
@@ -101,6 +112,7 @@ class HDF5DataSelectionWidgetOW(
         rawDetectorDataPath = taskInputValues.get("raw_detector_data_path")
         if rawDetectorDataPath:
             self._rawDataSelection.setDetectorPath(rawDetectorDataPath)
+            self._onNewFileSelected()
 
         rawMetadataPath = taskInputValues.get("raw_metadata_path")
         if rawMetadataPath:
@@ -118,7 +130,7 @@ class HDF5DataSelectionWidgetOW(
 
         treatedDataDir = taskInputValues.get("treated_data_dir")
         if treatedDataDir is not None:
-            self._workingDirLineEdit.setText(treatedDataDir)
+            self._workingDirSelection.setDir(treatedDataDir)
 
         workflowTitle = taskInputValues.get("workflow_title")
         if workflowTitle is not None:
@@ -138,10 +150,10 @@ class HDF5DataSelectionWidgetOW(
                 "dark_detector_data_path": self._darkDataSelection.getDetectorPath(),
             }
 
-        if self._workingDirLineEdit.text():
+        if self._workingDirSelection.getDir():
             inputs = {
                 **inputs,
-                "treated_data_dir": self._workingDirLineEdit.text(),
+                "treated_data_dir": self._workingDirSelection.getDir(),
             }
 
         if self._workflowTitleLineEdit.text():
@@ -161,7 +173,15 @@ class HDF5DataSelectionWidgetOW(
             self.set_default_input(key, value)
 
     def _executeTask(self):
+        rawDataSelectionInvalid = not self._rawDataSelection.validateSelection()
+        darkDataSelectionInvalid = (
+            self._darkDataGroup.isChecked()
+            and not self._darkDataSelection.validateSelection()
+        )
         self.saveInputs()
+        if rawDataSelectionInvalid or darkDataSelectionInvalid:
+            show_error_msg("One of the inputs of the form is invalid.")
+            return
         self.execute_ewoks_task()
 
     def closeEvent(self, *a, **kw):

orangecontrib/darfix/widgets/metadata.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
+from ewoksorange.gui.owwidgets.threaded import OWEwoksWidgetOneThread
 
 from darfix import dtypes
-from darfix.gui.metadataWidget import MetadataWidget
+from darfix.gui.metadata_widget import MetadataWidget
 from darfix.tasks.metadata import MetadataTask
 
 

orangecontrib/darfix/widgets/noiseremoval.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from darfix.core.noiseremoval import clean_operation_dict
-from darfix.gui.noiseremoval.noise_removal_widget import NoiseRemovalWidget
-from darfix.tasks.noiseremoval import NoiseRemoval
-from orangecontrib.darfix.widgets.operationWidgetBase import OperationWidgetBase
+from darfix.core.noise_removal import clean_operation_dict
+from darfix.gui.noise_removal.noise_removal_widget import NoiseRemovalWidget
+from darfix.tasks.noise_removal import NoiseRemoval
+from orangecontrib.darfix.widgets.operation_widget_base import OperationWidgetBase
 
 
 class NoiseRemovalWidgetOW(OperationWidgetBase, ewokstaskclass=NoiseRemoval):

orangecontrib/darfix/widgets/{operationWidgetBase.py → operation_widget_base.py}

@@ -5,8 +5,8 @@ from silx.gui import qt
 from darfix import dtypes
 from darfix.core.utils import OperationAborted
 from darfix.gui.utils.message import missing_dataset_msg
-from darfix.gui.utils.standardButtonBox import StandardButtonBox
-from orangecontrib.darfix.widgets.datasetWidgetBase import DatasetWidgetBase
+from darfix.gui.utils.standard_buttonbox import StandardButtonBox
+from orangecontrib.darfix.widgets.dataset_widget_base import DatasetWidgetBase
 
 
 class OperationWidgetBase(DatasetWidgetBase, openclass=True):

orangecontrib/darfix/widgets/pca.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 from ewokscore.missing_data import is_missing_data
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
+from ewoksorange.gui.owwidgets.threaded import OWEwoksWidgetOneThread
 
 from darfix.dtypes import Dataset
-from darfix.gui.PCAWidget import PCAPlot
+from darfix.gui.pca_widget import PCAPlot
 from darfix.tasks.pca import PCA
 
 

orangecontrib/darfix/widgets/projection.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
+from ewoksorange.gui.owwidgets.threaded import OWEwoksWidgetOneThread
 
 from darfix.dtypes import Dataset
-from darfix.gui.projectionWidget import ProjectionWidget
+from darfix.gui.projection_widget import ProjectionWidget
 from darfix.tasks.projection import Projection
 
 

orangecontrib/darfix/widgets/rockingcurves.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from darfix import dtypes
-from darfix.gui.rocking_curves.rockingCurvesWidget import RockingCurvesWidget
+from darfix.gui.rocking_curves.rocking_curves_widget import RockingCurvesWidget
 from darfix.tasks.rocking_curves import RockingCurves
-from orangecontrib.darfix.widgets.datasetWidgetBase import DatasetWidgetBase
+from orangecontrib.darfix.widgets.dataset_widget_base import DatasetWidgetBase
 
 
 class RockingCurvesWidgetOW(DatasetWidgetBase, ewokstaskclass=RockingCurves):
@@ -17,6 +17,8 @@ class RockingCurvesWidgetOW(DatasetWidgetBase, ewokstaskclass=RockingCurves):
     def __init__(self):
         super().__init__()
 
+        self.setWidgetToDisableWhenRunning(None)
+
         self._widget = RockingCurvesWidget(parent=self)
         self._widget.sigFitClicked.connect(self._launch_fit)
         self.mainArea.layout().addWidget(self._widget)
@@ -27,6 +29,7 @@ class RockingCurvesWidgetOW(DatasetWidgetBase, ewokstaskclass=RockingCurves):
         if method is not None:
             self._widget.setFitMethod(method)
         self.datasetChanged.connect(self._onDatasetChanged)
+        self._widget.sigAbortClicked.connect(self.cancel_running_task)
 
     def _onDatasetChanged(self, dataset: dtypes.Dataset):
         self._widget.setDataset(dataset)

orangecontrib/darfix/widgets/roiselection.py

@@ -1,29 +1,15 @@
 from __future__ import annotations
 
-import logging
-from enum import Enum
-
 import numpy
 from ewokscore.missing_data import is_missing_data
 
 from darfix import dtypes
-from darfix.gui.roiSelectionWidget import ROISelectionWidget
+from darfix.gui.roi_selection_widget import ROISelectionWidget
 from darfix.tasks.roi import RoiSelection
-from orangecontrib.darfix.widgets.datasetWidgetBase import DatasetWidgetBase
-
-_logger = logging.getLogger(__name__)
-
-
-class _ROIBehavior(Enum):
-    """Define the different behavior we can have regarding ROI"""
-
-    FIT_TO_DATASET = "fit-to-dataset"
-    """When a ROI is applied we want to update the ROI to the shape to show the user that the ROI has been applied"""
-    PROPOSE_USER_ROI = "propose-ROI-to-user"
-    """When a new dataset is set (or when resetting) we want to propose to the user a subset of the frame (one fifth of the current frame shape)"""
+from orangecontrib.darfix.widgets.operation_widget_base import OperationWidgetBase
 
 
-class RoiSelectionWidgetOW(DatasetWidgetBase, ewokstaskclass=RoiSelection):
+class RoiSelectionWidgetOW(OperationWidgetBase, ewokstaskclass=RoiSelection):
     name = "roi selection"
     icon = "icons/roi.png"
     want_main_area = True
@@ -34,85 +20,34 @@ class RoiSelectionWidgetOW(DatasetWidgetBase, ewokstaskclass=RoiSelection):
     def __init__(self):
         super().__init__()
 
-        self._widget = ROISelectionWidget(parent=self)
-        self.mainArea.layout().addWidget(self._widget)
-        self._widget.sigApply.connect(self._updateActiveDataset)
-        self._widget.sigValidate.connect(self._validateResult)
-        self._widget.sigReset.connect(self._reset)
-
-        self._update_dataset: dtypes.Dataset = None
-        """Dataset updated when the users press 'apply'"""
-        self._dataset: dtypes.Dataset = None
-        """Original input dataset"""
-
-        self._nextRoiInteractionBehavior: _ROIBehavior = _ROIBehavior.PROPOSE_USER_ROI
-        """When a new output is received we want either to:
-        * propose a ROI fitting the dataset shape (if a ROI - subset of the dataset - has been applied)
-        * propose a ROI on a subset of the dataset (in the case a new dataset has been received)
-        """
+        # Connect Signals / Slots
 
         self.datasetChanged.connect(self.onDatasetChanged)
+        self.sigOperationApplied.connect(self.onRoiApplied)
 
-    def _validateResult(self):
-        self._nextRoiInteractionBehavior = _ROIBehavior.PROPOSE_USER_ROI
-        self.propagate_downstream()
-        self.accept()
+    def createMainWidget(self, default_inputs: dict) -> ROISelectionWidget:
+        widget = ROISelectionWidget()
+        return widget
 
-    def onDatasetChanged(self, dataset: dtypes.Dataset):
+    def saveMainWidget(self) -> dict:
+        self.set_default_input(
+            "roi_origin", tuple(self.mainWidget.getRoi().getOrigin())
+        )
+        self.set_default_input("roi_size", tuple(self.mainWidget.getRoi().getSize()))
 
-        self._dataset = self._update_dataset = dataset
+    @property
+    def mainWidget(self) -> ROISelectionWidget:
+        return super().mainWidget
 
-        self._widget.setDataset(dataset)
-        self._nextRoiInteractionBehavior = _ROIBehavior.PROPOSE_USER_ROI
+    def onRoiApplied(self, newDataset: dtypes.Dataset):
+        self.mainWidget.setDataset(newDataset, roiEnabled=False)
 
+    def onDatasetChanged(self, dataset: dtypes.Dataset):
+        self.mainWidget.setDataset(dataset)
         if not self._tryRecoverLastRoi():
-            self._resetTaskAndROI(dataset=dataset)
-
-    def _updateActiveDataset(self):
-
-        self._widget.clampRoiToDataset(self._update_dataset.dataset)
-        roi = self._widget.getRoi()
-
-        self.set_default_input("roi_origin", roi.getOrigin().tolist())
-        self.set_default_input("roi_size", roi.getSize().tolist())
-        self._nextRoiInteractionBehavior = _ROIBehavior.FIT_TO_DATASET
-        self.execute_ewoks_task_without_propagation()
-        self._widget.enableApplyingROI(False)
-
-    def _updateROI(self):
-        if self._nextRoiInteractionBehavior is _ROIBehavior.FIT_TO_DATASET:
-            # Apply
-            self._widget.enableValidation(True)
-            self._widget._fitROIToDataset(self._update_dataset.dataset)
-        elif self._nextRoiInteractionBehavior is _ROIBehavior.PROPOSE_USER_ROI:
-            # Reset
-            self._widget.enableValidation(False)
-            self._widget._setROIForNewDataset(self._update_dataset.dataset)
+            self.mainWidget.setROIForNewDataset(dataset.dataset)
         else:
-            raise NotImplementedError(
-                f"Behavior not defined ({self._nextRoiInteractionBehavior})"
-            )
-
-    def task_output_changed(self):
-        super().task_output_changed()
-        self._update_dataset = self.get_task_output_value("dataset")
-
-        if is_missing_data(self._update_dataset):
-            _logger.error("Roi application failed (or cancelled)")
-            return
-
-        self._updateROI()
-
-        self._widget.setStack(self._update_dataset.dataset)
-        # update the input dataset for next iteration
-        self.set_dynamic_input("dataset", self._update_dataset)
-
-    def _reset(self):
-        self._update_dataset = self._dataset
-
-        self._nextRoiInteractionBehavior = _ROIBehavior.PROPOSE_USER_ROI
-        self._widget.setDataset(self._update_dataset)
-        self._resetTaskAndROI(dataset=self._update_dataset)
+            self.mainWidget.clampRoiToDataset(dataset.dataset)
 
     def _tryRecoverLastRoi(self) -> bool:
         """Look at saved default input in .ows and try propose the roi on the current dataset."""
@@ -129,23 +64,6 @@ class RoiSelectionWidgetOW(DatasetWidgetBase, ewokstaskclass=RoiSelection):
 
         origin = numpy.array(origin)
         size = numpy.array(size)
-        self._widget.setRoi(size=size, origin=origin)
-        self._widget.enableValidation(False)
-        self._widget.enableApplyingROI(True)
-        return True
+        self.mainWidget.setRoi(size=size, origin=origin)
 
-    def _resetTaskAndROI(self, dataset: dtypes.Dataset):
-        """
-        Reset the original dataset (last dataset received) and the ROI.
-
-        When receiving a new dataset or resetting it, we need to process the task to
-        retrieve the task output dataset when the user presses ok.
-        To speed up process in this specific case (ROI match frame shape), the task will simply propagate the original dataset.
-        """
-        self.set_default_input("roi_origin", (0, 0))
-        self.set_default_input("roi_size", dataset.dataset.frame_shape)
-        self.set_dynamic_input("dataset", dataset)
-        self.execute_ewoks_task_without_propagation()
-
-        self._widget.enableValidation(False)
-        self._widget.enableApplyingROI(True)
+        return True

orangecontrib/darfix/widgets/rsmhistogram.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import numpy
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
+from ewoksorange.gui.owwidgets.threaded import OWEwoksWidgetOneThread
 
 from darfix.dtypes import Dataset
-from darfix.gui.rsmHistogramWidget import RSMHistogramWidget
+from darfix.gui.rsm_histogram_widget import RSMHistogramWidget
 from darfix.tasks.rsm_histogram import RSMHistogram
 
 

orangecontrib/darfix/widgets/shiftcorrection.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import numpy
 from silx.gui import qt
 
-from darfix.gui.shiftcorrection.shiftCorrectionWidget import ShiftCorrectionWidget
-from darfix.tasks.shiftcorrection import ShiftCorrection
-from orangecontrib.darfix.widgets.operationWidgetBase import OperationWidgetBase
+from darfix.gui.shift_correction.shift_correction_widget import ShiftCorrectionWidget
+from darfix.tasks.shift_correction import ShiftCorrection
+from orangecontrib.darfix.widgets.operation_widget_base import OperationWidgetBase
 
 
 class ShiftCorrectionWidgetOW(OperationWidgetBase, ewokstaskclass=ShiftCorrection):

orangecontrib/darfix/widgets/transformation.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 from typing import Any
 from typing import Dict
 
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
-from ewoksorange.gui.parameterform import block_signals
+from ewoksorange.gui.owwidgets.threaded import OWEwoksWidgetOneThread
+from ewoksorange.gui.widgets.parameter_form import block_signals
 from silx.gui import qt
 
 from darfix import dtypes
-from darfix.gui.magnificationWidget import MagnificationWidget
-from darfix.gui.rsmWidget import RSMWidget
+from darfix.gui.magnification_widget import MagnificationWidget
+from darfix.gui.rsm_widget import RSMWidget
 from darfix.tasks.transformation import TransformationMatrixComputation
 
 

orangecontrib/darfix/widgets/weakbeam.py

@@ -1,21 +1,15 @@
 import logging
-from typing import Optional
-
-from ewokscore.missing_data import MISSING_DATA
-from ewoksorange.bindings.owwidgets import OWEwoksWidgetOneThread
-from ewoksorange.gui.parameterform import block_signals
 
 from darfix import dtypes
-from darfix.gui.operationThread import OperationThread
-from darfix.gui.utils.message import missing_dataset_msg
-from darfix.gui.weakBeamWidget import WeakBeamWidget
-from darfix.tasks.weakbeam import WeakBeam
+from darfix.gui.weak_beam_widget import WeakBeamWidget
+from darfix.tasks.weak_beam import WeakBeam
+from orangecontrib.darfix.widgets.operation_widget_base import OperationWidgetBase
 
 _logger = logging.getLogger(__name__)
 
 
 class WeakBeamWidgetOW(
-    OWEwoksWidgetOneThread,
+    OperationWidgetBase,
     ewokstaskclass=WeakBeam,
 ):
     """
@@ -27,103 +21,26 @@ class WeakBeamWidgetOW(
     want_main_area = True
     want_control_area = False
 
-    _ewoks_inputs_to_hide_from_orange = ("nvalue", "indices", "title")
+    _ewoks_inputs_to_hide_from_orange = ("nvalue", "title")
 
     def __init__(self):
         super().__init__()
-        self._thread = None
-
-        self._widget = WeakBeamWidget(parent=self)
-        self.mainArea.layout().addWidget(self._widget)
-        nvalue = self.get_default_input_value("nvalue", MISSING_DATA)
-        if nvalue is not MISSING_DATA:
-            with block_signals(self._widget):
-                self._widget.nvalue = nvalue
-        else:
-            self.set_default_input("nvalue", self._widget.nvalue)
-
-        # connect signal / slot
-        self._widget.sigValidate.connect(self.execute_ewoks_task)
-        self._widget.sigApplyThreshold.connect(self._launch_recover_weak_beam)
-        self._widget.sigNValueChanged.connect(self._nValueChanged)
-
-    def setDataset(self, dataset: Optional[dtypes.Dataset], pop_up: bool = False):
-        if dataset is None:
-            return
-        if pop_up:
-            self.open()
-        self.set_dynamic_input("dataset", dataset=dataset)
-        # if some processing on-going with the previous dataset stop it.
-        self._stop_thread()
-
-    def _nValueChanged(self):
-        self.set_default_input("nvalue", self._widget.nvalue)
-
-    def handleNewSignals(self) -> None:
-        dataset = self.get_task_input_value("dataset", None)
-        if dataset is None:
-            return
-
-        self.setDataset(dataset=dataset, pop_up=True)
-
-        if isinstance(dataset, dtypes.Dataset):
-            self.set_dynamic_input("indices", dataset.indices)
-            title = dataset.dataset.title
-            self.set_default_input(
-                "title",
-                title if title is not None else MISSING_DATA,
-            )
-
-        # warning: do not call to make sure the processing is not triggered
-        # return super().handleNewSignals()
-
-    def task_output_changed(self) -> None:
-        dataset = self.get_task_output_value("dataset", MISSING_DATA)
-        self.setDataset(dataset)
-
-    def _launch_recover_weak_beam(self):
-        """callback when the user modify the 'nvalue'"""
-        if self._thread is not None:
-            _logger.warning("recover weak beam already on going")
-
-        dataset = self.get_task_input_value("dataset", None)
-        if dataset is None:
-            missing_dataset_msg()
-            return
-        if not isinstance(dataset, dtypes.Dataset):
-            raise dtypes.DatasetTypeError(dataset)
+        self.sigOperationApplied.connect(self.__onOperationApplied)
+        self.buttons.resetButton.hide()
 
-        self._widget.setProcessingButtonsEnabled(False)
-        nvalue = self.get_task_input_value("nvalue", MISSING_DATA)
-        # FIXME: all processing should be in done in a ewoks task. See https://gitlab.esrf.fr/XRD/darfix/-/issues/130
-        self._thread = OperationThread(self, dataset.dataset.recover_weak_beam)
-        self._thread.setArgs(
-            n=nvalue,
-            indices=dataset.indices,
-        )
-        self._thread.finished.connect(self._recover_weak_beam_finished)
-        self._thread.start()
+    def createMainWidget(self, default_inputs: dict) -> WeakBeamWidget:
+        widget = WeakBeamWidget()
+        widget.nvalue = default_inputs.get("nvalue", 1.0)
+        return widget
 
-    def _stop_thread(self):
-        if self._thread is not None:
-            self._thread.finished.disconnect(self._recover_weak_beam_finished)
-        self._thread = None
-        self._widget.setProcessingButtonsEnabled(True)
+    def saveMainWidget(self) -> dict:
+        self.set_default_input("nvalue", self.mainWidget.nvalue)
 
-    def _recover_weak_beam_finished(self):
-        sender = self.sender()
-        dataset = self._thread.data
-        self._stop_thread()
+    def __onOperationApplied(self, dataset: dtypes.Dataset):
+        self.mainWidget.updateDataset(dataset)
+        # this trick re-enable button apply directly
+        self.reset()
 
-        if dataset in (None, MISSING_DATA):
-            raise RuntimeError("An exception occured when trying to recover weakbeam")
-        assert isinstance(
-            dataset, dtypes.ImageDataset
-        ), f"dataset is expected to be an instance of {dtypes.ImageDataset}. Get {type(dataset)}"
-        self._widget.setResult(
-            center_of_mass=dataset.apply_moments(indices=sender.kwargs["indices"])[0][
-                0
-            ],
-            transformation=dataset.transformation,
-        )
-        self._stop_thread()
+    @property
+    def mainWidget(self) -> WeakBeamWidget:
+        return super().mainWidget