mosamatic2 2.0.24__py3-none-any.whl

mosamatic2/ui/mainwindow.py

@@ -0,0 +1,426 @@
+import os
+import mosamatic2.constants as constants
+from PySide6.QtWidgets import (
+    QMainWindow,
+)
+from PySide6.QtGui import (
+    QGuiApplication,
+    QAction,
+    QIcon,
+)
+from PySide6.QtCore import Qt, QByteArray
+from mosamatic2.ui.utils import version, resource_path, is_macos
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.settings import Settings
+from mosamatic2.ui.widgets.panels.mainpanel import MainPanel
+from mosamatic2.ui.widgets.panels.logpanel import LogPanel
+from mosamatic2.ui.widgets.panels.tasks.rescaledicomimagestaskpanel import RescaleDicomImagesTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.segmentmusclefatl3tensorflowtaskpanel import SegmentMuscleFatL3TensorFlowTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.segmentmusclefatt4pytorchtaskpanel import SegmentMuscleFatT4PyTorchTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.createpngsfromsegmentationstaskpanel import CreatePngsFromSegmentationsTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.calculatescorestaskpanel import CalculateScoresTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.dicom2niftitaskpanel import Dicom2NiftiTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.segmentationnifti2numpytaskpanel import SegmentationNifti2NumpyTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.segmentationnumpy2niftitaskpanel import SegmentationNumpy2NiftiTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.createdicomsummarytaskpanel import CreateDicomSummaryTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.selectslicefromscanstaskpanel import SelectSliceFromScansTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.totalsegmentatortaskpanel import TotalSegmentatorTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.calculatemaskstatisticstaskpanel import CalculateMaskStatisticsTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.applythresholdtosegmentationstaskpanel import ApplyThresholdToSegmentationsTaskPanel
+from mosamatic2.ui.widgets.panels.pipelines.defaultpipelinepanel import DefaultPipelinePanel
+from mosamatic2.ui.widgets.panels.pipelines.defaultdockerpipelinepanel import DefaultDockerPipelinePanel
+from mosamatic2.ui.widgets.panels.pipelines.boadockerpipelinepanel import BoaDockerPipelinePanel
+from mosamatic2.ui.widgets.panels.pipelines.liveranalysispipelinepanel import LiverAnalysisPipelinePanel
+from mosamatic2.ui.widgets.panels.visualizations.slicevisualization.slicevisualization import SliceVisualization
+from mosamatic2.ui.widgets.panels.visualizations.sliceselectionvisualization.sliceselectionvisualization import SliceSelectionVisualization
+from mosamatic2.ui.widgets.panels.visualizations.liversegmentvisualization.liversegmentvisualization import LiverSegmentVisualization
+
+
+LOG = LogManager()
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super(MainWindow, self).__init__()
+        self._settings = None
+        self._main_panel = None
+        self._log_panel = None
+        self._decompress_dicom_files_task_panel = None
+        self._rescale_dicom_images_task_panel = None
+        self._segment_muscle_fat_l3_tensorflow_task_panel = None
+        self._segment_muscle_fat_t4_pytorch_task_panel = None
+        self._create_pngs_from_segmentations_task_panel = None
+        self._calculate_scores_task_panel = None
+        self._dicom2nifti_task_panel = None
+        self._segmentation_numpy_to_nifti_task_panel = None
+        self._segmentation_nifti_to_numpy_task_panel = None
+        self._create_dicom_summary_task_panel = None
+        self._select_slice_from_scans_task_panel = None
+        self._total_segmentator_task_panel = None
+        self._calculate_mask_statistics_task_panel = None
+        self._apply_threshold_to_segmentations_task_panel = None
+        self._default_pipeline_panel = None
+        self._default_docker_pipeline_panel = None
+        self._boa_docker_pipeline_panel = None
+        self._liver_analysis_pipeline_panel = None
+        self._slice_visualization = None
+        self._slice_selection_visualization = None
+        self._liver_segment_visualization = None
+        self.init_window()
+
+    def init_window(self):
+        self.setWindowTitle(f'{constants.MOSAMATIC2_WINDOW_TITLE} {version()}')
+        icon_file_name = constants.MOSAMATIC2_APP_ICON_FILE_NAME_MAC if is_macos() else constants.MOSAMATIC2_APP_ICON_FILE_NAME_WIN
+        icon_path = resource_path(os.path.join(constants.MOSAMATIC2_ICONS_DIR_PATH, icon_file_name))
+        self.setWindowIcon(QIcon(icon_path))
+        if not self.load_geometry_and_state():
+            self.set_default_size_and_position()
+        self.init_menus()
+        self.init_status_bar()
+        self.addDockWidget(Qt.DockWidgetArea.TopDockWidgetArea, self.main_panel())
+        self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.log_panel())
+
+    def init_menus(self):
+        self.init_app_menu()
+        self.init_tasks_menu()
+        self.init_pipelines_menu()
+        self.init_visualizations_menu()
+        if is_macos():            
+            self.menuBar().setNativeMenuBar(False)
+
+    def init_app_menu(self):
+        exit_action = QAction('Exit', self)
+        exit_action.triggered.connect(self.close)
+        app_menu = self.menuBar().addMenu('Application')
+        app_menu.addAction(exit_action)
+
+    def init_tasks_menu(self):
+        rescale_dicom_images_task_action = QAction('RescaleDicomImagesTask', self)
+        rescale_dicom_images_task_action.triggered.connect(self.handle_rescale_dicom_images_task_action)
+        segment_muscle_fat_l3_tensorflow_task_action = QAction('SegmentMuscleAndFatL3TensorFlowTask', self)
+        segment_muscle_fat_l3_tensorflow_task_action.triggered.connect(self.handle_segment_muscle_fat_l3_tensorflow_task_action)
+        segment_muscle_fat_t4_pytorch_task_action = QAction("SegmentMuscleFatT4PytorchTask", self)
+        segment_muscle_fat_t4_pytorch_task_action.triggered.connect(self.handle_segment_muscle_fat_t4_pytorch_task_action)
+        calculate_scores_task_action = QAction('CalculateScoresTask', self)
+        calculate_scores_task_action.triggered.connect(self.handle_calculate_scores_task_action)
+        create_pngs_from_segmentations_task_action = QAction('CreatePngsFromSegmentationsTask', self)
+        create_pngs_from_segmentations_task_action.triggered.connect(self.handle_create_pngs_from_segmentations_task_action)
+        dicom2nifti_task_action = QAction('Dicom2NiftiTask', self)
+        dicom2nifti_task_action.triggered.connect(self.handle_dicom2nifti_task_action)
+        segmentation_numpy_to_nifti_task_action = QAction('SegmentationNumpy2NiftiTask', self)
+        segmentation_numpy_to_nifti_task_action.triggered.connect(self.handle_segmentation_numpy_to_nifti_task_action)
+        segmentation_nifti_to_numpy_task_action = QAction('SegmentationNifti2NumpyTask', self)
+        segmentation_nifti_to_numpy_task_action.triggered.connect(self.handle_segmentation_nifti_to_numpy_task_action)
+        create_dicom_summary_task_action = QAction('CreateDicomSummaryTask', self)
+        create_dicom_summary_task_action.triggered.connect(self.handle_create_dicom_summary_task_action)
+        select_slice_from_scans_task_action = QAction('SelectSliceFromScansTask', self)
+        select_slice_from_scans_task_action.triggered.connect(self.handle_select_slice_from_scans_task_action)
+        total_segmentator_task_action = QAction('TotalSegmentatorTask', self)
+        total_segmentator_task_action.triggered.connect(self.handle_total_segmentator_task_action)
+        calculate_mask_statistics_task_action = QAction('CalculateMaskStatisticsTask', self)
+        calculate_mask_statistics_task_action.triggered.connect(self.handle_calculate_mask_statistics_task_action)
+        apply_threshold_to_segmentations_task_action = QAction('ApplyThresholdToSegmentationsTask', self)
+        apply_threshold_to_segmentations_task_action.triggered.connect(self.handle_apply_threshold_to_segmentations_task_action)
+        tasks_menu = self.menuBar().addMenu('Tasks')
+        tasks_menu.addAction(rescale_dicom_images_task_action)
+        tasks_menu.addAction(segment_muscle_fat_l3_tensorflow_task_action)
+        tasks_menu.addAction(segment_muscle_fat_t4_pytorch_task_action)
+        tasks_menu.addAction(calculate_scores_task_action)
+        tasks_menu.addAction(create_pngs_from_segmentations_task_action)
+        tasks_menu.addAction(dicom2nifti_task_action)
+        tasks_menu.addAction(segmentation_numpy_to_nifti_task_action)
+        tasks_menu.addAction(segmentation_nifti_to_numpy_task_action)
+        tasks_menu.addAction(create_dicom_summary_task_action)
+        tasks_menu.addAction(select_slice_from_scans_task_action)
+        tasks_menu.addAction(total_segmentator_task_action)
+        tasks_menu.addAction(calculate_mask_statistics_task_action)
+        tasks_menu.addAction(apply_threshold_to_segmentations_task_action)
+
+    def init_pipelines_menu(self):
+        default_pipeline_action = QAction('DefaultPipeline', self)
+        default_pipeline_action.triggered.connect(self.handle_default_pipeline_action)
+        default_docker_pipeline_action = QAction('DefaultDockerPipeline', self)
+        default_docker_pipeline_action.triggered.connect(self.handle_default_docker_pipeline_action)
+        boa_docker_pipeline_action = QAction('BoaDockerPipeline', self)
+        boa_docker_pipeline_action.triggered.connect(self.handle_boa_docker_pipeline_action)
+        liver_analysis_pipeline_action = QAction('LiverAnalysisPipeline', self)
+        liver_analysis_pipeline_action.triggered.connect(self.handle_liver_analysis_pipeline_action)
+        pipelines_menu = self.menuBar().addMenu('Pipelines')
+        pipelines_menu.addAction(default_pipeline_action)
+        pipelines_menu.addAction(default_docker_pipeline_action)
+        pipelines_menu.addAction(boa_docker_pipeline_action)
+        pipelines_menu.addAction(liver_analysis_pipeline_action)
+
+    def init_visualizations_menu(self):
+        slice_visualization_action = QAction('SliceVisualization', self)
+        slice_visualization_action.triggered.connect(self.handle_slice_visualization_action)
+        slice_selection_visualization_action = QAction('SliceSelectionVisualization', self)
+        slice_selection_visualization_action.triggered.connect(self.handle_slice_selection_visualization_action)
+        liver_segment_visualization_action = QAction('LiverSegmentVisualization', self)
+        liver_segment_visualization_action.triggered.connect(self.handle_liver_segment_visualization_action)
+        visualizations_menu = self.menuBar().addMenu('Visualizations')
+        visualizations_menu.addAction(slice_visualization_action)
+        visualizations_menu.addAction(slice_selection_visualization_action)
+        visualizations_menu.addAction(liver_segment_visualization_action)
+
+    def init_status_bar(self):
+        self.set_status('Ready')
+
+    # GET
+
+    def settings(self):
+        if not self._settings:
+            self._settings = Settings()
+        return self._settings
+
+    def main_panel(self):
+        if not self._main_panel:
+            self._main_panel = MainPanel(self)
+            self._main_panel.add_panel(self.rescale_dicom_images_task_panel(), 'rescaledicomimagestaskpanel')
+            self._main_panel.add_panel(self.segment_muscle_fat_l3_tensorflow_task_panel(), 'segmentmusclefatl3tensorflowtaskpanel')
+            self._main_panel.add_panel(self.segment_muscle_fat_t4_pytorch_task_panel(), 'segmentmusclefatt4pytorchtaskpanel')
+            self._main_panel.add_panel(self.create_pngs_from_segmentations_task_panel(), 'createpngsfromsegmentationstaskpanel')
+            self._main_panel.add_panel(self.calculate_scores_task_panel(), 'calculatescorestaskpanel')
+            self._main_panel.add_panel(self.dicom2nifti_task_panel(), 'dicom2niftitaskpanel')
+            self._main_panel.add_panel(self.segmentation_numpy_to_nifti_task_panel(), 'segmentationnumpy2niftitaskpanel')
+            self._main_panel.add_panel(self.segmentation_nifti_to_numpy_task_panel(), 'segmentationnifti2numpytaskpanel')
+            self._main_panel.add_panel(self.create_dicom_summary_task_panel(), 'createdicomsummarytaskpanel')
+            self._main_panel.add_panel(self.select_slice_from_scans_task_panel(), 'selectslicefromscanstaskpanel')
+            self._main_panel.add_panel(self.total_segmentator_task_panel(), 'totalsegmentatortaskpanel')
+            self._main_panel.add_panel(self.calculate_mask_statistics_task_panel(), 'calculatemaskstatisticstaskpanel')
+            self._main_panel.add_panel(self.apply_threshold_to_segmentations_task_panel(), 'applythresholdtosegmentationstaskpanel')
+            self._main_panel.add_panel(self.default_pipeline_panel(), 'defaultpipelinepanel')
+            self._main_panel.add_panel(self.default_docker_pipeline_panel(), 'defaultdockerpipelinepanel')
+            self._main_panel.add_panel(self.boa_docker_pipeline_panel(), 'boadockerpipelinepanel')
+            self._main_panel.add_panel(self.liver_analysis_pipeline_panel(), 'liveranalysispipelinepanel')
+            self._main_panel.add_panel(self.slice_visualization(), 'slicevisualization')
+            self._main_panel.add_panel(self.slice_selection_visualization(), 'sliceselectionvisualization')
+            self._main_panel.add_panel(self.liver_segment_visualization(), 'liversegmentvisualization')
+            self._main_panel.select_panel('defaultpipelinepanel')
+        return self._main_panel
+    
+    def log_panel(self):
+        if not self._log_panel:
+            self._log_panel = LogPanel()
+            LOG.add_listener(self._log_panel)
+        return self._log_panel
+
+    # MISCELLANEOUS
+
+    def rescale_dicom_images_task_panel(self):
+        if not self._rescale_dicom_images_task_panel:
+            self._rescale_dicom_images_task_panel = RescaleDicomImagesTaskPanel()
+        return self._rescale_dicom_images_task_panel
+    
+    def segment_muscle_fat_l3_tensorflow_task_panel(self):
+        if not self._segment_muscle_fat_l3_tensorflow_task_panel:
+            self._segment_muscle_fat_l3_tensorflow_task_panel = SegmentMuscleFatL3TensorFlowTaskPanel()
+        return self._segment_muscle_fat_l3_tensorflow_task_panel
+
+    def segment_muscle_fat_t4_pytorch_task_panel(self):
+        if not self._segment_muscle_fat_t4_pytorch_task_panel:
+            self._segment_muscle_fat_t4_pytorch_task_panel = SegmentMuscleFatT4PyTorchTaskPanel()
+        return self._segment_muscle_fat_t4_pytorch_task_panel
+
+    def create_pngs_from_segmentations_task_panel(self):
+        if not self._create_pngs_from_segmentations_task_panel:
+            self._create_pngs_from_segmentations_task_panel = CreatePngsFromSegmentationsTaskPanel()
+        return self._create_pngs_from_segmentations_task_panel
+    
+    def calculate_scores_task_panel(self):
+        if not self._calculate_scores_task_panel:
+            self._calculate_scores_task_panel = CalculateScoresTaskPanel()
+        return self._calculate_scores_task_panel
+    
+    def dicom2nifti_task_panel(self):
+        if not self._dicom2nifti_task_panel:
+            self._dicom2nifti_task_panel = Dicom2NiftiTaskPanel()
+        return self._dicom2nifti_task_panel
+
+    def segmentation_numpy_to_nifti_task_panel(self):
+        if not self._segmentation_numpy_to_nifti_task_panel:
+            self._segmentation_numpy_to_nifti_task_panel = SegmentationNumpy2NiftiTaskPanel()
+        return self._segmentation_numpy_to_nifti_task_panel
+    
+    def segmentation_nifti_to_numpy_task_panel(self):
+        if not self._segmentation_nifti_to_numpy_task_panel:
+            self._segmentation_nifti_to_numpy_task_panel = SegmentationNifti2NumpyTaskPanel()
+        return self._segmentation_nifti_to_numpy_task_panel
+    
+    def create_dicom_summary_task_panel(self):
+        if not self._create_dicom_summary_task_panel:
+            self._create_dicom_summary_task_panel = CreateDicomSummaryTaskPanel()
+        return self._create_dicom_summary_task_panel
+
+    def select_slice_from_scans_task_panel(self):
+        if not self._select_slice_from_scans_task_panel:
+            self._select_slice_from_scans_task_panel = SelectSliceFromScansTaskPanel()
+        return self._select_slice_from_scans_task_panel
+
+    def total_segmentator_task_panel(self):
+        if not self._total_segmentator_task_panel:
+            self._total_segmentator_task_panel = TotalSegmentatorTaskPanel()
+        return self._total_segmentator_task_panel
+    
+    def calculate_mask_statistics_task_panel(self):
+        if not self._calculate_mask_statistics_task_panel:
+            self._calculate_mask_statistics_task_panel = CalculateMaskStatisticsTaskPanel()
+        return self._calculate_mask_statistics_task_panel
+
+    def apply_threshold_to_segmentations_task_panel(self):
+        if not self._apply_threshold_to_segmentations_task_panel:
+            self._apply_threshold_to_segmentations_task_panel = ApplyThresholdToSegmentationsTaskPanel()
+        return self._apply_threshold_to_segmentations_task_panel
+    
+    def default_pipeline_panel(self):
+        if not self._default_pipeline_panel:
+            self._default_pipeline_panel = DefaultPipelinePanel()
+        return self._default_pipeline_panel
+
+    def default_docker_pipeline_panel(self):
+        if not self._default_docker_pipeline_panel:
+            self._default_docker_pipeline_panel = DefaultDockerPipelinePanel()
+        return self._default_docker_pipeline_panel
+
+    def boa_docker_pipeline_panel(self):
+        if not self._boa_docker_pipeline_panel:
+            self._boa_docker_pipeline_panel = BoaDockerPipelinePanel()
+        return self._boa_docker_pipeline_panel
+    
+    def liver_analysis_pipeline_panel(self):
+        if not self._liver_analysis_pipeline_panel:
+            self._liver_analysis_pipeline_panel = LiverAnalysisPipelinePanel()
+        return self._liver_analysis_pipeline_panel
+    
+    def slice_visualization(self):
+        if not self._slice_visualization:
+            self._slice_visualization = SliceVisualization()
+        return self._slice_visualization
+    
+    def slice_selection_visualization(self):
+        if not self._slice_selection_visualization:
+            self._slice_selection_visualization = SliceSelectionVisualization()
+        return self._slice_selection_visualization
+
+    def liver_segment_visualization(self):
+        if not self._liver_segment_visualization:
+            self._liver_segment_visualization = LiverSegmentVisualization()
+        return self._liver_segment_visualization
+
+    # SETTERS
+
+    def set_status(self, message):
+        self.statusBar().showMessage(message)
+
+    # EVENT HANDLERS
+
+    def handle_rescale_dicom_images_task_action(self):
+        self.main_panel().select_panel('rescaledicomimagestaskpanel')
+
+    def handle_segment_muscle_fat_l3_tensorflow_task_action(self):
+        self.main_panel().select_panel('segmentmusclefatl3tensorflowtaskpanel')
+
+    def handle_segment_muscle_fat_t4_pytorch_task_action(self):
+        self.main_panel().select_panel('segmentmusclefatt4pytorchtaskpanel')
+
+    def handle_create_pngs_from_segmentations_task_action(self):
+        self.main_panel().select_panel('createpngsfromsegmentationstaskpanel')
+
+    def handle_calculate_scores_task_action(self):
+        self.main_panel().select_panel('calculatescorestaskpanel')
+
+    def handle_dicom2nifti_task_action(self):
+        self.main_panel().select_panel('dicom2niftitaskpanel')
+
+    def handle_segmentation_numpy_to_nifti_task_action(self):
+        self.main_panel().select_panel('segmentationnumpy2niftitaskpanel')
+
+    def handle_segmentation_nifti_to_numpy_task_action(self):
+        self.main_panel().select_panel('segmentationnifti2numpytaskpanel')
+
+    def handle_create_dicom_summary_task_action(self):
+        self.main_panel().select_panel('createdicomsummarytaskpanel')
+
+    def handle_select_slice_from_scans_task_action(self):
+        self.main_panel().select_panel('selectslicefromscanstaskpanel')
+
+    def handle_total_segmentator_task_action(self):
+        self.main_panel().select_panel('totalsegmentatortaskpanel')
+
+    def handle_calculate_mask_statistics_task_action(self):
+        self.main_panel().select_panel('calculatemaskstatisticstaskpanel')
+
+    def handle_apply_threshold_to_segmentations_task_action(self):
+        self.main_panel().select_panel('applythresholdtosegmentationstaskpanel')
+
+    def handle_default_pipeline_action(self):
+        self.main_panel().select_panel('defaultpipelinepanel')
+
+    def handle_default_docker_pipeline_action(self):
+        self.main_panel().select_panel('defaultdockerpipelinepanel')
+
+    def handle_boa_docker_pipeline_action(self):
+        self.main_panel().select_panel('boadockerpipelinepanel')
+
+    def handle_liver_analysis_pipeline_action(self):
+        self.main_panel().select_panel('liveranalysispipelinepanel')
+
+    def handle_slice_visualization_action(self):
+        self.main_panel().select_panel('slicevisualization')
+
+    def handle_slice_selection_visualization_action(self):
+        self.main_panel().select_panel('sliceselectionvisualization')
+
+    def handle_liver_segment_visualization_action(self):
+        self.main_panel().select_panel('liversegmentvisualization')
+
+    def showEvent(self, event):
+        return super().showEvent(event)
+
+    def closeEvent(self, event):
+        self.save_geometry_and_state()
+        # Save inputs and parameters of relevant panels
+        self.rescale_dicom_images_task_panel().save_inputs_and_parameters()
+        self.segment_muscle_fat_l3_tensorflow_task_panel().save_inputs_and_parameters()
+        self.segment_muscle_fat_t4_pytorch_task_panel().save_inputs_and_parameters()
+        self.create_pngs_from_segmentations_task_panel().save_inputs_and_parameters()
+        self.calculate_scores_task_panel().save_inputs_and_parameters()
+        self.dicom2nifti_task_panel().save_inputs_and_parameters()
+        self.segmentation_numpy_to_nifti_task_panel().save_inputs_and_parameters()
+        self.segmentation_nifti_to_numpy_task_panel().save_inputs_and_parameters()
+        self.create_dicom_summary_task_panel().save_inputs_and_parameters()
+        self.select_slice_from_scans_task_panel().save_inputs_and_parameters()
+        self.total_segmentator_task_panel().save_inputs_and_parameters()
+        self.calculate_mask_statistics_task_panel().save_inputs_and_parameters()
+        self.apply_threshold_to_segmentations_task_panel().save_inputs_and_parameters()
+        self.default_pipeline_panel().save_inputs_and_parameters()
+        self.default_docker_pipeline_panel().save_inputs_and_parameters()
+        self.boa_docker_pipeline_panel().save_inputs_and_parameters()
+        self.liver_analysis_pipeline_panel().save_inputs_and_parameters()
+        self.slice_visualization().save_inputs_and_parameters()
+        self.slice_selection_visualization().save_inputs_and_parameters()
+        self.liver_segment_visualization().save_inputs_and_parameters()
+        return super().closeEvent(event)
+
+    def load_geometry_and_state(self):
+        geometry = self.settings().get(constants.MOSAMATIC2_WINDOW_GEOMETRY_KEY)
+        state = self.settings().get(constants.MOSAMATIC2_WINDOW_STATE_KEY)
+        if isinstance(geometry, QByteArray) and self.restoreGeometry(geometry):
+            if isinstance(state, QByteArray):
+                self.restoreState(state)
+            return True
+        return False
+
+    def save_geometry_and_state(self):
+        self.settings().set(constants.MOSAMATIC2_WINDOW_GEOMETRY_KEY, self.saveGeometry())
+        self.settings().set(constants.MOSAMATIC2_WINDOW_STATE_KEY, self.saveState())
+
+    def set_default_size_and_position(self):
+        self.resize(constants.MOSAMATIC2_WINDOW_W, constants.MOSAMATIC2_WINDOW_H)
+        self.center_window()
+
+    def center_window(self):
+        screen = QGuiApplication.primaryScreen().geometry()
+        x = (screen.width() - self.geometry().width()) / 2
+        y = (screen.height() - self.geometry().height()) / 2
+        self.move(int(x), int(y))

