Detailed Description

Main program window for the graphical user interface of OpenGeoSys.

Definition at line 40 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. More...

void	save ()
	Function calls for saving files. More...

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. More...

void	exportBoreholesToGMS (std::string listName, std::string fileName)
	Function calls for GMS export. More...

void	FEMTestStart ()
	Testing functionality for connection to FEM lib. More...

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. More...

void	showStationNameDialog (const std::string &stn_vec_name, std::size_t id)
	Allows setting the name for a station. More...

void	showCreateStructuredGridDialog ()
	Creates a structured grid with user-specified parameters. More...

void	showMeshElementRemovalDialog ()
	Removal of mesh elements based on a number of criteria. More...

void	showDiagramPrefsDialog ()
	Calls the diagram prefs dialog from the Tools menu. More...

void	showDiagramPrefsDialog (QModelIndex &index)
	Calls the diagram prefs dialog from the station list (i.e. for a specific station). More...

void	showFileConverter ()
	Calls the OGSFileConverter as an external tool. More...

void	showLicense ()

void	showLineEditDialog (const std::string &geoName)

void	showGMSHPrefsDialog ()

void	showMergeGeometriesDialog ()

void	showMeshAnalysisDialog ()

void	showMeshQualitySelectionDialog (MeshLib::VtkMappedMeshSource *mshSource)

void	showVisalizationPrefsDialog ()

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 100 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 901 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 GitInfoLib::GitInfo::git_version_sha1_short, GitInfoLib::GitInfo::ogs_version, and MaterialLib::Solids::MFront::toString().

◆ 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 1123 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())
         {
             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");
             }
  
             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 431 of file mainwindow.cpp.

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

References writeSettings().

◆ convertMeshToGeometry

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

protectedslot

Definition at line 1110 of file mainwindow.cpp.

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

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

Referenced by MainWindow().

◆ convertPointsToStations

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

protectedslot

Definition at line 1334 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 921 of file mainwindow.cpp.

 {
     QMenu* importFiles = new QMenu("&Import Files", this);
     importFiles->addAction("&FEFLOW Files...",
                            [this] { open(ImportFileType::FEFLOW); });
     importFiles->addAction("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 1517 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 1115 of file mainwindow.cpp.

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

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

Referenced by MainWindow().

◆ FEMTestStart

void MainWindow::FEMTestStart ( )

protectedslot

Testing functionality for connection to FEM lib.

Definition at line 1423 of file mainwindow.cpp.

1423 {}

◆ 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 1597 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 1430 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 572 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
         {
             auto boreholes = std::make_unique<std::vector<GeoLib::Point*>>();
             std::string name = fi.baseName().toStdString();
  
             if (GMSInterface::readBoreholesFromGMS(boreholes.get(),
                                                    fileName.toStdString()))
             {
                 _project.getGEOObjects().addStationVec(std::move(boreholes),
                                                        name);
             }
             else
             {
                 OGSError::box("Error reading GMS file.");
             }
         }
         else if (fi.suffix().toLower() == "3dm")  // GMS mesh files
         {
             std::string name = fileName.toStdString();
             std::unique_ptr<MeshLib::Mesh> mesh(
                 GMSInterface::readGMS3DMMesh(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(), MaterialPropertyLib::name, ImportFileType::NETCDF, VtkBGImageSource::New(), VtkGeoImageSource::New(), ImportFileType::OGS, ImportFileType::OGS_GEO, ImportFileType::OGS_MSH, ImportFileType::OGS_STN, ImportFileType::POLYRASTER, ImportFileType::RASTER, 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(), 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 1435 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 948 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 1013 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)"};
         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 1496 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->GetRenderWindow());
         exporter->Write();
         exporter->Delete();
     }
 }

◆ on_actionExportVRML2_triggered

void MainWindow::on_actionExportVRML2_triggered ( bool checked = false )

protectedslot

Definition at line 1474 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->GetRenderWindow());
         exporter->Write();
         exporter->Delete();
     }
 }

◆ on_actionExportVTK_triggered

void MainWindow::on_actionExportVTK_triggered ( bool checked = false )

protectedslot

Definition at line 1444 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, MaterialPropertyLib::name, and VtkVisPipelineItem::writeToFile().

◆ open

void MainWindow::open ( int file_type = 0 )

protectedslot

Function calls for opening files.

Definition at line 497 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 515 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 1581 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 879 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 524 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 984 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 473 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 1312 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 1417 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 1257 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 1239 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 1229 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 437 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 1274 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 1360 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().

◆ showLicense

void MainWindow::showLicense ( )

protectedslot

Definition at line 895 of file mainwindow.cpp.

 {
     LicenseDialog dlg;
     dlg.exec();
 }

◆ showLineEditDialog

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

protectedslot

Definition at line 1345 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 1372 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(), GeoLib::GEOObjects::mergeGeometries(), and MaterialPropertyLib::name.

◆ showMeshAnalysisDialog

void MainWindow::showMeshAnalysisDialog ( )

protectedslot

