MainWindow Class Reference

Detailed Description

Main program window for the graphical user interface of OpenGeoSys.

Definition at line 38 of file mainwindow.h.

#include <mainwindow.h>

Inheritance diagram for MainWindow:

Collaboration diagram for MainWindow:

Signals
void	fileUsed (QString filename)
void	fileOpenRequested (int)

Public Member Functions
	MainWindow (QWidget *parent=nullptr)
void	ShowWindow ()
void	HideWindow ()
void	loadFileOnStartUp (const QString &fileName)

Protected Slots
void	showGeoDockWidget (bool show)
void	showStationDockWidget (bool show)
void	showMshDockWidget (bool show)
void	showConditionDockWidget (bool show)
void	showVisDockWidget (bool show)
void	open (int file_type=0)
	Function calls for opening files.
void	save ()
	Function calls for saving files.
void	callGMSH (std::vector< std::string > &selectedGeometries, unsigned param1, double param2, double param3, double param4, bool delete_geo_file)
	Function calls for generating GMSH files from the GUI.
void	exportBoreholesToGMS (std::string listName, std::string fileName)
	Function calls for GMS export.
void	FEMTestStart ()
	Testing functionality for connection to FEM lib.
void	loadPetrelFiles ()
void	mapGeometry (const std::string &geo_name)
void	convertMeshToGeometry (const MeshLib::Mesh *mesh)
void	convertPointsToStations (std::string const &geo_name)
void	openRecentFile ()
void	about ()
void	showAddPipelineFilterItemDialog (QModelIndex parentIndex)
void	showDataExplorerSettingsDialog ()
void	showGeoNameDialog (const std::string &geometry_name, const GeoLib::GEOTYPE object_type, std::size_t id)
	Allows setting the name for a geometric object.
void	showStationNameDialog (const std::string &stn_vec_name, std::size_t id)
	Allows setting the name for a station.
void	showCreateStructuredGridDialog ()
	Creates a structured grid with user-specified parameters.
void	showMeshElementRemovalDialog ()
	Removal of mesh elements based on a number of criteria.
void	showDiagramPrefsDialog ()
	Calls the diagram prefs dialog from the Tools menu.
void	showDiagramPrefsDialog (QModelIndex &index)
void	showFileConverter ()
	Calls the OGSFileConverter as an external tool.
void	showLicense ()
void	showLineEditDialog (const std::string &geoName)
void	showGMSHPrefsDialog ()
void	showMergeGeometriesDialog ()
void	showMeshAnalysisDialog ()
void	showTranslateDataDialog ()
void	showLayers2GridDialog ()
void	showMeshQualitySelectionDialog (MeshLib::VtkMappedMeshSource *mshSource)
void	showVisalizationPrefsDialog ()
void	showVtu2GridDialog ()
void	updateDataViews ()
void	writeGeometryToFile (QString gliName, QString fileName)
void	writeStationListToFile (QString listName, QString fileName)
void	on_actionExportVTK_triggered (bool checked=false)
void	on_actionExportVRML2_triggered (bool checked=false)
void	on_actionExportObj_triggered (bool checked=false)
void	createPresentationMenu ()
void	startPresentationMode ()
void	quitPresentationMode ()

Protected Member Functions
void	closeEvent (QCloseEvent *event) override

Private Member Functions
QMenu *	createImportFilesMenu ()
void	loadFile (ImportFileType::type t, const QString &fileName)
void	loadFEMConditionsFromFile (const QString &fileName, std::string geoName="")
void	readSettings ()
void	writeSettings ()
QString	getLastUsedDir ()

Private Attributes
DataHolderLib::Project	_project
std::unique_ptr< MeshModel >	_meshModel
std::unique_ptr< ElementTreeModel >	_elementModel
std::unique_ptr< ProcessModel >	_processModel
std::unique_ptr< FemConditionModel >	_conditionModel
std::unique_ptr< VtkVisPipeline >	_vtkVisPipeline
QList< QRect >	_screenGeometries
std::unique_ptr< QWidget >	_vtkWidget
QByteArray	_windowState
std::unique_ptr< VisPrefsDialog >	_visPrefsDialog
std::unique_ptr< GEOModels >	_geo_model

Constructor & Destructor Documentation

MainWindow()

MainWindow::MainWindow ( QWidget *  parent = nullptr )

explicit