mosamatic2/ui/resources/VERSION

@@ -0,0 +1 @@
+2.0.24 

mosamatic2/ui/settings.py

@@ -0,0 +1,62 @@
+import mosamatic2.constants as constants
+from PySide6.QtCore import QSettings
+from mosamatic2.core.managers.logmanager import LogManager
+
+LOG = LogManager()
+
+
+class Settings(QSettings):
+    def __init__(self):
+        super(Settings, self).__init__(
+            QSettings.IniFormat, 
+            QSettings.UserScope, 
+            constants.MOSAMATIC2_BUNDLE_IDENTIFIER, 
+            constants.MOSAMATIC2_APP_NAME,
+        )
+
+    def prepend_bundle_identifier_and_name(self, name):
+        return '{}.{}.{}'.format(constants.MOSAMATIC2_BUNDLE_IDENTIFIER, constants.MOSAMATIC2_APP_NAME, name)
+
+    def get(self, name, default=None):
+        if not name.startswith(constants.MOSAMATIC2_BUNDLE_IDENTIFIER):
+            name = self.prepend_bundle_identifier_and_name(name)
+        value = self.value(name)
+        if value is None or value == '':
+            return default
+        return value
+    
+    def get_int(self, name, default=None):
+        try:
+            return int(self.get(name, default))
+        except ValueError as e:
+            return default
+        
+    def get_float(self, name, default=None):
+        try:
+            return float(self.get(name, default))
+        except ValueError as e:
+            return default
+        
+    def get_bool(self, name, default=None):
+        try:
+            value = self.get(name, default)
+            if value and isinstance(value, str):
+                if value == '0' or value.lower() == 'false':
+                    return False
+                elif value == '1' or value.lower() == 'true':
+                    return True
+                else:
+                    return default
+            if value and isinstance(value, bool):
+                return value
+        except ValueError as e:
+            return default
+    
+    def set(self, name, value):
+        name = self.prepend_bundle_identifier_and_name(name)
+        self.setValue(name, value)
+
+    def print(self):
+        LOG.info(f'Settings path: {self.fileName()}')
+        for key in self.allKeys():
+            LOG.info(f'Settings: {key}')

