MainWindow.py

            data=[self._study, None]
        ):
            return

        hydraulic_structures = HydraulicStructuresWindow(
            study=self._study,
            parent=self
        )
        hydraulic_structures.show()

    def open_lateral_contrib(self):
        if self.sub_window_exists(
            LateralContributionWindow,
            data=[self._study, None]
        ):
            return

        lateral = LateralContributionWindow(
            study=self._study,
            parent=self
        )
        lateral.show()

    def open_stricklers(self):
        if self.sub_window_exists(
            StricklersWindow,
            data=[self._study, self.conf]
        ):
            return

        strick = StricklersWindow(
            study=self._study,
            config=self.conf,
            parent=self
        )
        strick.show()

    def open_frictions(self):
        if self._study is not None:
            if self._study.river.has_current_reach():
                reach = self._study.river.current_reach()

                if self.sub_window_exists(
                    FrictionsWindow,
                    data=[self._study, None, reach]
                ):
                    return

                frictions = FrictionsWindow(
                    study=self._study,
                    parent=self
                )
                frictions.show()
            else:
                self.msg_select_reach()

    def open_initial_conditions(self):
        if self._study.river.has_current_reach():
            reach = self._study.river.current_reach()

            if self.sub_window_exists(
                InitialConditionsWindow,
                data=[self._study, self.conf, reach]
            ):
                return

            initial = InitialConditionsWindow(
                study=self._study,
                config=self.conf,
                reach=reach,
                parent=self
            )
            initial.show()
        else:
            self.msg_select_reach()

    def open_additional_files(self):
        if self._study is not None:
            if self.sub_window_exists(
                AddFileListWindow,
                data=[self._study, None]
            ):
                return

            self.additonal_files = AddFileListWindow(
                study=self._study, parent=self
            )
            self.additonal_files.show()

    def open_rep_lines(self):
        if self._study is not None:
            if self.sub_window_exists(
                REPLineListWindow,
                data=[self._study, None]
            ):
                return

            self.rep_lines = REPLineListWindow(
                study=self._study, parent=self
            )
            self.rep_lines.show()

    def open_solver_parameters(self):
        if self.sub_window_exists(
            SolverParametersWindow,
            data=[self._study, None]
        ):
            return

        params = SolverParametersWindow(
            study=self._study,
            parent=self
        )
        params.show()

    def open_sediment_layers(self):
        if self.sub_window_exists(
            SedimentLayersWindow,
            data=[self._study, None]
        ):
            return

        sl = SedimentLayersWindow(
            study=self._study,
            parent=self
        )
        sl.show()

    def open_reach_sediment_layers(self):
        reach = self._study.river.current_reach().reach

        if self.sub_window_exists(
            ReachSedimentLayersWindow,
            data=[self._study, None, reach]
        ):
            return

        sl = ReachSedimentLayersWindow(
            study=self._study,
            reach=reach,
            parent=self
        )
        sl.show()

    def run_lasest_solver(self):
        if self._last_solver is None:
            return

        self.run_solver(self._last_solver)

    def select_and_run_solver(self):
        if self._study is None:
            return

        run = SelectSolverWindow(
            study=self._study,
            config=self.conf,
            parent=self
        )
        if run.exec():
            self.run_solver(run.solver)

    def run_solver(self, solver):
        if self._study is None:
            return

        if self.sub_window_exists(
            CheckListWindow,
            data=[
                self._study,
                self.conf,
                solver
            ]
        ):
            return

        check = CheckListWindow(
            study=self._study,
            config=self.conf,
            solver=solver,
            parent=self
        )
        check.show()

    def solver_log(self, solver):
        sol = SolverLogWindow(
            study=self._study,
            config=self.conf,
            solver=solver,
            parent=self
        )
        sol.show()

    def open_solver_results(self, solver, results=None):
        def reading_fn():
            self._tmp_results = results

        # If no specific results, get last results
        if results is None:
            def reading_fn():
                self._tmp_results = self._last_results

            if self._last_results is None:
                def reading_fn():
                    self._tmp_results = solver.results(
                        self._study,
                        self._solver_workdir(solver),
                    )

        # Open from file
        if type(results) is str:
            logger.info(f"Open results from {os.path.dirname(results)}")

            name = os.path.basename(results).replace(".BIN", "")

            def reading_fn():
                self._tmp_results = solver.results(
                    self._study,
                    os.path.dirname(results),
                    name=name
                )

        dlg = ReadingResultsDialog(reading_fn=reading_fn, parent=self)
        dlg.exec_()
        results = self._tmp_results

        # No results available
        if results is None:
            return

        # Windows already opened
        if self.sub_window_exists(
                ResultsWindow,
                data=[
                    self._study,
                    None,       # No config
                    solver,
                    results
                ]
        ):
            return

        res = ResultsWindow(
            study=self._study,
            solver=solver,
            results=results,
            parent=self
        )
        res.show()

    def _solver_workdir(self, solver):
        workdir = os.path.join(
            os.path.dirname(self._study.filename),
            "_PAMHYR_",
            self._study.name.replace(" ", "_"),
            solver.name.replace(" ", "_"),
        )

        return workdir

    def open_last_results(self):
        if self._last_solver is None:
            return

        self.open_solver_results(self._last_solver, self._last_results)

    def open_results_from_file(self):
        if self._study is None:
            return

        if self._study.filename == "":
            return

        dialog = QFileDialog(self)
        dialog.setFileMode(QFileDialog.FileMode.ExistingFile)
        dialog.setDefaultSuffix(".BIN")
        # dialog.setFilter(dialog.filter() | QtCore.QDir.Hidden)
        dialog.setNameFilters(['Mage (*.BIN)'])

        if self._last_solver is None:
            dialog.setDirectory(
                os.path.dirname(self._study.filename)
            )
        else:
            dialog.setDirectory(
                self._solver_workdir(self._last_solver)
            )

        if dialog.exec_():
            file_name = dialog.selectedFiles()
            logger.info(f"Select results: {file_name}")
            self.open_solver_results(
                self._last_solver,
                results=file_name[0]
            )

    #################
    # DOCUMENTATION #
    #################

    def _doc_path_file(self, filename):
        if ".py" in sys.argv[0]:
            return os.path.abspath(
                os.path.join(
                    os.path.dirname(__file__),
                    "..", "..", "doc", filename
                )
            )

        return os.path.abspath(
            os.path.join(
                os.path.dirname(__file__),
                "..", "..", "doc", filename
            )
        )

    def open_doc(self, filename):
        if "https://" in filename:
            url = QUrl(filename)
            QDesktopServices.openUrl(url)
            return

        if _doc == "external":
            url = QUrl(f"file://{self._doc_path_file(filename)}")
            QDesktopServices.openUrl(url)
        else:
            if ".odt" in filename:
                url = QUrl(f"file://{DocWindow._path_file(filename)}")
                QDesktopServices.openUrl(url)
            else:
                doc = DocWindow(
                    filename=filename,
                    parent=self
                )
                doc.show()

    def open_doc_user(self):
        self.open_doc(
            "https://gitlab.irstea.fr/theophile.terraz/pamhyr/-/wikis/home"
        )

    def open_doc_dev(self, ext="pdf"):
        self.open_doc(f"Pamhyr2-dev.{ext}")

    def open_doc_mage(self):
        self.open_doc("mage8.pdf")

    #########
    # DEBUG #
    #########

    def open_debug(self):
        repl = ReplWindow(
            study=self._study,
            config=self.conf,
            parent=self
        )
        repl.show()

    def open_sqlite(self):
        if self._study is None:
            logger.debug("No study open for sql debuging...")
            return

        file = self._study.filename
        _ = subprocess.Popen(
            f"sqlitebrowser {file}",
            shell=True
        )

    # TODO: Delete me !
    ###############
    # DUMMY STUFF #
    ###############

    def open_dummy(self, title="Dummy"):
        self.dummy = DummyWindow(
            title=title if type(title) is str else "Dummy",
            parent=self
        )
        self.dummy.show()