Definition at line 103 of file mainwindow.cpp.

                                        : QMainWindow(parent)
{
    setupUi(this);
 
    // Setup various models
    _geo_model = std::make_unique<GEOModels>(_project.getGEOObjects());
    _meshModel = std::make_unique<MeshModel>(_project);
    _elementModel = std::make_unique<ElementTreeModel>();
    _processModel = std::make_unique<ProcessModel>(_project);
    _conditionModel = std::make_unique<FemConditionModel>();
 
    geoTabWidget->treeView->setModel(_geo_model->getGeoModel());
    stationTabWidget->treeView->setModel(_geo_model->getStationModel());
    meshTabWidget->treeView->setModel(_meshModel.get());
    meshTabWidget->elementView->setModel(_elementModel.get());
    modellingTabWidget->treeView->setModel(_processModel.get());
    modellingTabWidget->conditionView->setModel(_conditionModel.get());
 
    // vtk visualization pipeline
    _vtkVisPipeline =
        std::make_unique<VtkVisPipeline>(visualizationWidget->renderer());
 
    // station model connects
    connect(stationTabWidget->treeView, SIGNAL(openStationListFile(int)), this,
            SLOT(open(int)));
    connect(stationTabWidget->treeView,
            SIGNAL(stationListExportRequested(std::string, std::string)), this,
            SLOT(exportBoreholesToGMS(
                std::string, std::string)));  // export Stationlist to GMS
    connect(stationTabWidget->treeView, SIGNAL(stationListRemoved(std::string)),
            _geo_model.get(),
            SLOT(removeStationVec(
                std::string)));  // update model when stations are removed
    connect(stationTabWidget->treeView,
            SIGNAL(stationListSaved(QString, QString)), this,
            SLOT(writeStationListToFile(QString,
                                        QString)));  // save Stationlist to File
    connect(
        _geo_model.get(),
        SIGNAL(stationVectorRemoved(StationTreeModel*, std::string)), this,
        SLOT(updateDataViews()));  // update data view when stations are removed
    connect(stationTabWidget->treeView,
            SIGNAL(requestNameChangeDialog(const std::string&, std::size_t)),
            this, SLOT(showStationNameDialog(const std::string&, std::size_t)));
    connect(stationTabWidget->treeView,
            SIGNAL(geometryMappingRequested(const std::string&)), this,
            SLOT(mapGeometry(const std::string&)));
    connect(stationTabWidget->treeView, SIGNAL(diagramRequested(QModelIndex&)),
            this,
            SLOT(showDiagramPrefsDialog(
                QModelIndex&)));  // connect treeview to diagramview
 
    // geo model connects
    connect(geoTabWidget->treeView, SIGNAL(openGeometryFile(int)), this,
            SLOT(open(int)));
    connect(geoTabWidget->treeView,
            SIGNAL(listRemoved(std::string, GeoLib::GEOTYPE)), _geo_model.get(),
            SLOT(removeGeometry(std::string, GeoLib::GEOTYPE)));
    connect(geoTabWidget->treeView,
            SIGNAL(geometryMappingRequested(const std::string&)), this,
            SLOT(mapGeometry(const std::string&)));
    connect(
        geoTabWidget->treeView, SIGNAL(saveToFileRequested(QString, QString)),
        this,
        SLOT(writeGeometryToFile(QString, QString)));  // save geometry to file
    connect(geoTabWidget->treeView,
            SIGNAL(requestPointToStationConversion(std::string const&)), this,
            SLOT(convertPointsToStations(std::string const&)));
    connect(
        geoTabWidget->treeView,
        SIGNAL(requestLineEditDialog(const std::string&)), this,
        SLOT(showLineEditDialog(const std::string&)));  // open line edit dialog
    connect(geoTabWidget->treeView,
            SIGNAL(requestNameChangeDialog(const std::string&,
                                           const GeoLib::GEOTYPE, std::size_t)),
            this,
            SLOT(showGeoNameDialog(const std::string&, const GeoLib::GEOTYPE,
                                   std::size_t)));
    connect(_geo_model.get(),
            SIGNAL(geoDataAdded(GeoTreeModel*, std::string, GeoLib::GEOTYPE)),
            this, SLOT(updateDataViews()));
    connect(_geo_model.get(),
            SIGNAL(geoDataRemoved(GeoTreeModel*, std::string, GeoLib::GEOTYPE)),
            this, SLOT(updateDataViews()));
    connect(geoTabWidget->treeView,
            SIGNAL(geoItemSelected(const vtkPolyDataAlgorithm*, int)),
            _vtkVisPipeline.get(),
            SLOT(highlightGeoObject(const vtkPolyDataAlgorithm*, int)));
    connect(geoTabWidget->treeView, SIGNAL(removeGeoItemSelection()),
            _vtkVisPipeline.get(), SLOT(removeHighlightedGeoObject()));
    connect(stationTabWidget->treeView,
            SIGNAL(geoItemSelected(const vtkPolyDataAlgorithm*, int)),
            _vtkVisPipeline.get(),
            SLOT(highlightGeoObject(const vtkPolyDataAlgorithm*, int)));
    connect(stationTabWidget->treeView, SIGNAL(removeGeoItemSelection()),
            _vtkVisPipeline.get(), SLOT(removeHighlightedGeoObject()));
 
    // Setup connections for mesh models to GUI
    connect(meshTabWidget->treeView, SIGNAL(openMeshFile(int)), this,
            SLOT(open(int)));
    connect(meshTabWidget->treeView,
            SIGNAL(requestMeshRemoval(const QModelIndex&)), _meshModel.get(),
            SLOT(removeMesh(const QModelIndex&)));
    connect(meshTabWidget->treeView,
            SIGNAL(requestMeshRemoval(const QModelIndex&)), _elementModel.get(),
            SLOT(clearView()));
    connect(
        meshTabWidget->treeView,
        SIGNAL(qualityCheckRequested(MeshLib::VtkMappedMeshSource*)),
        this,
        SLOT(showMeshQualitySelectionDialog(MeshLib::VtkMappedMeshSource*)));
    connect(meshTabWidget->treeView,
            SIGNAL(requestMeshToGeometryConversion(const MeshLib::Mesh*)), this,
            SLOT(convertMeshToGeometry(const MeshLib::Mesh*)));
    connect(meshTabWidget->treeView,
            SIGNAL(elementSelected(vtkUnstructuredGridAlgorithm const* const,
                                   unsigned, bool)),
            _vtkVisPipeline.get(),
            SLOT(highlightMeshComponent(
                vtkUnstructuredGridAlgorithm const* const, unsigned, bool)));
    connect(meshTabWidget->treeView, SIGNAL(meshSelected(MeshLib::Mesh const&)),
            this->_elementModel.get(), SLOT(setMesh(MeshLib::Mesh const&)));
    connect(meshTabWidget->treeView, SIGNAL(meshSelected(MeshLib::Mesh const&)),
            meshTabWidget->elementView, SLOT(updateView()));
    connect(
        meshTabWidget->treeView,
        SIGNAL(elementSelected(vtkUnstructuredGridAlgorithm const* const,
                               unsigned, bool)),
        this->_elementModel.get(),
        SLOT(setElement(vtkUnstructuredGridAlgorithm const* const, unsigned)));
    connect(meshTabWidget->treeView,
            SIGNAL(elementSelected(vtkUnstructuredGridAlgorithm const* const,
                                   unsigned, bool)),
            meshTabWidget->elementView, SLOT(updateView()));
    connect(meshTabWidget->treeView,
            SIGNAL(elementSelected(vtkUnstructuredGridAlgorithm const* const,
                                   unsigned, bool)),
            reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SLOT(removeHighlightActor()));
    connect(meshTabWidget->treeView, SIGNAL(removeSelectedMeshComponent()),
            _vtkVisPipeline.get(), SLOT(removeHighlightedMeshComponent()));
    connect(meshTabWidget->elementView,
            SIGNAL(nodeSelected(vtkUnstructuredGridAlgorithm const* const,
                                unsigned, bool)),
            reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SLOT(removeHighlightActor()));
    connect(meshTabWidget->elementView,
            SIGNAL(nodeSelected(vtkUnstructuredGridAlgorithm const* const,
                                unsigned, bool)),
            _vtkVisPipeline.get(),
            SLOT(highlightMeshComponent(
                vtkUnstructuredGridAlgorithm const* const, unsigned, bool)));
    connect(meshTabWidget->elementView, SIGNAL(removeSelectedMeshComponent()),
            _vtkVisPipeline.get(), SLOT(removeHighlightedMeshComponent()));
 
    // Connection for process model to GUI
    connect(modellingTabWidget->treeView,
            SIGNAL(processVarRemoved(QString const&)), _processModel.get(),
            SLOT(removeProcessVariable(QString const&)));
    connect(modellingTabWidget->treeView,
            SIGNAL(conditionRemoved(QString const&, QString const&)),
            _processModel.get(),
            SLOT(removeCondition(QString const&, QString const&)));
    connect(modellingTabWidget->treeView, SIGNAL(clearConditionView()),
            _conditionModel.get(), SLOT(clearView()));
    connect(modellingTabWidget->treeView,
            SIGNAL(processVarSelected(DataHolderLib::FemCondition*)),
            _conditionModel.get(),
            SLOT(setProcessVariable(DataHolderLib::FemCondition*)));
    connect(modellingTabWidget->treeView,
            SIGNAL(conditionSelected(DataHolderLib::FemCondition*)),
            _conditionModel.get(),
            SLOT(setFemCondition(DataHolderLib::FemCondition*)));
    connect(modellingTabWidget->treeView,
            SIGNAL(processVarSelected(DataHolderLib::FemCondition*)),
            modellingTabWidget->conditionView, SLOT(updateView()));
    connect(modellingTabWidget->treeView,
            SIGNAL(conditionSelected(DataHolderLib::FemCondition*)),
            modellingTabWidget->conditionView, SLOT(updateView()));
 
    // VisPipeline Connects
    connect(_geo_model.get(),
            SIGNAL(geoDataAdded(GeoTreeModel*, std::string, GeoLib::GEOTYPE)),
            _vtkVisPipeline.get(),
            SLOT(addPipelineItem(GeoTreeModel*, std::string, GeoLib::GEOTYPE)));
    connect(
        _geo_model.get(),
        SIGNAL(geoDataRemoved(GeoTreeModel*, std::string, GeoLib::GEOTYPE)),
        _vtkVisPipeline.get(),
        SLOT(removeSourceItem(GeoTreeModel*, std::string, GeoLib::GEOTYPE)));
 
    connect(_geo_model.get(),
            SIGNAL(stationVectorAdded(StationTreeModel*, std::string)),
            _vtkVisPipeline.get(),
            SLOT(addPipelineItem(StationTreeModel*, std::string)));
    connect(_geo_model.get(),
            SIGNAL(stationVectorRemoved(StationTreeModel*, std::string)),
            _vtkVisPipeline.get(),
            SLOT(removeSourceItem(StationTreeModel*, std::string)));
 
    connect(_meshModel.get(), SIGNAL(meshAdded(MeshModel*, QModelIndex)),
            _vtkVisPipeline.get(),
            SLOT(addPipelineItem(MeshModel*, QModelIndex)));
    connect(_meshModel.get(), SIGNAL(meshRemoved(MeshModel*, QModelIndex)),
            _vtkVisPipeline.get(),
            SLOT(removeSourceItem(MeshModel*, QModelIndex)));
 
    connect(_vtkVisPipeline.get(), SIGNAL(vtkVisPipelineChanged()),
            visualizationWidget->vtkWidget, SLOT(update()));
    connect(_vtkVisPipeline.get(), SIGNAL(vtkVisPipelineChanged()),
            vtkVisTabWidget->vtkVisPipelineView, SLOT(expandAll()));
    connect(_vtkVisPipeline.get(), SIGNAL(itemSelected(const QModelIndex&)),
            vtkVisTabWidget->vtkVisPipelineView,
            SLOT(selectItem(const QModelIndex&)));
 
    vtkVisTabWidget->vtkVisPipelineView->setModel(_vtkVisPipeline.get());
    connect(vtkVisTabWidget->vtkVisPipelineView,
            SIGNAL(requestRemovePipelineItem(QModelIndex)),
            _vtkVisPipeline.get(), SLOT(removePipelineItem(QModelIndex)));
    connect(vtkVisTabWidget->vtkVisPipelineView,
            SIGNAL(requestAddPipelineFilterItem(QModelIndex)), this,
            SLOT(showAddPipelineFilterItemDialog(QModelIndex)));
    connect(vtkVisTabWidget, SIGNAL(requestViewUpdate()), visualizationWidget,
            SLOT(updateView()));
 
    connect(vtkVisTabWidget->vtkVisPipelineView,
            SIGNAL(actorSelected(vtkProp3D*)),
            reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SLOT(highlightActor(vtkProp3D*)));
    connect(_vtkVisPipeline.get(), SIGNAL(vtkVisPipelineChanged()),
            visualizationWidget, SLOT(updateView()));
 
    // Propagates selected vtk object in the pipeline to the pick interactor
    connect(vtkVisTabWidget->vtkVisPipelineView,
            SIGNAL(dataObjectSelected(vtkDataObject*)),
            reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SLOT(pickableDataObject(vtkDataObject*)));
    connect(reinterpret_cast<QObject*>(visualizationWidget->vtkPickCallback()),
            SIGNAL(actorPicked(vtkProp3D*)),
            vtkVisTabWidget->vtkVisPipelineView, SLOT(selectItem(vtkProp3D*)));
    connect(reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SIGNAL(elementPicked(vtkUnstructuredGridAlgorithm const* const,
                                 const unsigned)),
            this->_elementModel.get(),
            SLOT(setElement(vtkUnstructuredGridAlgorithm const* const,
                            const unsigned)));
    connect(reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SIGNAL(elementPicked(vtkUnstructuredGridAlgorithm const* const,
                                 const unsigned)),
            meshTabWidget->elementView, SLOT(updateView()));
    connect(reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SIGNAL(clearElementView()), this->_elementModel.get(),
            SLOT(clearView()));
    connect(reinterpret_cast<QObject*>(visualizationWidget->interactorStyle()),
            SIGNAL(elementPicked(vtkUnstructuredGridAlgorithm const* const,
                                 const unsigned)),
            this->_vtkVisPipeline.get(),
            SLOT(removeHighlightedMeshComponent()));
 
    connect(vtkVisTabWidget->vtkVisPipelineView,
            SIGNAL(meshAdded(MeshLib::Mesh*)), _meshModel.get(),
            SLOT(addMesh(MeshLib::Mesh*)));
 
    // Stack the data dock widgets together
    tabifyDockWidget(geoDock, mshDock);
    tabifyDockWidget(mshDock, modellingDock);
    tabifyDockWidget(modellingDock, stationDock);
 
    // Restore window geometry
    readSettings();
 
    // Get info on screens geometry(ies)
    _vtkWidget.reset(visualizationWidget->vtkWidget);
    for (auto const& screen : QGuiApplication::screens())
    {
        _screenGeometries.push_back(screen->availableGeometry());
    }
 
    // Setup import files menu
    QMenu* import_files_menu = createImportFilesMenu();  // owned by MainWindow
    menu_File->insertMenu(action_Exit, import_files_menu);
 
    // Setup recent files menu
    RecentFiles* recentFiles =
        new RecentFiles(this, SLOT(openRecentFile()), "recentFileList");
    connect(this, SIGNAL(fileUsed(QString)), recentFiles,
            SLOT(setCurrentFile(QString)));
    menu_File->insertMenu(action_Exit, recentFiles->menu());
 
    // Setup Windows menu
    QAction* showGeoDockAction = geoDock->toggleViewAction();
    showGeoDockAction->setStatusTip(tr("Shows / hides the geometry view"));
    connect(showGeoDockAction, SIGNAL(triggered(bool)), this,
            SLOT(showGeoDockWidget(bool)));
    menuWindows->addAction(showGeoDockAction);
 
    QAction* showStationDockAction = stationDock->toggleViewAction();
    showStationDockAction->setStatusTip(tr("Shows / hides the station view"));
    connect(showStationDockAction, SIGNAL(triggered(bool)), this,
            SLOT(showStationDockWidget(bool)));
    menuWindows->addAction(showStationDockAction);
 
    QAction* showMshDockAction = mshDock->toggleViewAction();
    showMshDockAction->setStatusTip(tr("Shows / hides the mesh view"));
    connect(showMshDockAction, SIGNAL(triggered(bool)), this,
            SLOT(showMshDockWidget(bool)));
    menuWindows->addAction(showMshDockAction);
 
    QAction* showModellingDockAction = modellingDock->toggleViewAction();
    showModellingDockAction->setStatusTip(tr("Shows / hides the Process view"));
    connect(showModellingDockAction, SIGNAL(triggered(bool)), this,
            SLOT(showConditionDockWidget(bool)));
    menuWindows->addAction(showModellingDockAction);
 
    QAction* showVisDockAction = vtkVisDock->toggleViewAction();
    showVisDockAction->setStatusTip(tr("Shows / hides the VTK Pipeline view"));
    connect(showVisDockAction, SIGNAL(triggered(bool)), this,
            SLOT(showVisDockWidget(bool)));
    menuWindows->addAction(showVisDockAction);
 
    // Presentation mode
    auto* presentationMenu = new QMenu(this);
    presentationMenu->setTitle("Presentation on");
    connect(presentationMenu, SIGNAL(aboutToShow()), this,
            SLOT(createPresentationMenu()));
    menuWindows->insertMenu(showVisDockAction, presentationMenu);
 
    _visPrefsDialog = std::make_unique<VisPrefsDialog>(*_vtkVisPipeline,
                                                       *visualizationWidget);
}