mosamatic2/ui/utils.py

@@ -0,0 +1,36 @@
+import os
+import sys
+import mosamatic2.constants as constants
+from PySide6.QtGui import (
+    QPixmap, 
+    QPainter, 
+    QColor
+)
+
+
+def resource_path(relative_path):
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+    return os.path.join(base_path, relative_path)
+
+
+def version():
+    with open(resource_path(constants.MOSAMATIC2_VERSION_FILE), 'r') as f:
+        return f.readline().strip()
+
+
+def is_macos():
+    return sys.platform.startswith('darwin')
+
+
+def icon(parent, icon_type):
+    return parent.style().standardIcon(icon_type)
+
+
+def set_opacity(pixmap, opacity):
+    result = QPixmap(pixmap.size())
+    result.fill(QColor(0, 0, 0, 0))
+    painter = QPainter(result)
+    painter.setOpacity(opacity)
+    painter.drawPixmap(0, 0, pixmap)
+    painter.end()
+    return result

mosamatic2/ui/widgets/dialogs/dialog.py

@@ -0,0 +1,16 @@
+from PySide6.QtWidgets import (
+    QDialog,
+)
+
+
+class Dialog(QDialog):
+    def __init__(self, parent=None):
+        super(Dialog, self).__init__(parent)
+        self.setFixedWidth(400)
+
+    def clear(self):
+        raise NotImplementedError()
+
+    def showEvent(self, arg__1):
+        self.clear()
+        return super().showEvent(arg__1)