Definition at line 1328 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 1320 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 1387 of file mainwindow.cpp.

 {
     if (mshSource == nullptr)
     {
         return;
     }
  
     MeshQualitySelectionDialog dlg;
     if (dlg.exec() != QDialog::Accepted)
     {
         return;
     }
     MeshLib::MeshQualityType const type(dlg.getSelectedMetric());
     MeshLib::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(), MeshLib::ElementQualityInterface::getQualityVector(), MeshQualitySelectionDialog::getSelectedMetric(), and MeshLib::ElementQualityInterface::writeHistogram().

Referenced by MainWindow().

◆ showMshDockWidget

void MainWindow::showMshDockWidget ( bool show )

protectedslot

Definition at line 461 of file mainwindow.cpp.

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

Referenced by MainWindow().

◆ showStationDockWidget

void MainWindow::showStationDockWidget ( bool show )

protectedslot

Definition at line 449 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 1295 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().

◆ showVisalizationPrefsDialog

void MainWindow::showVisalizationPrefsDialog ( )

protectedslot

Definition at line 1412 of file mainwindow.cpp.

 {
     _visPrefsDialog->show();
 }

References _visPrefsDialog.

◆ showVisDockWidget

void MainWindow::showVisDockWidget ( bool show )

protectedslot

Definition at line 485 of file mainwindow.cpp.

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

Referenced by MainWindow().

◆ ShowWindow()

void MainWindow::ShowWindow ( )

Definition at line 1425 of file mainwindow.cpp.

 {
     this->show();
 }

◆ startPresentationMode

void MainWindow::startPresentationMode ( )

protectedslot

Definition at line 1552 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 871 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 990 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 887 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 1006 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 130 of file mainwindow.h.

Referenced by MainWindow().

◆ _elementModel

std::unique_ptr<ElementTreeModel> MainWindow::_elementModel

private

Definition at line 128 of file mainwindow.h.

Referenced by MainWindow().

◆ _geo_model

std::unique_ptr<GEOModels> MainWindow::_geo_model

private

Definition at line 138 of file mainwindow.h.

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

◆ _meshModel

std::unique_ptr<MeshModel> MainWindow::_meshModel

private

Definition at line 127 of file mainwindow.h.

Referenced by MainWindow(), loadFile(), showCreateStructuredGridDialog(), and showMeshElementRemovalDialog().

◆ _processModel

std::unique_ptr<ProcessModel> MainWindow::_processModel

private

Definition at line 129 of file mainwindow.h.

Referenced by MainWindow(), and loadFile().

◆ _project

DataHolderLib::Project MainWindow::_project

private

◆ _screenGeometries

QList<QRect> MainWindow::_screenGeometries

private

Definition at line 132 of file mainwindow.h.

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

◆ _visPrefsDialog

std::unique_ptr<VisPrefsDialog> MainWindow::_visPrefsDialog

private

Definition at line 136 of file mainwindow.h.

Referenced by MainWindow(), and showVisalizationPrefsDialog().

◆ _vtkVisPipeline

std::unique_ptr<VtkVisPipeline> MainWindow::_vtkVisPipeline

private

Definition at line 131 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 133 of file mainwindow.h.

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

◆ _windowState

QByteArray MainWindow::_windowState

private

Definition at line 134 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

Detailed Description

Signals

Public Member Functions

Protected Slots

Protected Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ MainWindow()

Member Function Documentation

◆ about

◆ callGMSH

◆ closeEvent()

◆ convertMeshToGeometry

◆ convertPointsToStations

◆ createImportFilesMenu()

◆ createPresentationMenu

◆ exportBoreholesToGMS

◆ FEMTestStart

◆ fileOpenRequested

◆ fileUsed

◆ getLastUsedDir()

◆ HideWindow()

◆ loadFEMConditionsFromFile()

◆ loadFile()

◆ loadFileOnStartUp()

◆ loadPetrelFiles

◆ mapGeometry

◆ on_actionExportObj_triggered

◆ on_actionExportVRML2_triggered

◆ on_actionExportVTK_triggered

◆ open

◆ openRecentFile

◆ quitPresentationMode

◆ readSettings()

◆ save

◆ showAddPipelineFilterItemDialog

◆ showConditionDockWidget

◆ showCreateStructuredGridDialog

◆ showDataExplorerSettingsDialog

◆ showDiagramPrefsDialog [1/2]

◆ showDiagramPrefsDialog [2/2]

◆ showFileConverter

◆ showGeoDockWidget

◆ showGeoNameDialog

◆ showGMSHPrefsDialog

◆ showLicense

◆ showLineEditDialog

◆ showMergeGeometriesDialog

◆ showMeshAnalysisDialog

◆ showMeshElementRemovalDialog

◆ showMeshQualitySelectionDialog

◆ showMshDockWidget

◆ showStationDockWidget

◆ showStationNameDialog

◆ showVisalizationPrefsDialog

◆ showVisDockWidget

◆ ShowWindow()

◆ startPresentationMode

◆ updateDataViews

◆ writeGeometryToFile

◆ writeSettings()

◆ writeStationListToFile

Member Data Documentation

◆ _conditionModel

◆ _elementModel

◆ _geo_model

◆ _meshModel

◆ _processModel

◆ _project

◆ _screenGeometries

◆ _visPrefsDialog

◆ _vtkVisPipeline

◆ _vtkWidget

◆ _windowState