References _conditionModel, _elementModel, _geo_model, _meshModel, _processModel, _project, _screenGeometries, _visPrefsDialog, _vtkVisPipeline, _vtkWidget, convertMeshToGeometry(), convertPointsToStations(), createImportFilesMenu(), createPresentationMenu(), exportBoreholesToGMS(), fileUsed(), DataHolderLib::Project::getGEOObjects(), mapGeometry(), RecentFiles::menu(), open(), openRecentFile(), readSettings(), showAddPipelineFilterItemDialog(), showConditionDockWidget(), showDiagramPrefsDialog(), showGeoDockWidget(), showGeoNameDialog(), showLineEditDialog(), showMeshQualitySelectionDialog(), showMshDockWidget(), showStationDockWidget(), showStationNameDialog(), showVisDockWidget(), updateDataViews(), writeGeometryToFile(), and writeStationListToFile().

Member Function Documentation

about

void MainWindow::about ( )

protectedslot

Definition at line 904 of file mainwindow.cpp.

{
    QString about(
        "<a href='https://www.opengeosys.org'>www.opengeosys.org</a><br /><br "
        "/>");
    about.append(
        QString("Version: %1<br />")
            .arg(QString::fromStdString(GitInfoLib::GitInfo::ogs_version)));
 
    about.append(
        QString("Git commit: <a "
                "href='https://github.com/ufz/ogs/commit/%1'>%1</a><br />")
            .arg(QString::fromStdString(
                GitInfoLib::GitInfo::git_version_sha1_short)));
    about.append(QString("Built date: %1<br />")
                     .arg(QDate::currentDate().toString(Qt::ISODate)));
 
    QMessageBox::about(this, "About OpenGeoSys 6", about);
}

References about(), GitInfoLib::GitInfo::git_version_sha1_short, and GitInfoLib::GitInfo::ogs_version.

Referenced by about().

callGMSH

void MainWindow::callGMSH ( std::vector< std::string > &  selectedGeometries, unsigned  param1, double  param2, double  param3, double  param4, bool  delete_geo_file  )

protectedslot

Function calls for generating GMSH files from the GUI.

Definition at line 1126 of file mainwindow.cpp.

{
    if (!selectedGeometries.empty())
    {
        INFO("Start meshing ...");
 
        QString fileName("");
        QString dir_str = this->getLastUsedDir();
 
        if (!delete_geo_file)
        {
            fileName = QFileDialog::getSaveFileName(
                this, "Save GMSH-file as",
                LastSavedFileDirectory::getDir() + "tmp_gmsh.geo",
                "GMSH geometry files (*.geo)");
        }
        else
        {
            fileName = "tmp_gmsh.geo";
        }
 
        if (!fileName.isEmpty())
        {
            try
            {
                if (param4 == -1)
                {  // adaptive meshing selected
                    FileIO::GMSH::GMSHInterface gmsh_io(
                        _project.getGEOObjects(), true,
                        FileIO::GMSH::MeshDensityAlgorithm::AdaptiveMeshDensity,
                        param2, param3, param1, selectedGeometries, false,
                        false);
                    BaseLib::IO::writeStringToFile(gmsh_io.writeToString(),
                                                   fileName.toStdString());
                }
                else
                {  // homogeneous meshing selected
                    FileIO::GMSH::GMSHInterface gmsh_io(
                        _project.getGEOObjects(), true,
                        FileIO::GMSH::MeshDensityAlgorithm::FixedMeshDensity,
                        param4, param3, param1, selectedGeometries, false,
                        false);
                    BaseLib::IO::writeStringToFile(gmsh_io.writeToString(),
                                                   fileName.toStdString());
                }
 
                if (system(nullptr) != 0)  // command processor available
                {
                    QSettings settings;
                    std::string gmsh_path =
                        settings.value("DataExplorerGmshPath")
                            .toString()
                            .toStdString();
 
                    if (!gmsh_path.empty())
                    {
                        std::string fname(fileName.toStdString());
                        std::string gmsh_command =
                            "\"" + gmsh_path + "\" -2 -algo meshadapt " + fname;
                        std::size_t pos(fname.rfind("."));
                        if (pos != std::string::npos)
                        {
                            fname = fname.substr(0, pos);
                        }
                        gmsh_command += " -o " + fname + ".msh";
                        // Newer gmsh versions write a newer file format for
                        // meshes per default. At the moment we can't read this
                        // new format. This is a switch for gmsh to write the
                        // 'old' file format.
                        gmsh_command += " -format msh22";
                        auto const return_value =
                            std::system(gmsh_command.c_str());
                        if (return_value != 0)
                        {
                            QString const message =
                                "Execution of gmsh command returned non-zero "
                                "status, " +
                                QString::number(return_value);
                            OGSError::box(message, "Error");
                        }
                        else
                        {
                            this->loadFile(ImportFileType::GMSH,
                                           fileName.left(fileName.length() - 3)
                                               .append("msh"));
                        }
                    }
                    else
                    {
                        OGSError::box("Location of GMSH not specified.",
                                      "Error");
                    }
                }
                else
                {
                    OGSError::box(
                        "Error executing command gmsh - no command processor "
                        "available",
                        "Error");
                }
            }
            catch (std::runtime_error& error)
            {
                OGSError::box(QString(error.what()) +
                                  QString("\n Please cleanup the input data."),
                              "ERROR");
            }
            if (delete_geo_file)
            {
                BaseLib::removeFile(fileName.toStdString());
            }
        }
    }
    else
        INFO("No geometry information selected.");
    QApplication::restoreOverrideCursor();
}