mosamatic2/ui/widgets/dialogs/helpdialog.py

@@ -0,0 +1,9 @@
+from mosamatic2.ui.widgets.dialogs.dialog import Dialog
+
+
+class HelpDialog(Dialog):
+    def clear(self):
+        pass
+
+    def set_text(self, text):
+        pass

mosamatic2/ui/widgets/panels/defaultpanel.py

@@ -0,0 +1,31 @@
+from PySide6.QtWidgets import QWidget, QPushButton
+
+from mosamatic2.ui.widgets.dialogs.helpdialog import HelpDialog
+
+
+class DefaultPanel(QWidget):
+    def __init__(self):
+        super(DefaultPanel, self).__init__()
+        self._title = None
+        self._help_dialog = None
+        self._show_help_button = None
+
+    def title(self):
+        return self._title
+    
+    def set_title(self, title):
+        self._title = title
+
+    def help_dialog(self):
+        if not self._help_dialog:
+            self._help_dialog = HelpDialog()
+        return self._help_dialog
+
+    def show_help_button(self):
+        if not self._show_help_button:
+            self._show_help_button = QPushButton('Help')
+            self._show_help_button.clicked.connect(self.handle_show_help_button)
+        return self._show_help_button
+    
+    def handle_show_help_button(self):
+        self.help_dialog().show()

mosamatic2/ui/widgets/panels/logpanel.py

@@ -0,0 +1,65 @@
+from PySide6.QtWidgets import (
+    QWidget,
+    QDockWidget,
+    QTextEdit,
+    QPushButton,
+    QVBoxLayout,
+    QLabel,
+)
+
+from mosamatic2.core.managers.logmanagerlistener import LogManagerListener
+
+PANEL_TITLE = 'Output log'
+PANEL_NAME = 'logpanel'
+
+
+class LogPanel(QDockWidget, LogManagerListener):
+    def __init__(self):
+        super(LogPanel, self).__init__()
+        self._title_label = None
+        self._text_edit = None
+        self.init_layout()
+
+    def title_label(self):
+        if not self._title_label:
+            self._title_label = QLabel(PANEL_TITLE)
+        return self._title_label
+
+    def text_edit(self):
+        if not self._text_edit:
+            self._text_edit = QTextEdit()
+        return self._text_edit
+    
+    def init_layout(self):
+        clear_logs_button = QPushButton('Clear log')
+        clear_logs_button.clicked.connect(self.handle_clear_logs_button)
+        layout = QVBoxLayout()
+        # layout.addWidget(self.title_label())
+        layout.addWidget(self.text_edit())
+        layout.addWidget(clear_logs_button)
+        container = QWidget()
+        container.setLayout(layout)
+        self.setObjectName(PANEL_NAME)
+        self.setWindowTitle(self.title_label().text())
+        self.setWidget(container)
+
+    # HELPERS
+
+    def add_line(self, line):
+        self.text_edit().insertPlainText(line + '\n')
+        self.move_to_end()
+
+    def move_to_end(self):
+        cursor = self.text_edit().textCursor()
+        cursor.movePosition(cursor.MoveOperation.End)
+        self.text_edit().setTextCursor(cursor)
+        self.text_edit().ensureCursorVisible()
+
+    # EVENTS
+
+    def handle_clear_logs_button(self):
+        self.text_edit().clear()
+
+    # implements(LogManagerListener)
+    def new_message(self, message):
+        self.add_line(message)