References _project, FileIO::GMSH::AdaptiveMeshDensity, OGSError::box(), FileIO::GMSH::FixedMeshDensity, LastSavedFileDirectory::getDir(), DataHolderLib::Project::getGEOObjects(), getLastUsedDir(), ImportFileType::GMSH, INFO(), loadFile(), BaseLib::removeFile(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Referenced by showGMSHPrefsDialog().

closeEvent()

void MainWindow::closeEvent ( QCloseEvent *  event )

overrideprotected

Definition at line 434 of file mainwindow.cpp.

{
    writeSettings();
    QWidget::closeEvent(event);
}

References writeSettings().

convertMeshToGeometry

void MainWindow::convertMeshToGeometry ( const MeshLib::Mesh *  mesh )

protectedslot

Definition at line 1113 of file mainwindow.cpp.

{
    MeshToolsLib::convertMeshToGeo(*mesh, _project.getGEOObjects());
}

References _project, MeshToolsLib::convertMeshToGeo(), and DataHolderLib::Project::getGEOObjects().

Referenced by MainWindow().

convertPointsToStations

void MainWindow::convertPointsToStations ( std::string const &  geo_name )

protectedslot

Definition at line 1378 of file mainwindow.cpp.

{
    std::string stn_name = geo_name + " Stations";
    int ret = GeoLib::geoPointsToStations(_project.getGEOObjects(), geo_name,
                                          stn_name);
    if (ret == 1)
    {
        OGSError::box("No points found to convert.");
    }
}

References _project, OGSError::box(), GeoLib::geoPointsToStations(), and DataHolderLib::Project::getGEOObjects().

Referenced by MainWindow().

createImportFilesMenu()

QMenu * MainWindow::createImportFilesMenu ( )

private

Definition at line 924 of file mainwindow.cpp.

{
    QMenu* importFiles = new QMenu("&Import Files", this);
    importFiles->addAction("&FEFLOW Files...",
                           [this] { open(ImportFileType::FEFLOW); });
    importFiles->addAction("SMS/G&MS Files...",
                           [this] { open(ImportFileType::GMS); });
    importFiles->addAction("&GMSH Files...",
                           [this] { open(ImportFileType::GMSH); });
    importFiles->addAction("&Gocad TSurface...",
                           [this] { open(ImportFileType::GOCAD_TSURF); });
#ifdef OGS_USE_NETCDF
    importFiles->addAction("&NetCDF Files...",
                           [this] { open(ImportFileType::NETCDF); });
#endif  // OGS_USE_NETCDF
    importFiles->addAction("&Petrel Files...", [this] { loadPetrelFiles(); });
    importFiles->addAction("&Raster Files...",
                           [this] { open(ImportFileType::RASTER); });
    importFiles->addAction("&Shape Files...",
                           [this] { open(ImportFileType::SHAPE); });
    importFiles->addAction("&TetGen Files...",
                           [this] { open(ImportFileType::TETGEN); });
    importFiles->addAction("&VTK Files...",
                           [this] { open(ImportFileType::VTK); });
    return importFiles;
}

References ImportFileType::FEFLOW, ImportFileType::GMS, ImportFileType::GMSH, ImportFileType::GOCAD_TSURF, loadPetrelFiles(), ImportFileType::NETCDF, open(), ImportFileType::RASTER, ImportFileType::SHAPE, ImportFileType::TETGEN, and ImportFileType::VTK.

Referenced by MainWindow().

createPresentationMenu

void MainWindow::createPresentationMenu ( )

protectedslot

Definition at line 1561 of file mainwindow.cpp.

{
    auto* menu = static_cast<QMenu*>(QObject::sender());
    menu->clear();
    if (!_vtkWidget->parent())
    {
        QAction* action = new QAction("Quit presentation mode", menu);
        connect(action, SIGNAL(triggered()), this,
                SLOT(quitPresentationMode()));
        action->setShortcutContext(Qt::WidgetShortcut);
        action->setShortcut(QKeySequence(Qt::Key_Escape));
        menu->addAction(action);
    }
    else
    {
        int count = 0;
        const int currentScreen =
            QApplication::desktop()->screenNumber(visualizationWidget);
        foreach (QRect screenGeo, _screenGeometries)
        {
            Q_UNUSED(screenGeo);
            QAction* action =
                new QAction(QString("On screen %1").arg(count), menu);
            connect(action, SIGNAL(triggered()), this,
                    SLOT(startPresentationMode()));
            if (count == currentScreen)
            {
                action->setEnabled(false);
            }
            menu->addAction(action);
            ++count;
        }
    }
}

References _screenGeometries, _vtkWidget, quitPresentationMode(), and startPresentationMode().

Referenced by MainWindow().

exportBoreholesToGMS

void MainWindow::exportBoreholesToGMS ( std::string  listName, std::string  fileName  )

protectedslot

Function calls for GMS export.

Definition at line 1118 of file mainwindow.cpp.

{
    const std::vector<GeoLib::Point*>* stations(
        _project.getGEOObjects().getStationVec(listName));
    GMSInterface::writeBoreholesToGMS(stations, fileName);
}

References _project, DataHolderLib::Project::getGEOObjects(), GeoLib::GEOObjects::getStationVec(), and FileIO::GMSInterface::writeBoreholesToGMS().

Referenced by MainWindow().

FEMTestStart

void MainWindow::FEMTestStart ( )

protectedslot

Testing functionality for connection to FEM lib.

Definition at line 1467 of file mainwindow.cpp.

{}

fileOpenRequested

void MainWindow::fileOpenRequested ( int  )

signal

fileUsed

void MainWindow::fileUsed ( QString  filename )

signal

Referenced by MainWindow(), and loadFile().

getLastUsedDir()

QString MainWindow::getLastUsedDir ( )

private

Definition at line 1641 of file mainwindow.cpp.

{
    QSettings settings;
    QString fileName("");
    QStringList files = settings.value("recentFileList").toStringList();
    if (!files.empty())
    {
        return QFileInfo(files[0]).absolutePath();
    }
 
    return QDir::homePath();
}

Referenced by callGMSH().

HideWindow()

void MainWindow::HideWindow

(

)

Definition at line 1474 of file mainwindow.cpp.

{
    this->hide();
}

loadFEMConditionsFromFile()

void MainWindow::loadFEMConditionsFromFile ( const QString &  fileName, std::string  geoName = ""  )

private

loadFile()

void MainWindow::loadFile ( ImportFileType::type  t, const QString &  fileName  )

private

Definition at line 575 of file mainwindow.cpp.

{
    QFile file(fileName);
    if (!file.exists())
    {
        QMessageBox::warning(this, tr("Application"),
                             tr("Cannot read file %1:\n%2.")
                                 .arg(fileName)
                                 .arg(file.errorString()));
        return;
    }
 
    QApplication::setOverrideCursor(Qt::WaitCursor);
    QFileInfo fi(fileName);
    QSettings settings;
    QDir dir = QDir(fileName);
    std::string base =
        fi.absoluteDir().absoluteFilePath(fi.completeBaseName()).toStdString();
 
    if (t == ImportFileType::OGS || t == ImportFileType::OGS_GEO ||
        t == ImportFileType::OGS_STN || t == ImportFileType::OGS_MSH)
    {
        if (fi.suffix().toLower() == "gli")
        {
            std::string unique_name;
            std::vector<std::string> errors;
            std::string const gmsh_path =
                settings.value("DataExplorerGmshPath").toString().toStdString();
            if (!FileIO::Legacy::readGLIFileV4(fileName.toStdString(),
                                               _project.getGEOObjects(),
                                               unique_name, errors, gmsh_path))
            {
                for (auto& error : errors)
                {
                    OGSError::box(QString::fromStdString(error));
                }
            }
        }
        else if (fi.suffix().toLower() == "prj")
        {
            XmlPrjInterface xml(_project);
            if (xml.readFile(fileName))
            {
                _meshModel->updateModel();
                _processModel->updateModel();
            }
            else
            {
                OGSError::box(
                    "Failed to load project file.\n Please see console for "
                    "details.");
            }
        }
        else if (fi.suffix().toLower() == "gml")
        {
            GeoLib::IO::XmlGmlInterface xml(_project.getGEOObjects());
            try
            {
                if (!xml.readFile(fileName))
                {
                    OGSError::box(
                        "Failed to load geometry.\n Please see console for "
                        "details.");
                }
            }
            catch (std::runtime_error const& err)
            {
                OGSError::box(err.what(),
                              "Failed to read file `" + fileName + "'");
            }
        }
        // OpenGeoSys observation station files (incl. boreholes)
        else if (fi.suffix().toLower() == "stn")
        {
            GeoLib::IO::XmlStnInterface xml(_project.getGEOObjects());
            if (!xml.readFile(fileName))
            {
                OGSError::box(
                    "Failed to load station data.\n Please see console for "
                    "details.");
            }
        }
        // OpenGeoSys mesh files
        else if (fi.suffix().toLower() == "msh" ||
                 fi.suffix().toLower() == "vtu" ||
                 fi.suffix().toLower() == "vtk")
        {
#ifndef NDEBUG
            QElapsedTimer myTimer;
            myTimer.start();
#endif
            std::unique_ptr<MeshLib::Mesh> mesh(
                MeshLib::IO::readMeshFromFile(fileName.toStdString()));
#ifndef NDEBUG
            INFO("Mesh loading time: {:d} ms.", myTimer.restart());
#endif
            if (mesh)
            {
                _meshModel->addMesh(std::move(mesh));
            }
            else
            {
                OGSError::box("Failed to load mesh file.");
            }
#ifndef NDEBUG
            INFO("Mesh model setup time: {:d} ms.", myTimer.elapsed());
#endif
        }
 
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
        emit fileUsed(fileName);
    }
    else if (t == ImportFileType::FEFLOW)
    {
        if (fi.suffix().toLower() == "fem")  // FEFLOW model files
        {
            FileIO::FEFLOWMeshInterface feflowMeshIO;
            std::unique_ptr<MeshLib::Mesh> mesh(
                feflowMeshIO.readFEFLOWFile(fileName.toStdString()));
            if (mesh)
            {
                _meshModel->addMesh(std::move(mesh));
            }
            else
            {
                OGSError::box("Failed to load a FEFLOW mesh.");
            }
            FileIO::FEFLOWGeoInterface feflowGeoIO;
            feflowGeoIO.readFEFLOWFile(fileName.toStdString(),
                                       _project.getGEOObjects());
        }
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
    }
    else if (t == ImportFileType::GMS)
    {
        if (fi.suffix().toLower() == "txt")  // GMS borehole files
        {
            std::vector<GeoLib::Point*> boreholes;
            std::string name = fi.baseName().toStdString();
 
            if (GMSInterface::readBoreholesFromGMS(boreholes,
                                                   fileName.toStdString()))
            {
                _project.getGEOObjects().addStationVec(std::move(boreholes),
                                                       name);
            }
            else
            {
                OGSError::box("Error reading GMS file.");
            }
        }
        else if (fi.suffix().toLower() == "2dm" ||
                 fi.suffix().toLower() == "3dm")  // GMS mesh files
        {
            std::string name = fileName.toStdString();
            std::unique_ptr<MeshLib::Mesh> mesh(GMSInterface::readMesh(name));
            if (mesh)
            {
                _meshModel->addMesh(std::move(mesh));
            }
            else
            {
                OGSError::box("Failed to load a GMS mesh.");
            }
        }
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
    }
    else if (t == ImportFileType::GMSH)
    {
        std::string msh_name(fileName.toStdString());
        if (FileIO::GMSH::isGMSHMeshFile(msh_name))
        {
            std::unique_ptr<MeshLib::Mesh> mesh(
                FileIO::GMSH::readGMSHMesh(msh_name));
            if (mesh)
            {
                _meshModel->addMesh(std::move(mesh));
            }
            else
            {
                OGSError::box("Failed to load a GMSH mesh.");
            }
        }
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
    }
    else if (t == ImportFileType::GOCAD_TSURF)
    {
        std::string file_name(fileName.toStdString());
        std::vector<std::unique_ptr<MeshLib::Mesh>> meshes;
        if (FileIO::Gocad::GocadAsciiReader::readFile(file_name, meshes))
        {
            for (auto& mesh : meshes)
            {
                if (mesh != nullptr)
                {
                    _meshModel->addMesh(std::move(mesh));
                }
            }
        }
        else
        {
            OGSError::box("Error reading file.");
        }
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
    }
#ifdef OGS_USE_NETCDF
    else if (t == ImportFileType::NETCDF)  // CH  01.2012
    {
        NetCdfConfigureDialog dlg(fileName.toStdString());
        dlg.exec();
        if (dlg.getMesh())
        {
            std::unique_ptr<MeshLib::Mesh> mesh(dlg.getMesh());
            mesh->setName(dlg.getName());
            _meshModel->addMesh(std::move(mesh));
        }
        if (dlg.getRaster())
            _vtkVisPipeline->addPipelineItem(dlg.getRaster());
 
        settings.setValue("lastOpenedRasterFileDirectory", dir.absolutePath());
    }
#endif  // OGS_USE_NETCDF
    else if (t == ImportFileType::RASTER)
    {
        VtkGeoImageSource* geoImage = VtkGeoImageSource::New();
        if (geoImage->readImage(fileName))
        {
            _vtkVisPipeline->addPipelineItem(geoImage);
        }
        else
        {
            geoImage->Delete();
            OGSError::box("Error reading raster.");
        }
        settings.setValue("lastOpenedRasterFileDirectory", dir.absolutePath());
    }
    else if (t == ImportFileType::POLYRASTER)
    {
        QImage raster;
        vtkImageAlgorithm* img = VtkRaster::loadImage(fileName.toStdString());
        VtkBGImageSource* bg = VtkBGImageSource::New();
        double* origin = img->GetOutput()->GetOrigin();
        bg->SetRaster(img, origin[0], origin[1],
                      img->GetOutput()->GetSpacing()[0]);
        bg->SetName(fileName);
        _vtkVisPipeline->addPipelineItem(bg);
        settings.setValue("lastOpenedRasterFileDirectory", dir.absolutePath());
    }
    else if (t == ImportFileType::SHAPE)
    {
        SHPImportDialog dlg(
            fileName.toStdString(), _project.getGEOObjects(),
            settings.value("DataExplorerGmshPath").toString().toStdString());
        dlg.exec();
        QDir dir = QDir(fileName);
        settings.setValue("lastOpenedShapeFileDirectory", dir.absolutePath());
    }
    else if (t == ImportFileType::TETGEN)
    {
        if (fi.suffix().toLower().compare("poly") == 0 ||
            fi.suffix().toLower().compare("smesh") == 0)
        {
            FileIO::TetGenInterface tetgen;
            tetgen.readTetGenGeometry(fileName.toStdString(),
                                      _project.getGEOObjects());
        }
        else
        {
            settings.setValue("lastOpenedTetgenFileDirectory",
                              QFileInfo(fileName).absolutePath());
            QString element_fname(fi.path() + "/" + fi.completeBaseName() +
                                  ".ele");
 
            if (!fileName.isEmpty())
            {
                FileIO::TetGenInterface tetgen;
                std::unique_ptr<MeshLib::Mesh> mesh(tetgen.readTetGenMesh(
                    fileName.toStdString(), element_fname.toStdString()));
                if (mesh)
                {
                    _meshModel->addMesh(std::move(mesh));
                }
                else
                {
                    OGSError::box("Failed to load a TetGen mesh.");
                }
            }
        }
    }
    else if (t == ImportFileType::VTK)
    {
        _vtkVisPipeline->loadFromFile(fileName);
        settings.setValue("lastOpenedVtkFileDirectory", dir.absolutePath());
    }
 
    QApplication::restoreOverrideCursor();
    updateDataViews();
}

References _meshModel, _processModel, _project, _vtkVisPipeline, GeoLib::GEOObjects::addStationVec(), OGSError::box(), ImportFileType::FEFLOW, fileUsed(), DataHolderLib::Project::getGEOObjects(), NetCdfConfigureDialog::getMesh(), NetCdfConfigureDialog::getName(), NetCdfConfigureDialog::getRaster(), ImportFileType::GMS, ImportFileType::GMSH, ImportFileType::GOCAD_TSURF, INFO(), FileIO::GMSH::isGMSHMeshFile(), VtkRaster::loadImage(), ImportFileType::NETCDF, VtkBGImageSource::New(), VtkGeoImageSource::New(), ImportFileType::OGS, ImportFileType::OGS_GEO, ImportFileType::OGS_MSH, ImportFileType::OGS_STN, ImportFileType::POLYRASTER, ImportFileType::RASTER, FileIO::GMSInterface::readBoreholesFromGMS(), FileIO::FEFLOWMeshInterface::readFEFLOWFile(), FileIO::FEFLOWGeoInterface::readFEFLOWFile(), FileIO::XmlPrjInterface::readFile(), GeoLib::IO::XmlGmlInterface::readFile(), GeoLib::IO::XmlStnInterface::readFile(), FileIO::Gocad::GocadAsciiReader::readFile(), FileIO::Legacy::readGLIFileV4(), FileIO::GMSH::readGMSHMesh(), VtkGeoImageSource::readImage(), FileIO::GMSInterface::readMesh(), MeshLib::IO::readMeshFromFile(), FileIO::TetGenInterface::readTetGenGeometry(), FileIO::TetGenInterface::readTetGenMesh(), VtkAlgorithmProperties::SetName(), VtkBGImageSource::SetRaster(), ImportFileType::SHAPE, ImportFileType::TETGEN, updateDataViews(), and ImportFileType::VTK.

Referenced by callGMSH(), loadFileOnStartUp(), open(), and openRecentFile().

loadFileOnStartUp()

void MainWindow::loadFileOnStartUp

(

const QString &

fileName

)

Definition at line 1479 of file mainwindow.cpp.

{
    QString ext = QFileInfo(fileName).suffix();
    if (ext == "msh" || ext == "vtu" || ext == "gli" || ext == "gml")
    {
        this->loadFile(ImportFileType::OGS, fileName);
    }
}

References loadFile(), and ImportFileType::OGS.

loadPetrelFiles

void MainWindow::loadPetrelFiles ( )

protectedslot

Definition at line 951 of file mainwindow.cpp.

{
    QSettings settings;
    QStringList sfc_file_names = QFileDialog::getOpenFileNames(
        this, "Select surface data file(s) to import", "", "Petrel files (*)");
    QStringList well_path_file_names = QFileDialog::getOpenFileNames(
        this, "Select well path data file(s) to import", "",
        "Petrel files (*)");
    if (!sfc_file_names.empty() || !well_path_file_names.empty())
    {
        QStringList::const_iterator it = sfc_file_names.begin();
        std::list<std::string> sfc_files;
        while (it != sfc_file_names.end())
        {
            sfc_files.push_back((*it).toStdString());
            ++it;
        }
 
        it = well_path_file_names.begin();
        std::list<std::string> well_path_files;
        while (it != well_path_file_names.end())
        {
            well_path_files.push_back((*it).toStdString());
            ++it;
        }
 
        std::string unique_str(*(sfc_files.begin()));
 
        PetrelInterface(sfc_files, well_path_files, unique_str,
                        &_project.getGEOObjects());
 
        QDir dir = QDir(sfc_file_names.at(0));
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
    }
}

References _project, and DataHolderLib::Project::getGEOObjects().

Referenced by createImportFilesMenu().

mapGeometry

void MainWindow::mapGeometry ( const std::string &  geo_name )

protectedslot

Definition at line 1016 of file mainwindow.cpp.

{
    GeoOnMeshMappingDialog dlg(this->_project.getMeshObjects());
    if (dlg.exec() != QDialog::Accepted)
    {
        return;
    }
 
    int choice(dlg.getDataSetChoice());
 
    QString file_name("");
    if (choice < 2)  // load something from a file
    {
        QString file_type[2] = {"OpenGeoSys mesh files (*.vtu *.msh)",
                                "Raster files(*.asc *.grd *.xyz)"};
        QSettings settings;
        file_name = QFileDialog::getOpenFileName(
            this,
            "Select file for mapping",
            settings.value("lastOpenedFileDirectory").toString(),
            file_type[choice]);
        if (file_name.isEmpty())
        {
            return;
        }
        QDir dir = QDir(file_name);
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
    }
 
    MeshGeoToolsLib::GeoMapper geo_mapper(_project.getGEOObjects(), geo_name);
    QFileInfo fi(file_name);
    if (choice == 1)  // load raster from file
    {
        if (fi.suffix().toLower() == "asc" || fi.suffix().toLower() == "grd")
        {
            std::unique_ptr<GeoLib::Raster> raster(
                FileIO::AsciiRasterInterface::getRasterFromASCFile(
                    file_name.toStdString()));
            if (raster)
            {
                geo_mapper.mapOnDEM(std::move(raster));
            }
            else
            {
                OGSError::box("Error reading raster file.");
            }
            _geo_model->updateGeometry(geo_name);
        }
        else
        {
            OGSError::box("The selected file is no supported raster file.");
        }
        return;
    }
 
    MeshLib::Mesh* mesh(nullptr);
    if (choice == 0)  // load mesh from file
    {
        if (fi.suffix().toLower() == "vtu" || fi.suffix().toLower() == "vtk" ||
            fi.suffix().toLower() == "msh")
        {
            mesh = MeshLib::IO::readMeshFromFile(file_name.toStdString());
        }
        else
        {
            OGSError::box("The selected file is no supported mesh file.");
            return;
        }
    }
    else
    {  // use mesh from ProjectData
        mesh = _project.getMeshObjects()[choice - 2].get();
    }
 
    std::string new_geo_name = dlg.getNewGeoName();
 
    if (new_geo_name.empty())
    {
        geo_mapper.mapOnMesh(mesh);
        _geo_model->updateGeometry(geo_name);
    }
    else
    {
        GeoLib::DuplicateGeometry dup(_project.getGEOObjects(), geo_name,
                                      new_geo_name);
        new_geo_name = dup.getFinalizedOutputName();
        MeshGeoToolsLib::GeoMapper mapper(_project.getGEOObjects(),
                                          new_geo_name);
        mapper.advancedMapOnMesh(*mesh);
        _geo_model->updateGeometry(new_geo_name);
    }
    if (choice == 0)
    {
        delete mesh;
    }
}

References _geo_model, _project, MeshGeoToolsLib::GeoMapper::advancedMapOnMesh(), OGSError::box(), GeoOnMeshMappingDialog::getDataSetChoice(), GeoLib::DuplicateGeometry::getFinalizedOutputName(), DataHolderLib::Project::getGEOObjects(), DataHolderLib::Project::getMeshObjects(), GeoOnMeshMappingDialog::getNewGeoName(), FileIO::AsciiRasterInterface::getRasterFromASCFile(), MeshGeoToolsLib::GeoMapper::mapOnDEM(), MeshGeoToolsLib::GeoMapper::mapOnMesh(), and MeshLib::IO::readMeshFromFile().

Referenced by MainWindow().

on_actionExportObj_triggered

void MainWindow::on_actionExportObj_triggered ( bool  checked = false )

protectedslot

Definition at line 1540 of file mainwindow.cpp.

{
    Q_UNUSED(checked)
    QSettings settings;
    QString fileName = QFileDialog::getSaveFileName(
        this, "Save scene to Wavefront OBJ files",
        settings.value("lastExportedFileDirectory").toString(), ";;");
    if (!fileName.isEmpty())
    {
        QDir dir = QDir(fileName);
        settings.setValue("lastExportedFileDirectory", dir.absolutePath());
 
        vtkOBJExporter* exporter = vtkOBJExporter::New();
        exporter->SetFilePrefix(fileName.toStdString().c_str());
        exporter->SetRenderWindow(
            visualizationWidget->vtkWidget->renderWindow());
        exporter->Write();
        exporter->Delete();
    }
}

on_actionExportVRML2_triggered

void MainWindow::on_actionExportVRML2_triggered ( bool  checked = false )

protectedslot

Definition at line 1518 of file mainwindow.cpp.

{
    Q_UNUSED(checked)
    QSettings settings;
    QString fileName = QFileDialog::getSaveFileName(
        this, "Save scene to VRML file",
        settings.value("lastExportedFileDirectory").toString(),
        "VRML files (*.wrl);;");
    if (!fileName.isEmpty())
    {
        QDir dir = QDir(fileName);
        settings.setValue("lastExportedFileDirectory", dir.absolutePath());
 
        vtkVRMLExporter* exporter = vtkVRMLExporter::New();
        exporter->SetFileName(fileName.toStdString().c_str());
        exporter->SetRenderWindow(
            visualizationWidget->vtkWidget->renderWindow());
        exporter->Write();
        exporter->Delete();
    }
}

on_actionExportVTK_triggered

void MainWindow::on_actionExportVTK_triggered ( bool  checked = false )

protectedslot

Definition at line 1488 of file mainwindow.cpp.

{
    Q_UNUSED(checked)
    QSettings settings;
    int count = 0;
    QString const filename = QFileDialog::getSaveFileName(
        this,
        "Export object to vtk-files",
        settings.value("lastExportedFileDirectory").toString(),
        "VTK files (*.vtp *.vtu)");
    if (!filename.isEmpty())
    {
        QDir const dir = QDir(filename);
        settings.setValue("lastExportedFileDirectory", dir.absolutePath());
 
        std::string const basename =
            QFileInfo(filename).path().toStdString() + "/" +
            QFileInfo(filename).baseName().toStdString();
        TreeModelIterator it(_vtkVisPipeline.get());
        ++it;
        while (*it)
        {
            std::string const name = basename + std::to_string(++count) + "-" +
                                     (*it)->data(0).toString().toStdString();
            static_cast<VtkVisPipelineItem*>(*it)->writeToFile(name);
            ++it;
        }
    }
}

References _vtkVisPipeline, and VtkVisPipelineItem::writeToFile().

open

void MainWindow::open ( int  file_type = 0 )

protectedslot

Function calls for opening files.

Definition at line 500 of file mainwindow.cpp.

{
    QSettings settings;
    auto t = static_cast<ImportFileType::type>(file_type);
    QString type_str = QString::fromStdString(
        (ImportFileType::convertImportFileTypeToString(t)));
    QString fileName = QFileDialog::getOpenFileName(
        this, "Select " + type_str + " file to import",
        settings.value("lastOpenedFileDirectory").toString(),
        QString::fromStdString(ImportFileType::getFileSuffixString(t)));
    if (!fileName.isEmpty())
    {
        loadFile(t, fileName);
        QDir dir = QDir(fileName);
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
    }
}

References ImportFileType::convertImportFileTypeToString(), ImportFileType::getFileSuffixString(), and loadFile().

Referenced by MainWindow(), and createImportFilesMenu().

openRecentFile

void MainWindow::openRecentFile ( )

protectedslot

Definition at line 518 of file mainwindow.cpp.

{
    auto* action = qobject_cast<QAction*>(sender());
    if (action)
    {
        loadFile(ImportFileType::OGS, action->data().toString());
    }
}

References loadFile(), and ImportFileType::OGS.

Referenced by MainWindow().

quitPresentationMode

void MainWindow::quitPresentationMode ( )

protectedslot

Definition at line 1625 of file mainwindow.cpp.

{
    // Remove the quit action
    QAction* action = _vtkWidget->actions().back();
    _vtkWidget->removeAction(action);
    delete action;
 
    // Add the widget back to visualization widget
    visualizationWidget->layout()->addWidget(_vtkWidget.get());
 
    QMainWindow::centralWidget()->show();
 
    // Restore the previously saved QMainWindow state
    this->restoreState(_windowState);
}

References _vtkWidget, and _windowState.

Referenced by createPresentationMenu(), and startPresentationMode().

readSettings()

void MainWindow::readSettings ( )

private

Definition at line 882 of file mainwindow.cpp.

{
    QSettings settings;
 
    restoreGeometry(settings.value("windowGeometry").toByteArray());
    restoreState(settings.value("windowState").toByteArray());
}

Referenced by MainWindow().

save

void MainWindow::save ( )

protectedslot

Function calls for saving files.

Definition at line 527 of file mainwindow.cpp.

{
    QString fileName = QFileDialog::getSaveFileName(
        this,
        "Save data as",
        LastSavedFileDirectory::getDir(),
        "GeoSys project (*.prj);;GMSH geometry files (*.geo)");
 
    if (fileName.isEmpty())
    {
        OGSError::box("No filename specified.");
        return;
    }
 
    QFileInfo fi(fileName);
    LastSavedFileDirectory::setDir(fileName);
 
    if (fi.suffix().toLower() == "prj")
    {
        XmlPrjInterface xml(_project);
        BaseLib::IO::writeStringToFile(xml.writeToString(),
                                       fileName.toStdString());
    }
    else if (fi.suffix().toLower() == "geo")
    {
        auto const selected_geometries =
            _project.getGEOObjects().getGeometryNames();
 
        // values necessary also for the adaptive meshing
        const double point_density = 0;
        const double station_density = point_density;
        const int max_pnts_per_leaf = 0;
 
        FileIO::GMSH::GMSHInterface gmsh_io(
            _project.getGEOObjects(), true,
            FileIO::GMSH::MeshDensityAlgorithm::FixedMeshDensity, point_density,
            station_density, max_pnts_per_leaf, selected_geometries, false,
            false);
        bool const success = BaseLib::IO::writeStringToFile(
            gmsh_io.writeToString(), fileName.toStdString());
 
        if (!success)
        {
            OGSError::box(" No geometry available\n to write to geo-file");
        }
    }
}

References _project, OGSError::box(), FileIO::GMSH::FixedMeshDensity, LastSavedFileDirectory::getDir(), GeoLib::GEOObjects::getGeometryNames(), DataHolderLib::Project::getGEOObjects(), LastSavedFileDirectory::setDir(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

showAddPipelineFilterItemDialog

void MainWindow::showAddPipelineFilterItemDialog ( QModelIndex  parentIndex )

protectedslot

Definition at line 987 of file mainwindow.cpp.

{
    VtkAddFilterDialog dlg(*_vtkVisPipeline, parentIndex);
    dlg.exec();
}

References _vtkVisPipeline.

Referenced by MainWindow().

showConditionDockWidget

void MainWindow::showConditionDockWidget ( bool  show )

protectedslot

Definition at line 476 of file mainwindow.cpp.

{
    if (show)
    {
        modellingDock->show();
    }
    else
    {
        modellingDock->hide();
    }
}

Referenced by MainWindow().

showCreateStructuredGridDialog

void MainWindow::showCreateStructuredGridDialog ( )

protectedslot

Creates a structured grid with user-specified parameters.

Definition at line 1329 of file mainwindow.cpp.

{
    CreateStructuredGridDialog dlg;
    connect(&dlg, SIGNAL(meshAdded(MeshLib::Mesh*)), _meshModel.get(),
            SLOT(addMesh(MeshLib::Mesh*)));
    dlg.exec();
}

References _meshModel.

showDataExplorerSettingsDialog

void MainWindow::showDataExplorerSettingsDialog ( )

protectedslot

Definition at line 1461 of file mainwindow.cpp.

{
    DataExplorerSettingsDialog dlg;
    dlg.exec();
}

showDiagramPrefsDialog [1/2]

void MainWindow::showDiagramPrefsDialog ( )

protectedslot

Calls the diagram prefs dialog from the Tools menu.

Definition at line 1274 of file mainwindow.cpp.

{
    QSettings settings;
    QString fileName = QFileDialog::getOpenFileName(
        this, "Select data file to open",
        settings.value("lastOpenedFileDirectory").toString(),
        "Text files (*.txt);;All files (* *.*)");
    if (!fileName.isEmpty())
    {
        QDir dir = QDir(fileName);
        settings.setValue("lastOpenedFileDirectory", dir.absolutePath());
        auto* prefs = new DiagramPrefsDialog(fileName);
        prefs->setAttribute(Qt::WA_DeleteOnClose);
        prefs->show();
    }
}

Referenced by MainWindow().

showDiagramPrefsDialog [2/2]

void MainWindow::showDiagramPrefsDialog ( QModelIndex &  index )

protectedslot

Calls the diagram prefs dialog from the station list (i.e. for a specific station).

Definition at line 1256 of file mainwindow.cpp.

{
    QString listName;
    GeoLib::Station* stn =
        _geo_model->getStationModel()->stationFromIndex(index, listName);
 
    if (dynamic_cast<GeoLib::StationBorehole*>(stn))
    {
        OGSError::box("No time series data available for borehole.");
    }
    else if (dynamic_cast<GeoLib::Station*>(stn) && stn->getSensorData())
    {
        auto* prefs(new DiagramPrefsDialog(stn));
        prefs->setAttribute(Qt::WA_DeleteOnClose);
        prefs->show();
    }
}

References _geo_model, OGSError::box(), and GeoLib::Station::getSensorData().

showFileConverter

void MainWindow::showFileConverter ( )

protectedslot

Calls the OGSFileConverter as an external tool.

Definition at line 1246 of file mainwindow.cpp.

{
    QSettings settings;
    auto* dlg = new OGSFileConverter(
        settings.value("DataExplorerGmshPath").toString().toStdString(), this);
    dlg->setAttribute(Qt::WA_DeleteOnClose);
    dlg->show();
    dlg->raise();
}

showGeoDockWidget

void MainWindow::showGeoDockWidget ( bool  show )

protectedslot

Definition at line 440 of file mainwindow.cpp.

{
    if (show)
    {
        geoDock->show();
    }
    else
    {
        geoDock->hide();
    }
}

Referenced by MainWindow().

showGeoNameDialog

void MainWindow::showGeoNameDialog ( const std::string &  geometry_name, const GeoLib::GEOTYPE  object_type, std::size_t  id  )

protectedslot

Allows setting the name for a geometric object.

Definition at line 1291 of file mainwindow.cpp.

{
    std::string old_name = _project.getGEOObjects().getElementNameByID(
        geometry_name, object_type, id);
    SetNameDialog dlg(GeoLib::convertGeoTypeToString(object_type), id,
                      old_name);
    if (dlg.exec() != QDialog::Accepted)
    {
        return;
    }
 
    _geo_model->addNameForElement(geometry_name, object_type, id,
                                  dlg.getNewName());
    static_cast<GeoTreeModel*>(this->geoTabWidget->treeView->model())
        ->setNameForItem(geometry_name, object_type, id,
                         _project.getGEOObjects().getElementNameByID(
                             geometry_name, object_type, id));
}

References _geo_model, _project, GeoLib::convertGeoTypeToString(), GeoLib::GEOObjects::getElementNameByID(), DataHolderLib::Project::getGEOObjects(), and SetNameDialog::getNewName().

Referenced by MainWindow().

showGMSHPrefsDialog

void MainWindow::showGMSHPrefsDialog ( )

protectedslot

Definition at line 1404 of file mainwindow.cpp.

{
    GMSHPrefsDialog dlg(_project.getGEOObjects());
    connect(&dlg,
            SIGNAL(requestMeshing(std::vector<std::string>&, unsigned, double,
                                  double, double, bool)),
            this,
            SLOT(callGMSH(std::vector<std::string>&, unsigned, double, double,
                          double, bool)));
    dlg.exec();
}

References _project, callGMSH(), and DataHolderLib::Project::getGEOObjects().

showLayers2GridDialog

void MainWindow::showLayers2GridDialog ( )

protectedslot

Definition at line 1357 of file mainwindow.cpp.

{
    if (_meshModel == nullptr)
    {
        OGSError::box("The given mesh model does not exist.");
    }
 
    auto dlg = Layers2GridDialog(*_meshModel);
    dlg.exec();
}

References _meshModel, and OGSError::box().

showLicense

void MainWindow::showLicense ( )

protectedslot

Definition at line 898 of file mainwindow.cpp.

{
    LicenseDialog dlg;
    dlg.exec();
}

showLineEditDialog

void MainWindow::showLineEditDialog ( const std::string &  geoName )

protectedslot

Definition at line 1389 of file mainwindow.cpp.

{
    LineEditDialog lineEdit(
        *(_project.getGEOObjects().getPolylineVecObj(geoName)));
    connect(
        &lineEdit,
        SIGNAL(connectPolylines(const std::string&, std::vector<std::size_t>,
                                double, std::string, bool, bool)),
        _geo_model.get(),
        SLOT(connectPolylineSegments(const std::string&,
                                     std::vector<std::size_t>, double,
                                     std::string, bool, bool)));
    lineEdit.exec();
}

References _geo_model, _project, DataHolderLib::Project::getGEOObjects(), and GeoLib::GEOObjects::getPolylineVecObj().

Referenced by MainWindow().

showMergeGeometriesDialog

void MainWindow::showMergeGeometriesDialog ( )

protectedslot

Definition at line 1416 of file mainwindow.cpp.

{
    MergeGeometriesDialog dlg(_project.getGEOObjects());
    if (dlg.exec() != QDialog::Accepted)
    {
        return;
    }
    std::string name(dlg.getGeometryName());
    if (_project.getGEOObjects().mergeGeometries(dlg.getSelectedGeometries(),
                                                 name) < 0)
    {
        OGSError::box("Points are missing for\n at least one geometry.");
    }
}

References _project, OGSError::box(), MergeGeometriesDialog::getGeometryName(), DataHolderLib::Project::getGEOObjects(), MergeGeometriesDialog::getSelectedGeometries(), and GeoLib::GEOObjects::mergeGeometries().

showMeshAnalysisDialog

void MainWindow::showMeshAnalysisDialog ( )

protectedslot

Definition at line 1345 of file mainwindow.cpp.

{
    auto* dlg = new MeshAnalysisDialog(this->_project.getMeshObjects());
    dlg->exec();
}

References _project, and DataHolderLib::Project::getMeshObjects().

showMeshElementRemovalDialog

void MainWindow::showMeshElementRemovalDialog ( )

protectedslot

Removal of mesh elements based on a number of criteria.

Definition at line 1337 of file mainwindow.cpp.

{
    MeshElementRemovalDialog dlg(this->_project);
    connect(&dlg, SIGNAL(meshAdded(MeshLib::Mesh*)), _meshModel.get(),
            SLOT(addMesh(MeshLib::Mesh*)));
    dlg.exec();
}

References _meshModel, and _project.

showMeshQualitySelectionDialog

void MainWindow::showMeshQualitySelectionDialog ( MeshLib::VtkMappedMeshSource *  mshSource )

protectedslot

Definition at line 1431 of file mainwindow.cpp.

{
    if (mshSource == nullptr)
    {
        return;
    }
 
    MeshQualitySelectionDialog dlg;
    if (dlg.exec() != QDialog::Accepted)
    {
        return;
    }
    MeshLib::MeshQualityType const type(dlg.getSelectedMetric());
    MeshToolsLib::ElementQualityInterface quality_interface(
        *mshSource->GetMesh(), type);
    _vtkVisPipeline->showMeshElementQuality(
        mshSource, type, quality_interface.getQualityVector());
 
    if (dlg.getHistogram())
    {
        quality_interface.writeHistogram(dlg.getHistogramPath());
    }
}

References _vtkVisPipeline, MeshQualitySelectionDialog::getHistogram(), MeshQualitySelectionDialog::getHistogramPath(), MeshLib::VtkMappedMeshSource::GetMesh(), MeshToolsLib::ElementQualityInterface::getQualityVector(), MeshQualitySelectionDialog::getSelectedMetric(), and MeshToolsLib::ElementQualityInterface::writeHistogram().

Referenced by MainWindow().

showMshDockWidget

void MainWindow::showMshDockWidget ( bool  show )

protectedslot

Definition at line 464 of file mainwindow.cpp.

{
    if (show)
    {
        mshDock->show();
    }
    else
    {
        mshDock->hide();
    }
}

Referenced by MainWindow().

showStationDockWidget

void MainWindow::showStationDockWidget ( bool  show )

protectedslot

Definition at line 452 of file mainwindow.cpp.

{
    if (show)
    {
        stationDock->show();
    }
    else
    {
        stationDock->hide();
    }
}

Referenced by MainWindow().

showStationNameDialog

void MainWindow::showStationNameDialog ( const std::string &  stn_vec_name, std::size_t  id  )

protectedslot

Allows setting the name for a station.

Definition at line 1312 of file mainwindow.cpp.

{
    std::vector<GeoLib::Point*> const* stations =
        _project.getGEOObjects().getStationVec(stn_vec_name);
    auto* const stn = static_cast<GeoLib::Station*>((*stations)[id]);
    SetNameDialog dlg("Station", id, stn->getName());
    if (dlg.exec() != QDialog::Accepted)
    {
        return;
    }
 
    stn->setName(dlg.getNewName());
    static_cast<StationTreeModel*>(this->stationTabWidget->treeView->model())
        ->setNameForItem(stn_vec_name, id, stn->getName());
}

References _project, DataHolderLib::Project::getGEOObjects(), SetNameDialog::getNewName(), and GeoLib::GEOObjects::getStationVec().

Referenced by MainWindow().

showTranslateDataDialog

void MainWindow::showTranslateDataDialog ( )

protectedslot

Definition at line 1351 of file mainwindow.cpp.

{
    auto dlg = TranslateDataDialog(_meshModel.get(), _geo_model.get());
    dlg.exec();
}

References _geo_model, and _meshModel.

showVisalizationPrefsDialog

void MainWindow::showVisalizationPrefsDialog ( )

protectedslot

Definition at line 1456 of file mainwindow.cpp.

{
    _visPrefsDialog->show();
}

References _visPrefsDialog.

showVisDockWidget

void MainWindow::showVisDockWidget ( bool  show )

protectedslot

Definition at line 488 of file mainwindow.cpp.

{
    if (show)
    {
        vtkVisDock->show();
    }
    else
    {
        vtkVisDock->hide();
    }
}

Referenced by MainWindow().

showVtu2GridDialog

void MainWindow::showVtu2GridDialog ( )

protectedslot

Definition at line 1368 of file mainwindow.cpp.

{
    if (_meshModel == nullptr)
    {
        OGSError::box("The given mesh model does not exist.");
    }
    auto dlg = Vtu2GridDialog(*_meshModel);
    dlg.exec();
}

References _meshModel, and OGSError::box().

ShowWindow()

void MainWindow::ShowWindow

(

)

Definition at line 1469 of file mainwindow.cpp.

{
    this->show();
}

startPresentationMode

void MainWindow::startPresentationMode ( )

protectedslot

Definition at line 1596 of file mainwindow.cpp.

{
    // Save the QMainWindow state to restore when quitting presentation mode
    _windowState = this->saveState();
 
    // Get the screen number from the QAction which sent the signal
    QString actionText = static_cast<QAction*>(QObject::sender())->text();
    int screen = actionText.split(" ").back().toInt();
 
    // Move the widget to the screen and maximize it
    // Real fullscreen hides the menu
    _vtkWidget->setParent(nullptr, Qt::Window);
    _vtkWidget->move(
        QPoint(_screenGeometries[screen].x(), _screenGeometries[screen].y()));
    //_vtkWidget->showFullScreen();
    _vtkWidget->showMaximized();
 
    // Create an action which quits the presentation mode when pressing
    // ESCAPE when the the window has focus
    QAction* action = new QAction("Quit presentation mode", this);
    connect(action, SIGNAL(triggered()), this, SLOT(quitPresentationMode()));
    action->setShortcutContext(Qt::WidgetShortcut);
    action->setShortcut(QKeySequence(Qt::Key_Escape));
    _vtkWidget->addAction(action);
 
    // Hide the central widget to maximize the dock widgets
    QMainWindow::centralWidget()->hide();
}

References _screenGeometries, _vtkWidget, _windowState, and quitPresentationMode().

Referenced by createPresentationMenu().

updateDataViews

void MainWindow::updateDataViews ( )

protectedslot

Definition at line 874 of file mainwindow.cpp.

{
    visualizationWidget->updateViewOnLoad();
    geoTabWidget->treeView->updateView();
    stationTabWidget->treeView->updateView();
    meshTabWidget->treeView->updateView();
}

Referenced by MainWindow(), and loadFile().

writeGeometryToFile

void MainWindow::writeGeometryToFile ( QString  gliName, QString  fileName  )

protectedslot

Definition at line 993 of file mainwindow.cpp.

{
#ifndef NDEBUG
    QFileInfo fi(fileName);
    if (fi.suffix().toLower() == "gli")
    {
        FileIO::Legacy::writeAllDataToGLIFileV4(fileName.toStdString(),
                                                _project.getGEOObjects());
        return;
    }
#endif
    GeoLib::IO::XmlGmlInterface xml(_project.getGEOObjects());
    xml.export_name = gliName.toStdString();
    BaseLib::IO::writeStringToFile(xml.writeToString(), fileName.toStdString());
}

References _project, BaseLib::IO::XMLInterface::export_name, DataHolderLib::Project::getGEOObjects(), FileIO::Legacy::writeAllDataToGLIFileV4(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Referenced by MainWindow().

writeSettings()

void MainWindow::writeSettings ( )

private

Definition at line 890 of file mainwindow.cpp.

{
    QSettings settings;
 
    settings.setValue("windowGeometry", saveGeometry());
    settings.setValue("windowState", saveState());
}

Referenced by closeEvent().

writeStationListToFile

void MainWindow::writeStationListToFile ( QString  listName, QString  fileName  )

protectedslot

Definition at line 1009 of file mainwindow.cpp.

{
    GeoLib::IO::XmlStnInterface xml(_project.getGEOObjects());
    xml.export_name = listName.toStdString();
    BaseLib::IO::writeStringToFile(xml.writeToString(), fileName.toStdString());
}

References _project, BaseLib::IO::XMLInterface::export_name, DataHolderLib::Project::getGEOObjects(), BaseLib::IO::writeStringToFile(), and BaseLib::IO::Writer::writeToString().

Referenced by MainWindow().

Member Data Documentation

_conditionModel

std::unique_ptr<FemConditionModel> MainWindow::_conditionModel

private

Definition at line 136 of file mainwindow.h.

Referenced by MainWindow().

_elementModel

std::unique_ptr<ElementTreeModel> MainWindow::_elementModel

private

Definition at line 134 of file mainwindow.h.

Referenced by MainWindow().

_geo_model

std::unique_ptr<GEOModels> MainWindow::_geo_model

private

Definition at line 144 of file mainwindow.h.

Referenced by MainWindow(), mapGeometry(), showDiagramPrefsDialog(), showGeoNameDialog(), showLineEditDialog(), and showTranslateDataDialog().

_meshModel

std::unique_ptr<MeshModel> MainWindow::_meshModel

private

Definition at line 133 of file mainwindow.h.

Referenced by MainWindow(), loadFile(), showCreateStructuredGridDialog(), showLayers2GridDialog(), showMeshElementRemovalDialog(), showTranslateDataDialog(), and showVtu2GridDialog().

_processModel

std::unique_ptr<ProcessModel> MainWindow::_processModel

private

Definition at line 135 of file mainwindow.h.

Referenced by MainWindow(), and loadFile().

_project

DataHolderLib::Project MainWindow::_project

private

Definition at line 132 of file mainwindow.h.

Referenced by MainWindow(), callGMSH(), convertMeshToGeometry(), convertPointsToStations(), exportBoreholesToGMS(), loadFile(), loadPetrelFiles(), mapGeometry(), save(), showGeoNameDialog(), showGMSHPrefsDialog(), showLineEditDialog(), showMergeGeometriesDialog(), showMeshAnalysisDialog(), showMeshElementRemovalDialog(), showStationNameDialog(), writeGeometryToFile(), and writeStationListToFile().

_screenGeometries

QList<QRect> MainWindow::_screenGeometries

private

Definition at line 138 of file mainwindow.h.

Referenced by MainWindow(), createPresentationMenu(), and startPresentationMode().

_visPrefsDialog

std::unique_ptr<VisPrefsDialog> MainWindow::_visPrefsDialog

private

Definition at line 142 of file mainwindow.h.

Referenced by MainWindow(), and showVisalizationPrefsDialog().

_vtkVisPipeline

std::unique_ptr<VtkVisPipeline> MainWindow::_vtkVisPipeline

private

Definition at line 137 of file mainwindow.h.

Referenced by MainWindow(), loadFile(), on_actionExportVTK_triggered(), showAddPipelineFilterItemDialog(), and showMeshQualitySelectionDialog().

_vtkWidget

std::unique_ptr<QWidget> MainWindow::_vtkWidget

private

Definition at line 139 of file mainwindow.h.

Referenced by MainWindow(), createPresentationMenu(), quitPresentationMode(), and startPresentationMode().

_windowState

QByteArray MainWindow::_windowState

private

Definition at line 140 of file mainwindow.h.

Referenced by quitPresentationMode(), and startPresentationMode().

---

The documentation for this class was generated from the following files:

• Applications/DataExplorer/mainwindow.h
• Applications/DataExplorer/mainwindow.cpp