diff --git a/Examples/BlueBerryExampleLauncher/BlueBerryExampleLauncher.cpp b/Examples/BlueBerryExampleLauncher/BlueBerryExampleLauncher.cpp
index 96cc40d450..1487fa3eca 100644
--- a/Examples/BlueBerryExampleLauncher/BlueBerryExampleLauncher.cpp
+++ b/Examples/BlueBerryExampleLauncher/BlueBerryExampleLauncher.cpp
@@ -1,50 +1,50 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include <mitkBaseApplication.h>
#include "BlueBerryExampleLauncherDialog.h"
#include <QFileInfo>
#include <QVariant>
int main(int argc, char **argv)
{
mitk::BaseApplication app(argc, argv);
app.setApplicationName("BlueBerryExampleLauncher");
app.setOrganizationName("DKFZ");
app.initializeQt();
BlueBerryExampleLauncherDialog demoDialog;
QString selectedConfiguration = demoDialog.getDemoConfiguration();
if (selectedConfiguration.isEmpty())
return EXIT_SUCCESS;
app.setProvisioningFilePath(selectedConfiguration);
// We create the application id relying on a convention:
// org.mitk.example.<configuration-name>
QString appId = "org.mitk.example.";
- QStringList appIdTokens = QFileInfo(selectedConfiguration).baseName().toLower().split('_', QString::SkipEmptyParts);
+ QStringList appIdTokens = QFileInfo(selectedConfiguration).baseName().toLower().split('_', Qt::SkipEmptyParts);
appId += appIdTokens.size() > 1 ? appIdTokens.at(1) : appIdTokens.at(0);
// Special cases
if (appId == "org.mitk.example.exampleplugins")
{
appId = "org.mitk.qt.extapplication";
}
app.setProperty(mitk::BaseApplication::PROP_APPLICATION, appId);
return app.run();
}
diff --git a/Modules/QtWidgets/src/QmitkIOUtil.cpp b/Modules/QtWidgets/src/QmitkIOUtil.cpp
index 053a231c77..8dbde985ca 100644
--- a/Modules/QtWidgets/src/QmitkIOUtil.cpp
+++ b/Modules/QtWidgets/src/QmitkIOUtil.cpp
@@ -1,586 +1,586 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkIOUtil.h"
#include "mitkCoreServices.h"
#include "mitkCustomMimeType.h"
#include "mitkFileReaderRegistry.h"
#include "mitkFileWriterRegistry.h"
#include "mitkIMimeTypeProvider.h"
#include "mitkMimeType.h"
#include <mitkCoreObjectFactory.h>
#include <mitkIOUtil.h>
#include "QmitkFileReaderOptionsDialog.h"
#include "QmitkFileWriterOptionsDialog.h"
// QT
#include <QDebug>
#include <QFileDialog>
#include <QMessageBox>
#include <QSet>
#include <QString>
// ITK
#include <itksys/SystemTools.hxx>
#include <algorithm>
struct QmitkIOUtil::Impl
{
struct ReaderOptionsDialogFunctor : public ReaderOptionsFunctorBase
{
bool operator()(LoadInfo &loadInfo) const override
{
QmitkFileReaderOptionsDialog dialog(loadInfo);
if (dialog.exec() == QDialog::Accepted)
{
return !dialog.ReuseOptions();
}
else
{
loadInfo.m_Cancel = true;
return true;
}
}
};
struct WriterOptionsDialogFunctor : public WriterOptionsFunctorBase
{
bool operator()(SaveInfo &saveInfo) const override
{
QmitkFileWriterOptionsDialog dialog(saveInfo);
if (dialog.exec() == QDialog::Accepted)
{
return !dialog.ReuseOptions();
}
else
{
saveInfo.m_Cancel = true;
return true;
}
}
};
//! Filename characters that are not valid - depending on the platform (Windows, Posix)
static QString s_InvalidFilenameCharacters;
//! Return 'true' when:
//! - the specified filename contains characters not accepted by the file system (see s_InvalidFilenameCharacters)
//! - filename starts or ends in space characters
//!
//! This test is not exhaustive but just excluding the most common problems.
static bool IsIllegalFilename(const QString &fullFilename)
{
QFileInfo fi(fullFilename);
auto filename = fi.fileName();
for (const auto &ch : qAsConst(s_InvalidFilenameCharacters))
{
if (filename.contains(ch))
{
return true;
}
}
if (filename.startsWith(' ') || filename.endsWith(' '))
{
return true;
}
return false;
}
}; // Impl
#if defined(_WIN32) || defined(_WIN64)
QString QmitkIOUtil::Impl::s_InvalidFilenameCharacters = "<>:\"/\\|?*";
#else
QString QmitkIOUtil::Impl::s_InvalidFilenameCharacters = "/";
#endif
struct MimeTypeComparison
{
MimeTypeComparison(const std::string &mimeTypeName) : m_Name(mimeTypeName) {}
bool operator()(const mitk::MimeType &mimeType) const { return mimeType.GetName() == m_Name; }
const std::string m_Name;
};
QString QmitkIOUtil::GetFileOpenFilterString()
{
QString filters;
mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
std::vector<std::string> categories = mimeTypeProvider->GetCategories();
for (std::vector<std::string>::iterator cat = categories.begin(); cat != categories.end(); ++cat)
{
QSet<QString> filterExtensions;
std::vector<mitk::MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForCategory(*cat);
for (std::vector<mitk::MimeType>::iterator mt = mimeTypes.begin(); mt != mimeTypes.end(); ++mt)
{
std::vector<std::string> extensions = mt->GetExtensions();
for (std::vector<std::string>::iterator ext = extensions.begin(); ext != extensions.end(); ++ext)
{
filterExtensions << QString::fromStdString(*ext);
}
}
QString filter = QString::fromStdString(*cat) + " (";
foreach (const QString &extension, filterExtensions)
{
filter += "*." + extension + " ";
}
filter = filter.replace(filter.size() - 1, 1, ')');
filters += ";;" + filter;
}
filters.prepend("All (*)");
return filters;
}
QList<mitk::BaseData::Pointer> QmitkIOUtil::Load(const QStringList &paths, QWidget *parent)
{
std::vector<LoadInfo> loadInfos;
foreach (const QString &file, paths)
{
loadInfos.push_back(LoadInfo(file.toLocal8Bit().constData()));
}
Impl::ReaderOptionsDialogFunctor optionsCallback;
std::string errMsg = Load(loadInfos, nullptr, nullptr, &optionsCallback);
if (!errMsg.empty())
{
QMessageBox::warning(parent, "Error reading files", QString::fromStdString(errMsg));
mitkThrow() << errMsg;
}
QList<mitk::BaseData::Pointer> qResult;
for (std::vector<LoadInfo>::const_iterator iter = loadInfos.begin(), iterEnd = loadInfos.end(); iter != iterEnd;
++iter)
{
for (const auto &elem : iter->m_Output)
{
qResult << elem;
}
}
return qResult;
}
mitk::DataStorage::SetOfObjects::Pointer QmitkIOUtil::Load(const QStringList &paths,
mitk::DataStorage &storage,
QWidget *parent)
{
std::vector<LoadInfo> loadInfos;
foreach (const QString &file, paths)
{
loadInfos.push_back(LoadInfo(file.toLocal8Bit().constData()));
}
mitk::DataStorage::SetOfObjects::Pointer nodeResult = mitk::DataStorage::SetOfObjects::New();
Impl::ReaderOptionsDialogFunctor optionsCallback;
std::string errMsg = Load(loadInfos, nodeResult, &storage, &optionsCallback);
if (!errMsg.empty())
{
QMessageBox::warning(parent, "Error reading files", QString::fromStdString(errMsg));
}
return nodeResult;
}
QList<mitk::BaseData::Pointer> QmitkIOUtil::Load(const QString &path, QWidget *parent)
{
QStringList paths;
paths << path;
return Load(paths, parent);
}
mitk::DataStorage::SetOfObjects::Pointer QmitkIOUtil::Load(const QString &path,
mitk::DataStorage &storage,
QWidget *parent)
{
QStringList paths;
paths << path;
return Load(paths, storage, parent);
}
QString QmitkIOUtil::Save(const mitk::BaseData *data,
const QString &defaultBaseName,
const QString &defaultPath,
QWidget *parent,
bool setPathProperty)
{
std::vector<const mitk::BaseData *> dataVector;
dataVector.push_back(data);
QStringList defaultBaseNames;
defaultBaseNames.push_back(defaultBaseName);
return Save(dataVector, defaultBaseNames, defaultPath, parent, setPathProperty).back();
}
QStringList QmitkIOUtil::Save(const std::vector<const mitk::BaseData *> &data,
const QStringList &defaultBaseNames,
const QString &defaultPath,
QWidget *parent,
bool setPathProperty)
{
QStringList fileNames;
QString currentPath = defaultPath;
std::vector<SaveInfo> saveInfos;
int counter = 0;
for (std::vector<const mitk::BaseData *>::const_iterator dataIter = data.begin(), dataIterEnd = data.end();
dataIter != dataIterEnd;
++dataIter, ++counter)
{
SaveInfo saveInfo(*dataIter, mitk::MimeType(), std::string());
SaveFilter filters(saveInfo);
// If there is only the "__all__" filter string, it means there is no writer for this base data
if (filters.Size() < 2)
{
QMessageBox::warning(
parent,
"Saving not possible",
QString("No writer available for type \"%1\"").arg(QString::fromStdString((*dataIter)->GetNameOfClass())));
continue;
}
// Construct a default path and file name
QString filterString = filters.ToString();
QString selectedFilter = filters.GetDefaultFilter();
QString fileName = currentPath;
QString dialogTitle = "Save " + QString::fromStdString((*dataIter)->GetNameOfClass());
if (counter < defaultBaseNames.size())
{
dialogTitle += " \"" + defaultBaseNames[counter] + "\"";
fileName += QDir::separator() + defaultBaseNames[counter];
// We do not append an extension to the file name by default. The extension
// is chosen by the user by either selecting a filter or writing the
// extension in the file name himself (in the file save dialog).
/*
QString defaultExt = filters.GetDefaultExtension();
if (!defaultExt.isEmpty())
{
fileName += "." + defaultExt;
}
*/
}
// Ask the user for a file name
QString nextName = QFileDialog::getSaveFileName(parent, dialogTitle, fileName, filterString, &selectedFilter);
if (Impl::IsIllegalFilename(nextName))
{
QMessageBox::warning(
parent,
"Saving not possible",
QString("File \"%2\" contains invalid characters.\n\nPlease avoid any of \"%1\"")
- .arg(Impl::s_InvalidFilenameCharacters.split("", QString::SkipEmptyParts).join(" "))
+ .arg(Impl::s_InvalidFilenameCharacters.split("", Qt::SkipEmptyParts).join(" "))
.arg(nextName));
continue;
}
if (nextName.isEmpty())
{
// We stop asking for further file names, but we still save the
// data where the user already confirmed the save dialog.
break;
}
fileName = nextName;
std::string stdFileName = fileName.toLocal8Bit().constData();
QFileInfo fileInfo(fileName);
currentPath = fileInfo.absolutePath();
QString suffix = fileInfo.completeSuffix();
mitk::MimeType filterMimeType = filters.GetMimeTypeForFilter(selectedFilter);
mitk::MimeType selectedMimeType;
if (fileInfo.exists() && !fileInfo.isFile())
{
QMessageBox::warning(parent, "Saving not possible", QString("The path \"%1\" is not a file").arg(fileName));
continue;
}
// Theoretically, the user could have entered an extension that does not match the selected filter
// The extension then has prioritry over the filter
// Check if one of the available mime-types match the filename
std::vector<mitk::MimeType> filterMimeTypes = filters.GetMimeTypes();
for (std::vector<mitk::MimeType>::const_iterator mimeTypeIter = filterMimeTypes.begin(),
mimeTypeIterEnd = filterMimeTypes.end();
mimeTypeIter != mimeTypeIterEnd;
++mimeTypeIter)
{
if (mimeTypeIter->MatchesExtension(stdFileName))
{
selectedMimeType = *mimeTypeIter;
break;
}
}
if (!selectedMimeType.IsValid())
{
// The file name either does not contain an extension or the
// extension is unknown.
// If the file already exists, we stop here because we are unable
// to (over)write the file without adding a custom suffix. If the file
// does not exist, we add the default extension from the currently
// selected filter. If the "All" filter was selected, we only add the
// default extensions if the file name itself does not already contain
// an extension.
if (!fileInfo.exists())
{
if (filterMimeType == SaveFilter::ALL_MIMETYPE())
{
if (suffix.isEmpty())
{
// Use the highest ranked mime-type from the list
selectedMimeType = filters.GetDefaultMimeType();
}
}
else
{
selectedMimeType = filterMimeType;
}
if (selectedMimeType.IsValid())
{
suffix = QString::fromStdString(selectedMimeType.GetExtensions().front());
fileName += "." + suffix;
stdFileName = fileName.toLocal8Bit().constData();
// We changed the file name (added a suffix) so ask in case
// the file aready exists.
fileInfo = QFileInfo(fileName);
if (fileInfo.exists())
{
if (!fileInfo.isFile())
{
QMessageBox::warning(
parent, "Saving not possible", QString("The path \"%1\" is not a file").arg(fileName));
continue;
}
if (QMessageBox::question(
parent,
"Replace File",
QString("A file named \"%1\" already exists. Do you want to replace it?").arg(fileName)) ==
QMessageBox::No)
{
continue;
}
}
}
}
}
if (!selectedMimeType.IsValid())
{
// The extension/filename is not valid (no mime-type found), bail out
QMessageBox::warning(
parent, "Saving not possible", QString("No mime-type available which can handle \"%1\".").arg(fileName));
continue;
}
if (!QFileInfo(fileInfo.absolutePath()).isWritable())
{
QMessageBox::warning(parent, "Saving not possible", QString("The path \"%1\" is not writable").arg(fileName));
continue;
}
fileNames.push_back(fileName);
saveInfo.m_Path = stdFileName;
saveInfo.m_MimeType = selectedMimeType;
// pre-select the best writer for the chosen mime-type
saveInfo.m_WriterSelector.Select(selectedMimeType.GetName());
saveInfos.push_back(saveInfo);
}
if (!saveInfos.empty())
{
Impl::WriterOptionsDialogFunctor optionsCallback;
std::string errMsg = Save(saveInfos, &optionsCallback, setPathProperty);
if (!errMsg.empty())
{
QMessageBox::warning(parent, "Error writing files", QString::fromStdString(errMsg));
mitkThrow() << errMsg;
}
}
return fileNames;
}
void QmitkIOUtil::SaveBaseDataWithDialog(mitk::BaseData *data, std::string fileName, QWidget * /*parent*/)
{
Save(data, fileName);
}
void QmitkIOUtil::SaveSurfaceWithDialog(mitk::Surface::Pointer surface, std::string fileName, QWidget * /*parent*/)
{
Save(surface, fileName);
}
void QmitkIOUtil::SaveImageWithDialog(mitk::Image::Pointer image, std::string fileName, QWidget * /*parent*/)
{
Save(image, fileName);
}
void QmitkIOUtil::SavePointSetWithDialog(mitk::PointSet::Pointer pointset, std::string fileName, QWidget * /*parent*/)
{
Save(pointset, fileName);
}
struct QmitkIOUtil::SaveFilter::Impl
{
Impl(const mitk::IOUtil::SaveInfo &saveInfo) : m_SaveInfo(saveInfo)
{
// Add an artifical filter for "All"
m_MimeTypes.push_back(ALL_MIMETYPE());
m_FilterStrings.push_back("All (*.*)");
// Get all writers and their mime types for the given base data type
// (this is sorted already)
std::vector<mitk::MimeType> mimeTypes = saveInfo.m_WriterSelector.GetMimeTypes();
for (std::vector<mitk::MimeType>::const_reverse_iterator iter = mimeTypes.rbegin(), iterEnd = mimeTypes.rend();
iter != iterEnd;
++iter)
{
QList<QString> filterExtensions;
mitk::MimeType mimeType = *iter;
std::vector<std::string> extensions = mimeType.GetExtensions();
for (auto &extension : extensions)
{
filterExtensions << QString::fromStdString(extension);
}
if (m_DefaultExtension.isEmpty())
{
m_DefaultExtension = QString::fromStdString(extensions.front());
}
QString filter = QString::fromStdString(mimeType.GetComment()) + " (";
foreach (const QString &extension, filterExtensions)
{
filter += "*." + extension + " ";
}
filter = filter.replace(filter.size() - 1, 1, ')');
m_MimeTypes.push_back(mimeType);
m_FilterStrings.push_back(filter);
}
}
const mitk::IOUtil::SaveInfo m_SaveInfo;
std::vector<mitk::MimeType> m_MimeTypes;
QStringList m_FilterStrings;
QString m_DefaultExtension;
};
mitk::MimeType QmitkIOUtil::SaveFilter::ALL_MIMETYPE()
{
static mitk::CustomMimeType allMimeType(std::string("__all__"));
return mitk::MimeType(allMimeType, -1, -1);
}
QmitkIOUtil::SaveFilter::SaveFilter(const QmitkIOUtil::SaveFilter &other) : d(new Impl(*other.d))
{
}
QmitkIOUtil::SaveFilter::SaveFilter(const SaveInfo &saveInfo) : d(new Impl(saveInfo))
{
}
QmitkIOUtil::SaveFilter &QmitkIOUtil::SaveFilter::operator=(const QmitkIOUtil::SaveFilter &other)
{
d.reset(new Impl(*other.d));
return *this;
}
std::vector<mitk::MimeType> QmitkIOUtil::SaveFilter::GetMimeTypes() const
{
return d->m_MimeTypes;
}
QString QmitkIOUtil::SaveFilter::GetFilterForMimeType(const std::string &mimeType) const
{
std::vector<mitk::MimeType>::const_iterator iter =
std::find_if(d->m_MimeTypes.begin(), d->m_MimeTypes.end(), MimeTypeComparison(mimeType));
if (iter == d->m_MimeTypes.end())
{
return QString();
}
int index = static_cast<int>(iter - d->m_MimeTypes.begin());
if (index < 0 || index >= d->m_FilterStrings.size())
{
return QString();
}
return d->m_FilterStrings[index];
}
mitk::MimeType QmitkIOUtil::SaveFilter::GetMimeTypeForFilter(const QString &filter) const
{
int index = d->m_FilterStrings.indexOf(filter);
if (index < 0)
{
return mitk::MimeType();
}
return d->m_MimeTypes[index];
}
QString QmitkIOUtil::SaveFilter::GetDefaultFilter() const
{
if (d->m_FilterStrings.size() > 1)
{
return d->m_FilterStrings.at(1);
}
else if (d->m_FilterStrings.size() > 0)
{
return d->m_FilterStrings.front();
}
return QString();
}
QString QmitkIOUtil::SaveFilter::GetDefaultExtension() const
{
return d->m_DefaultExtension;
}
mitk::MimeType QmitkIOUtil::SaveFilter::GetDefaultMimeType() const
{
if (d->m_MimeTypes.size() > 1)
{
return d->m_MimeTypes.at(1);
}
else if (d->m_MimeTypes.size() > 0)
{
return d->m_MimeTypes.front();
}
return mitk::MimeType();
}
QString QmitkIOUtil::SaveFilter::ToString() const
{
return d->m_FilterStrings.join(";;");
}
int QmitkIOUtil::SaveFilter::Size() const
{
return d->m_FilterStrings.size();
}
bool QmitkIOUtil::SaveFilter::IsEmpty() const
{
return d->m_FilterStrings.isEmpty();
}
bool QmitkIOUtil::SaveFilter::ContainsMimeType(const std::string &mimeType)
{
return std::find_if(d->m_MimeTypes.begin(), d->m_MimeTypes.end(), MimeTypeComparison(mimeType)) !=
d->m_MimeTypes.end();
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
index a78bef468a..2d2bdb4f75 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
@@ -1,497 +1,497 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkTotalSegmentatorToolGUI.h"
#include "mitkProcessExecutor.h"
#include "mitkTotalSegmentatorTool.h"
#include <QApplication>
#include <QDir>
#include <QDirIterator>
#include <QFileDialog>
#include <QIcon>
#include <QmitkStyleManager.h>
#include <QMessageBox>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkTotalSegmentatorToolGUI, "")
QmitkTotalSegmentatorToolGUI::QmitkTotalSegmentatorToolGUI()
: QmitkMultiLabelSegWithPreviewToolGUIBase(), m_SuperclassEnableConfirmSegBtnFnc(m_EnableConfirmSegBtnFnc)
{
// Nvidia-smi command returning zero doesn't always imply lack of GPUs.
// Pytorch uses its own libraries to communicate to the GPUs. Hence, only a warning can be given.
if (m_GpuLoader.GetGPUCount() == 0)
{
std::string warning = "WARNING: No GPUs were detected on your machine. The TotalSegmentator tool can be very slow.";
this->ShowErrorMessage(warning);
}
m_EnableConfirmSegBtnFnc = [this](bool enabled)
{ return !m_FirstPreviewComputation ? m_SuperclassEnableConfirmSegBtnFnc(enabled) : false; };
}
void QmitkTotalSegmentatorToolGUI::ConnectNewTool(mitk::SegWithPreviewTool *newTool)
{
Superclass::ConnectNewTool(newTool);
m_FirstPreviewComputation = true;
}
void QmitkTotalSegmentatorToolGUI::InitializeUI(QBoxLayout *mainLayout)
{
m_Controls.setupUi(this);
#ifndef _WIN32
m_Controls.sysPythonComboBox->addItem("/usr/bin");
#endif
this->AutoParsePythonPaths();
m_Controls.sysPythonComboBox->addItem("Select");
m_Controls.sysPythonComboBox->setCurrentIndex(0);
m_Controls.pythonEnvComboBox->addItem("Select");
m_Controls.pythonEnvComboBox->setDuplicatesEnabled(false);
m_Controls.pythonEnvComboBox->setDisabled(true);
m_Controls.previewButton->setDisabled(true);
m_Controls.statusLabel->setTextFormat(Qt::RichText);
m_Controls.subtaskComboBox->addItems(VALID_TASKS);
QString welcomeText;
this->SetGPUInfo();
if (m_GpuLoader.GetGPUCount() != 0)
{
welcomeText = "<b>STATUS: </b><i>Welcome to TotalSegmentator tool. You're in luck: " +
QString::number(m_GpuLoader.GetGPUCount()) + " GPU(s) were detected.</i>";
}
else
{
welcomeText = "<b>STATUS: </b><i>Welcome to TotalSegmentator tool. Sorry, " +
QString::number(m_GpuLoader.GetGPUCount()) + " GPUs were detected.</i>";
}
connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewBtnClicked()));
connect(m_Controls.clearButton, SIGNAL(clicked()), this, SLOT(OnClearInstall()));
connect(m_Controls.installButton, SIGNAL(clicked()), this, SLOT(OnInstallBtnClicked()));
connect(m_Controls.overrideBox, SIGNAL(stateChanged(int)), this, SLOT(OnOverrideChecked(int)));
connect(m_Controls.pythonEnvComboBox,
QOverload<int>::of(&QComboBox::activated),
[=](int index) { OnPythonPathChanged(m_Controls.pythonEnvComboBox->itemText(index)); });
connect(m_Controls.sysPythonComboBox,
QOverload<int>::of(&QComboBox::activated),
[=](int index) { OnSystemPythonChanged(m_Controls.sysPythonComboBox->itemText(index)); });
QString lastSelectedPyEnv = m_Settings.value("TotalSeg/LastCustomPythonPath").toString();
if (!lastSelectedPyEnv.isEmpty() && lastSelectedPyEnv!= "Select")
{
m_Controls.pythonEnvComboBox->insertItem(0, lastSelectedPyEnv);
}
const QString storageDir = m_Installer.GetVirtualEnvPath();
m_IsInstalled = this->IsTotalSegmentatorInstalled(storageDir);
if (m_IsInstalled)
{
m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(storageDir).first;
m_Installer.SetVirtualEnvPath(m_PythonPath);
this->EnableAll(m_IsInstalled);
welcomeText += " TotalSegmentator is already found installed.";
}
else
{
welcomeText += " TotalSegmentator is not installed. Please click on \"Install TotalSegmentator\" above.";
}
this->WriteStatusMessage(welcomeText);
QIcon deleteIcon =
QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/edit-delete.svg"));
QIcon arrowIcon =
QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/tango/scalable/actions/media-playback-start.svg"));
m_Controls.clearButton->setIcon(deleteIcon);
m_Controls.previewButton->setIcon(arrowIcon);
mainLayout->addLayout(m_Controls.verticalLayout);
Superclass::InitializeUI(mainLayout);
}
void QmitkTotalSegmentatorToolGUI::SetGPUInfo()
{
std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
for (const QmitkGPUSpec &gpuSpec : specs)
{
m_Controls.gpuComboBox->addItem(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
}
if (specs.empty())
{
m_Controls.gpuComboBox->setEditable(true);
m_Controls.gpuComboBox->addItem(QString::number(0));
m_Controls.gpuComboBox->setValidator(new QIntValidator(0, 999, this));
}
}
unsigned int QmitkTotalSegmentatorToolGUI::FetchSelectedGPUFromUI() const
{
QString gpuInfo = m_Controls.gpuComboBox->currentText();
if (m_GpuLoader.GetGPUCount() == 0)
{
return static_cast<unsigned int>(gpuInfo.toInt());
}
else
{
- QString gpuId = gpuInfo.split(":", QString::SplitBehavior::SkipEmptyParts).first();
+ QString gpuId = gpuInfo.split(":", Qt::SkipEmptyParts).first();
return static_cast<unsigned int>(gpuId.toInt());
}
}
void QmitkTotalSegmentatorToolGUI::EnableAll(bool isEnable)
{
m_Controls.previewButton->setEnabled(isEnable);
m_Controls.subtaskComboBox->setEnabled(isEnable);
m_Controls.installButton->setEnabled((!isEnable));
}
void QmitkTotalSegmentatorToolGUI::OnInstallBtnClicked()
{
bool isInstalled = false;
const auto [path, version] = OnSystemPythonChanged(m_Controls.sysPythonComboBox->currentText());
if (path.isEmpty())
{
this->WriteErrorMessage("<b>ERROR: </b>Couldn't find compatible Python.");
return;
}
// check if python 3.12 and ask for confirmation
if (version.startsWith("3.12") &&
QMessageBox::No == QMessageBox::question(
nullptr,
"Installing TotalSegmentator",
QString("WARNING: This is an unsupported version of Python that may not work. "
"We recommend using a supported Python version between 3.9 and 3.11.\n\n"
"Continue anyway?"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No))
{
return;
}
this->WriteStatusMessage("<b>STATUS: </b>Installing TotalSegmentator...");
m_Installer.SetSystemPythonPath(path);
isInstalled = m_Installer.SetupVirtualEnv(m_Installer.VENV_NAME);
if (isInstalled)
{
m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(m_Installer.GetVirtualEnvPath()).first;
this->WriteStatusMessage("<b>STATUS: </b>Successfully installed TotalSegmentator.");
}
else
{
this->WriteErrorMessage("<b>ERROR: </b>Couldn't install TotalSegmentator.");
}
this->EnableAll(isInstalled);
}
void QmitkTotalSegmentatorToolGUI::OnPreviewBtnClicked()
{
auto tool = this->GetConnectedToolAs<mitk::TotalSegmentatorTool>();
if (nullptr == tool)
{
return;
}
try
{
m_Controls.previewButton->setEnabled(false);
qApp->processEvents();
if (!this->IsTotalSegmentatorInstalled(m_PythonPath))
{
throw std::runtime_error(WARNING_TOTALSEG_NOT_FOUND);
}
bool isFast = m_Controls.fastBox->isChecked();
QString subTask = m_Controls.subtaskComboBox->currentText();
if (subTask != VALID_TASKS[0])
{
isFast = true;
}
tool->SetPythonPath(m_PythonPath.toStdString());
tool->SetGpuId(FetchSelectedGPUFromUI());
tool->SetFast(isFast);
tool->SetSubTask(subTask.toStdString());
this->WriteStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
tool->UpdatePreview();
m_Controls.previewButton->setEnabled(true);
m_FirstPreviewComputation = false;
}
catch (const std::exception &e)
{
std::stringstream errorMsg;
errorMsg << "<b>STATUS: </b>Error while processing parameters for TotalSegmentator segmentation. Reason: "
<< e.what();
this->ShowErrorMessage(errorMsg.str());
this->WriteErrorMessage(QString::fromStdString(errorMsg.str()));
m_Controls.previewButton->setEnabled(true);
return;
}
catch (...)
{
std::string errorMsg = "Unkown error occured while generation TotalSegmentator segmentation.";
this->ShowErrorMessage(errorMsg);
m_Controls.previewButton->setEnabled(true);
return;
}
this->SetLabelSetPreview(tool->GetPreviewSegmentation());
this->ActualizePreviewLabelVisibility();
this->WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully.</i>");
QString pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
if (!pythonPathTextItem.isEmpty() && pythonPathTextItem != "Select") // only cache if the prediction ended without errors.
{
QString lastSelectedPyEnv = m_Settings.value("TotalSeg/LastCustomPythonPath").toString();
if (lastSelectedPyEnv != pythonPathTextItem)
{
m_Settings.setValue("TotalSeg/LastCustomPythonPath", pythonPathTextItem);
}
}
}
void QmitkTotalSegmentatorToolGUI::ShowErrorMessage(const std::string &message, QMessageBox::Icon icon)
{
this->setCursor(Qt::ArrowCursor);
QMessageBox *messageBox = new QMessageBox(icon, nullptr, message.c_str());
messageBox->exec();
delete messageBox;
MITK_WARN << message;
}
void QmitkTotalSegmentatorToolGUI::WriteStatusMessage(const QString &message)
{
m_Controls.statusLabel->setText(message);
m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: white");
qApp->processEvents();
}
void QmitkTotalSegmentatorToolGUI::WriteErrorMessage(const QString &message)
{
m_Controls.statusLabel->setText(message);
m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: red");
qApp->processEvents();
}
bool QmitkTotalSegmentatorToolGUI::IsTotalSegmentatorInstalled(const QString &pythonPath)
{
QString fullPath = pythonPath;
bool isPythonExists = false, isExists = false;
#ifdef _WIN32
isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python.exe"));
if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
{
fullPath += QDir::separator() + QString("Scripts");
isPythonExists =
(!isPythonExists) ? QFile::exists(fullPath + QDir::separator() + QString("python.exe")) : isPythonExists;
}
isExists = QFile::exists(fullPath + QDir::separator() + QString("TotalSegmentator.exe")) && isPythonExists;
#else
isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python3"));
if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
{
fullPath += QDir::separator() + QString("bin");
isPythonExists =
(!isPythonExists) ? QFile::exists(fullPath + QDir::separator() + QString("python3")) : isPythonExists;
}
isExists = QFile::exists(fullPath + QDir::separator() + QString("TotalSegmentator")) && isPythonExists;
#endif
return isExists;
}
void QmitkTotalSegmentatorToolGUI::AutoParsePythonPaths()
{
QString homeDir = QDir::homePath();
std::vector<QString> searchDirs;
#ifdef _WIN32
searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
QString("anaconda3"));
#else
// Add search locations for possible standard python paths here
searchDirs.push_back(homeDir + QDir::separator() + "environments");
searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
#endif
for (QString searchDir : searchDirs)
{
if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
{
if (QDir(searchDir).exists())
{
m_Controls.sysPythonComboBox->addItem("(base): " + searchDir);
searchDir.append((QDir::separator() + QString("envs")));
}
}
for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
{
subIt.next();
QString envName = subIt.fileName();
if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
{
m_Controls.pythonEnvComboBox->addItem("(" + envName + "): " + subIt.filePath());
}
}
}
}
std::pair<QString, QString> QmitkTotalSegmentatorToolGUI::OnSystemPythonChanged(const QString &pyEnv)
{
std::pair<QString, QString> pyPath;
if (pyEnv == QString("Select"))
{
m_Controls.previewButton->setDisabled(true);
QString path =
QFileDialog::getExistingDirectory(m_Controls.sysPythonComboBox->parentWidget(), "Python Path", "dir");
if (!path.isEmpty())
{
this->OnSystemPythonChanged(path); // recall same function for new path validation
bool oldState = m_Controls.sysPythonComboBox->blockSignals(true); // block signal firing while inserting item
m_Controls.sysPythonComboBox->insertItem(0, path);
m_Controls.sysPythonComboBox->setCurrentIndex(0);
m_Controls.sysPythonComboBox->blockSignals(
oldState); // unblock signal firing after inserting item. Remove this after Qt6 migration
}
}
else
{
QString uiPyPath = this->GetPythonPathFromUI(pyEnv);
pyPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(uiPyPath);
}
return pyPath;
}
void QmitkTotalSegmentatorToolGUI::OnPythonPathChanged(const QString &pyEnv)
{
if (pyEnv == QString("Select"))
{
m_Controls.previewButton->setDisabled(true);
QString path =
QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
if (!path.isEmpty())
{
this->OnPythonPathChanged(path); // recall same function for new path validation
bool oldState = m_Controls.pythonEnvComboBox->blockSignals(true); // block signal firing while inserting item
m_Controls.pythonEnvComboBox->insertItem(0, path);
m_Controls.pythonEnvComboBox->setCurrentIndex(0);
m_Controls.pythonEnvComboBox->blockSignals(
oldState); // unblock signal firing after inserting item. Remove this after Qt6 migration
}
}
else if (!this->IsTotalSegmentatorInstalled(this->GetPythonPathFromUI(pyEnv)))
{
this->ShowErrorMessage(WARNING_TOTALSEG_NOT_FOUND);
m_Controls.previewButton->setDisabled(true);
}
else
{// Show positive status meeage
m_Controls.previewButton->setDisabled(false);
QString uiPyPath = this->GetPythonPathFromUI(pyEnv);
m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(uiPyPath).first;
}
}
QString QmitkTotalSegmentatorToolGUI::GetPythonPathFromUI(const QString &pyUI) const
{
QString fullPath = pyUI;
if (-1 != fullPath.indexOf(")"))
{
fullPath = fullPath.mid(fullPath.indexOf(")") + 2);
}
return fullPath.simplified();
}
void QmitkTotalSegmentatorToolGUI::OnOverrideChecked(int state)
{
bool isEnabled = false;
if (state == Qt::Checked)
{
isEnabled = true;
m_Controls.previewButton->setDisabled(true);
m_PythonPath.clear();
}
else
{
m_PythonPath.clear();
m_Controls.previewButton->setDisabled(true);
if (m_IsInstalled)
{
const QString pythonPath = m_Installer.GetVirtualEnvPath();
auto pathObject = QmitkSetupVirtualEnvUtil::GetExactPythonPath(pythonPath);
m_PythonPath = pathObject.first;
this->EnableAll(m_IsInstalled);
}
}
m_Controls.pythonEnvComboBox->setEnabled(isEnabled);
}
void QmitkTotalSegmentatorToolGUI::OnClearInstall()
{
QDir folderPath(m_Installer.GetVirtualEnvPath());
if (folderPath.removeRecursively())
{
m_Controls.installButton->setEnabled(true);
m_IsInstalled = false;
if (!m_Controls.overrideBox->isChecked())
{
m_Controls.previewButton->setEnabled(false);
}
}
else
{
MITK_ERROR
<< "The virtual environment couldn't be removed. Please check if you have the required access privileges or, some other process is accessing the folders.";
}
}
bool QmitkTotalSegmentatorToolInstaller::SetupVirtualEnv(const QString& venvName)
{
if (GetSystemPythonPath().isEmpty())
{
return false;
}
QDir folderPath(GetBaseDir());
folderPath.mkdir(venvName);
if (!folderPath.cd(venvName))
{
return false; // Check if directory creation was successful.
}
mitk::ProcessExecutor::ArgumentListType args;
auto spExec = mitk::ProcessExecutor::New();
auto spCommand = itk::CStyleCommand::New();
spCommand->SetCallback(&PrintProcessEvent);
spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
args.push_back("-m");
args.push_back("venv");
args.push_back(venvName.toStdString());
#ifdef _WIN32
QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python.exe";
QString pythonExeFolder = "Scripts";
#else
QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python3";
QString pythonExeFolder = "bin";
#endif
spExec->Execute(GetBaseDir().toStdString(), pythonFile.toStdString(), args); // Setup local virtual environment
if (folderPath.cd(pythonExeFolder))
{
this->SetPythonPath(folderPath.absolutePath());
this->SetPipPath(folderPath.absolutePath());
this->InstallPytorch();
for (auto &package : PACKAGES)
{
this->PipInstall(package.toStdString(), &PrintProcessEvent);
}
std::string pythonCode; // python syntax to check if torch is installed with CUDA.
pythonCode.append("import torch;");
pythonCode.append("print('Pytorch was installed with CUDA') if torch.cuda.is_available() else print('PyTorch was "
"installed WITHOUT CUDA');");
this->ExecutePython(pythonCode, &PrintProcessEvent);
return true;
}
return false;
}
QString QmitkTotalSegmentatorToolInstaller::GetVirtualEnvPath()
{
return STORAGE_DIR + VENV_NAME;
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
index 6e449c5a4e..b39262f9ad 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
@@ -1,1197 +1,1197 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitknnUNetToolGUI.h"
#include "mitkProcessExecutor.h"
#include "mitknnUnetTool.h"
#include <mitkTimeNavigationController.h>
#include <QApplication>
#include <QDir>
#include <QDirIterator>
#include <QIcon>
#include <QmitkStyleManager.h>
#include <QmitknnUNetEnsembleLayout.h>
#include <QtGlobal>
#include <algorithm>
#include <ctkCollapsibleGroupBox.h>
#include <itksys/SystemTools.hxx>
#include <nlohmann/json.hpp>
#include <mitkIOUtil.h>
MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitknnUNetToolGUI, "")
QmitknnUNetToolGUI::QmitknnUNetToolGUI() : QmitkMultiLabelSegWithPreviewToolGUIBase(), m_SuperclassEnableConfirmSegBtnFnc(m_EnableConfirmSegBtnFnc)
{
// Nvidia-smi command returning zero doesn't always imply lack of GPUs.
// Pytorch uses its own libraries to communicate to the GPUs. Hence, only a warning can be given.
if (m_GpuLoader.GetGPUCount() == 0)
{
std::string warning = "WARNING: No GPUs were detected on your machine. The nnUNet tool might not work.";
this->ShowErrorMessage(warning);
}
// define predicates for multi modal data selection combobox
auto imageType = mitk::TNodePredicateDataType<mitk::Image>::New();
auto labelSetImageType = mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
m_MultiModalPredicate = mitk::NodePredicateAnd::New(imageType, labelSetImageType).GetPointer();
m_nnUNetThread = new QThread(this);
m_Worker = new nnUNetDownloadWorker;
m_Worker->moveToThread(m_nnUNetThread);
m_EnableConfirmSegBtnFnc = [this](bool enabled)
{
return !m_FirstPreviewComputation ? m_SuperclassEnableConfirmSegBtnFnc(enabled) : false;
};
}
QmitknnUNetToolGUI::~QmitknnUNetToolGUI()
{
m_nnUNetThread->quit();
m_nnUNetThread->wait();
}
void QmitknnUNetToolGUI::ConnectNewTool(mitk::SegWithPreviewTool *newTool)
{
Superclass::ConnectNewTool(newTool);
newTool->IsTimePointChangeAwareOff();
m_FirstPreviewComputation = true;
}
void QmitknnUNetToolGUI::InitializeUI(QBoxLayout *mainLayout)
{
m_Controls.setupUi(this);
#ifndef _WIN32
m_Controls.pythonEnvComboBox->addItem("/usr/bin");
#endif
m_Controls.pythonEnvComboBox->addItem("Select");
AutoParsePythonPaths();
SetGPUInfo();
connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewRequested()));
connect(m_Controls.modeldirectoryBox,
SIGNAL(directoryChanged(const QString &)),
this,
SLOT(OnDirectoryChanged(const QString &)));
connect(
m_Controls.modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
connect(m_Controls.taskBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTaskChanged(const QString &)));
connect(
m_Controls.plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
connect(m_Controls.multiModalBox, SIGNAL(stateChanged(int)), this, SLOT(OnCheckBoxChanged(int)));
connect(m_Controls.pythonEnvComboBox,
#if QT_VERSION >= 0x050F00 // 5.15
SIGNAL(textActivated(const QString &)),
#elif QT_VERSION >= 0x050C00 // 5.12
SIGNAL(currentTextChanged(const QString &)),
#endif
this,
SLOT(OnPythonPathChanged(const QString &)));
connect(m_Controls.refreshdirectoryBox, SIGNAL(clicked()), this, SLOT(OnRefreshPresssed()));
connect(m_Controls.clearCacheButton, SIGNAL(clicked()), this, SLOT(OnClearCachePressed()));
connect(m_Controls.startDownloadButton, SIGNAL(clicked()), this, SLOT(OnDownloadModel()));
connect(m_Controls.stopDownloadButton, SIGNAL(clicked()), this, SLOT(OnStopDownload()));
// Qthreads
qRegisterMetaType<mitk::ProcessExecutor::Pointer>();
qRegisterMetaType<mitk::ProcessExecutor::ArgumentListType>();
connect(this, &QmitknnUNetToolGUI::Operate, m_Worker, &nnUNetDownloadWorker::DoWork);
connect(m_Worker, &nnUNetDownloadWorker::Exit, this, &QmitknnUNetToolGUI::OnDownloadWorkerExit);
connect(m_nnUNetThread, &QThread::finished, m_Worker, &QObject::deleteLater);
m_Controls.multiModalValueLabel->setStyleSheet("font-weight: bold; color: white");
m_Controls.multiModalValueLabel->setVisible(false);
m_Controls.requiredModalitiesLabel->setVisible(false);
m_Controls.stopDownloadButton->setVisible(false);
m_Controls.previewButton->setEnabled(false);
QIcon refreshIcon =
QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/view-refresh.svg"));
m_Controls.refreshdirectoryBox->setIcon(refreshIcon);
QIcon dirIcon =
QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-open.svg"));
m_Controls.modeldirectoryBox->setIcon(dirIcon);
m_Controls.refreshdirectoryBox->setEnabled(true);
QIcon stopIcon =
QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/status/dialog-error.svg"));
m_Controls.stopDownloadButton->setIcon(stopIcon);
m_Controls.statusLabel->setTextFormat(Qt::RichText);
if (m_GpuLoader.GetGPUCount() != 0)
{
WriteStatusMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
" GPUs were detected.</i>"));
}
else
{
WriteErrorMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
" GPUs were detected.</i>"));
}
mainLayout->addLayout(m_Controls.verticalLayout);
Superclass::InitializeUI(mainLayout);
m_UI_ROWS = m_Controls.advancedSettingsLayout->rowCount(); // Must do. Row count is correct only here.
this->DisableEverything();
QString lastSelectedPyEnv = m_Settings.value("nnUNet/LastPythonPath").toString();
m_Controls.pythonEnvComboBox->setCurrentText(lastSelectedPyEnv);
}
void QmitknnUNetToolGUI::EnableWidgets(bool enabled)
{
Superclass::EnableWidgets(enabled);
}
void QmitknnUNetToolGUI::ClearAllModalities()
{
m_Controls.multiModalBox->setChecked(false);
this->ClearAllModalLabels();
}
void QmitknnUNetToolGUI::ClearAllModalLabels()
{
for (auto modalLabel : m_ModalLabels)
{
delete modalLabel; // delete the layout item
m_ModalLabels.pop_back();
}
m_Controls.advancedSettingsLayout->update();
}
void QmitknnUNetToolGUI::DisableEverything()
{
m_Controls.modeldirectoryBox->setEnabled(false);
m_Controls.refreshdirectoryBox->setEnabled(false);
m_Controls.previewButton->setEnabled(false);
m_Controls.multiModalValueLabel->setVisible(false);
m_Controls.multiModalBox->setEnabled(false);
this->ClearAllComboBoxes();
this->ClearAllModalities();
}
void QmitknnUNetToolGUI::ClearAllComboBoxes()
{
m_Controls.modelBox->clear();
m_Controls.taskBox->clear();
m_Controls.foldBox->clear();
m_Controls.trainerBox->clear();
m_Controls.plannerBox->clear();
for (auto &layout : m_EnsembleParams)
{
layout->modelBox->clear();
layout->trainerBox->clear();
layout->plannerBox->clear();
layout->foldBox->clear();
}
}
std::vector<mitk::Image::ConstPointer> QmitknnUNetToolGUI::FetchMultiModalImagesFromUI()
{
std::vector<mitk::Image::ConstPointer> modals;
if (m_Controls.multiModalBox->isChecked() && !m_Modalities.empty())
{
std::set<std::string> nodeNames; // set container for keeping names of all nodes to check if they are added twice.
for (QmitkSingleNodeSelectionWidget *modality : m_Modalities)
{
mitk::DataNode::Pointer node = modality->GetSelectedNode();
if (nodeNames.find(node->GetName()) == nodeNames.end())
{
modals.push_back(dynamic_cast<const mitk::Image *>(node->GetData()));
nodeNames.insert(node->GetName());
}
else
{
throw std::runtime_error("Same modality is selected more than once. Please change your selection.");
break;
}
}
}
return modals;
}
bool QmitknnUNetToolGUI::IsNNUNetInstalled(const QString &pythonPath)
{
QString fullPath = pythonPath;
#ifdef _WIN32
if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
{
fullPath += QDir::separator() + QString("Scripts");
}
#else
if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
{
fullPath += QDir::separator() + QString("bin");
}
#endif
fullPath = fullPath.mid(fullPath.indexOf(" ") + 1);
bool isExists = QFile::exists(fullPath + QDir::separator() + QString("nnUNet_predict")) &&
QFile::exists(fullPath + QDir::separator() + QString("python3"));
return isExists;
}
void QmitknnUNetToolGUI::ShowErrorMessage(const std::string &message, QMessageBox::Icon icon)
{
this->setCursor(Qt::ArrowCursor);
QMessageBox *messageBox = new QMessageBox(icon, nullptr, message.c_str());
messageBox->exec();
delete messageBox;
MITK_WARN << message;
}
void QmitknnUNetToolGUI::WriteStatusMessage(const QString &message)
{
m_Controls.statusLabel->setText(message);
m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: white");
}
void QmitknnUNetToolGUI::WriteErrorMessage(const QString &message)
{
m_Controls.statusLabel->setText(message);
m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: red");
}
void QmitknnUNetToolGUI::ProcessEnsembleModelsParams(mitk::nnUNetTool::Pointer tool)
{
if (m_EnsembleParams[0]->modelBox->currentText() == m_EnsembleParams[1]->modelBox->currentText())
{
throw std::runtime_error("Both models you have selected for ensembling are the same.");
}
QString taskName = m_Controls.taskBox->currentText();
bool isPPJson = m_Controls.postProcessingCheckBox->isChecked();
std::vector<mitk::ModelParams> requestQ;
QString ppDirFolderNamePart1 = "ensemble_";
QStringList ppDirFolderNameParts;
for (auto &layout : m_EnsembleParams)
{
QStringList ppDirFolderName;
QString modelName = layout->modelBox->currentText();
ppDirFolderName << modelName;
ppDirFolderName << "__";
QString trainer = layout->trainerBox->currentText();
ppDirFolderName << trainer;
ppDirFolderName << "__";
QString planId = layout->plannerBox->currentText();
ppDirFolderName << planId;
if (!this->IsModelExists(modelName, taskName, QString(trainer + "__" + planId)))
{
std::string errorMsg = "The configuration " + modelName.toStdString() +
" you have selected doesn't exist. Check your Results Folder again.";
throw std::runtime_error(errorMsg);
}
std::vector<std::string> testfold = FetchSelectedFoldsFromUI(layout->foldBox);
mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, testfold);
requestQ.push_back(modelObject);
ppDirFolderNameParts << ppDirFolderName.join(QString(""));
}
tool->EnsembleOn();
if (isPPJson)
{
QString ppJsonFilePossibility1 = QDir::cleanPath(
m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.first() + "--" +
ppDirFolderNameParts.last() + QDir::separator() + "postprocessing.json");
QString ppJsonFilePossibility2 = QDir::cleanPath(
m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.last() + "--" +
ppDirFolderNameParts.first() + QDir::separator() + "postprocessing.json");
if (QFile(ppJsonFilePossibility1).exists())
{
tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility1.toStdString());
const QString statusMsg = "<i>Post Processing JSON file found: </i>" + ppJsonFilePossibility1;
this->WriteStatusMessage(statusMsg);
}
else if (QFile(ppJsonFilePossibility2).exists())
{
tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility2.toStdString());
const QString statusMsg = "<i>Post Processing JSON file found:</i>" + ppJsonFilePossibility2;
this->WriteStatusMessage(statusMsg);
}
else
{
std::string errorMsg =
"No post processing file was found for the selected ensemble combination. Continuing anyway...";
this->ShowErrorMessage(errorMsg);
}
}
tool->m_ParamQ.clear();
tool->m_ParamQ = requestQ;
}
void QmitknnUNetToolGUI::ProcessModelParams(mitk::nnUNetTool::Pointer tool)
{
tool->EnsembleOff();
std::vector<mitk::ModelParams> requestQ;
QString modelName = m_Controls.modelBox->currentText();
QString taskName = m_Controls.taskBox->currentText();
QString trainer = m_Controls.trainerBox->currentText();
QString planId = m_Controls.plannerBox->currentText();
std::vector<std::string> fetchedFolds = this->FetchSelectedFoldsFromUI(m_Controls.foldBox);
mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, fetchedFolds);
requestQ.push_back(modelObject);
tool->m_ParamQ.clear();
tool->m_ParamQ = requestQ;
}
bool QmitknnUNetToolGUI::IsModelExists(const QString &modelName, const QString &taskName, const QString &trainerPlanner)
{
QString modelSearchPath =
QDir::cleanPath(m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + modelName +
QDir::separator() + taskName + QDir::separator() + trainerPlanner);
if (QDir(modelSearchPath).exists())
{
return true;
}
return false;
}
void QmitknnUNetToolGUI::CheckAllInCheckableComboBox(ctkCheckableComboBox *foldBox)
{
// Recalling all added items to check-mark it.
const QAbstractItemModel *qaim = foldBox->checkableModel();
auto rows = qaim->rowCount();
for (std::remove_const_t<decltype(rows)> i = 0; i < rows; ++i)
{
const QModelIndex mi = qaim->index(i, 0);
foldBox->setCheckState(mi, Qt::Checked);
}
}
std::pair<QStringList, QStringList> QmitknnUNetToolGUI::ExtractTrainerPlannerFromString(QStringList trainerPlanners)
{
QString splitterString = "__";
QStringList trainers, planners;
for (const auto &trainerPlanner : trainerPlanners)
{
- trainers << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).first();
- planners << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).last();
+ trainers << trainerPlanner.split(splitterString, Qt::SkipEmptyParts).first();
+ planners << trainerPlanner.split(splitterString, Qt::SkipEmptyParts).last();
}
trainers.removeDuplicates();
planners.removeDuplicates();
return std::make_pair(trainers, planners);
}
std::vector<std::string> QmitknnUNetToolGUI::FetchSelectedFoldsFromUI(ctkCheckableComboBox *foldBox)
{
std::vector<std::string> folds;
if (foldBox->noneChecked())
{
this->CheckAllInCheckableComboBox(foldBox);
}
QModelIndexList foldList = foldBox->checkedIndexes();
for (const auto &index : foldList)
{
QString foldQString = foldBox->itemText(index.row());
if(foldQString != "dummy_element_that_nobody_can_see")
{
- foldQString = foldQString.split("_", QString::SplitBehavior::SkipEmptyParts).last();
+ foldQString = foldQString.split("_", Qt::SkipEmptyParts).last();
folds.push_back(foldQString.toStdString());
}
else
{
throw std::runtime_error("Folds are not recognized. Please check if your nnUNet results folder structure is legitimate");
}
}
return folds;
}
void QmitknnUNetToolGUI::UpdateCacheCountOnUI()
{
QString cacheText = m_CACHE_COUNT_BASE_LABEL + QString::number(m_Cache.size());
m_Controls.cacheCountLabel->setText(cacheText);
}
void QmitknnUNetToolGUI::AddToCache(size_t &hashKey, mitk::LabelSetImage::ConstPointer mlPreview)
{
nnUNetCache *newCacheObj = new nnUNetCache;
newCacheObj->m_SegCache = mlPreview;
m_Cache.insert(hashKey, newCacheObj);
MITK_INFO << "New hash: " << hashKey << " " << newCacheObj->m_SegCache.GetPointer();
this->UpdateCacheCountOnUI();
}
void QmitknnUNetToolGUI::SetGPUInfo()
{
std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
for (const QmitkGPUSpec &gpuSpec : specs)
{
m_Controls.gpuComboBox->addItem(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
}
if (specs.empty())
{
m_Controls.gpuComboBox->setEditable(true);
m_Controls.gpuComboBox->addItem(QString::number(0));
m_Controls.gpuComboBox->setValidator(new QIntValidator(0, 999, this));
}
}
unsigned int QmitknnUNetToolGUI::FetchSelectedGPUFromUI()
{
QString gpuInfo = m_Controls.gpuComboBox->currentText();
if (m_GpuLoader.GetGPUCount() == 0)
{
return static_cast<unsigned int>(gpuInfo.toInt());
}
else
{
- QString gpuId = gpuInfo.split(":", QString::SplitBehavior::SkipEmptyParts).first();
+ QString gpuId = gpuInfo.split(":", Qt::SkipEmptyParts).first();
return static_cast<unsigned int>(gpuId.toInt());
}
}
QString QmitknnUNetToolGUI::FetchResultsFolderFromEnv()
{
const char *pathVal = itksys::SystemTools::GetEnv("RESULTS_FOLDER");
QString retVal;
if (pathVal)
{
retVal = QString::fromUtf8(pathVal);
}
else
{
retVal = m_Settings.value("nnUNet/LastRESULTS_FOLDERPath").toString();
}
return retVal;
}
void QmitknnUNetToolGUI::DumpJSONfromPickle(const QString &picklePath)
{
const QString pickleFile = picklePath + QDir::separator() + m_PICKLE_FILENAME;
const QString jsonFile = picklePath + QDir::separator() + m_MITK_EXPORT_JSON_FILENAME;
if (!QFile::exists(jsonFile))
{
mitk::ProcessExecutor::Pointer spExec = mitk::ProcessExecutor::New();
mitk::ProcessExecutor::ArgumentListType args;
args.push_back("-c");
std::string pythonCode; // python syntax to parse plans.pkl file and export as Json file.
pythonCode.append("import pickle;");
pythonCode.append("import json;");
pythonCode.append("loaded_pickle = pickle.load(open('");
pythonCode.append(pickleFile.toStdString());
pythonCode.append("','rb'));");
pythonCode.append("modal_dict = {key: loaded_pickle[key] for key in loaded_pickle.keys() if key in "
"['modalities','num_modalities']};");
pythonCode.append("json.dump(modal_dict, open('");
pythonCode.append(jsonFile.toStdString());
pythonCode.append("', 'w'))");
args.push_back(pythonCode);
try
{
spExec->Execute(m_PythonPath.toStdString(), "python3", args);
}
catch (const mitk::Exception &e)
{
MITK_ERROR << "Pickle parsing FAILED!" << e.GetDescription();
this->WriteStatusMessage(
"Parsing failed in backend. Multiple Modalities will now have to be manually entered by the user.");
}
}
}
void QmitknnUNetToolGUI::ExportAvailableModelsAsJSON(const QString &resultsFolder)
{
const QString jsonPath = resultsFolder + QDir::separator() + m_AVAILABLE_MODELS_JSON_FILENAME;
if (!QFile::exists(jsonPath))
{
auto spExec = mitk::ProcessExecutor::New();
mitk::ProcessExecutor::ArgumentListType args;
args.push_back("--export");
args.push_back(resultsFolder.toStdString());
try
{
spExec->Execute(m_PythonPath.toStdString(), "nnUNet_print_available_pretrained_models", args);
}
catch (const mitk::Exception &e)
{
MITK_ERROR << "Exporting information FAILED." << e.GetDescription();
this->WriteStatusMessage("Exporting information FAILED.");
}
}
}
void QmitknnUNetToolGUI::DisplayMultiModalInfoFromJSON(const QString &jsonPath)
{
std::ifstream file(jsonPath.toStdString());
if (file.is_open())
{
auto jsonObj = nlohmann::json::parse(file, nullptr, false);
if (jsonObj.is_discarded() || !jsonObj.is_object())
{
MITK_ERROR << "Could not parse \"" << jsonPath.toStdString() << "\" as JSON object!";
return;
}
auto num_mods = jsonObj["num_modalities"].get<int>();
this->ClearAllModalLabels();
if (num_mods > 1)
{
m_Controls.multiModalBox->setChecked(true);
m_Controls.multiModalBox->setEnabled(false);
m_Controls.multiModalValueLabel->setText(QString::number(num_mods));
OnModalitiesNumberChanged(num_mods);
m_Controls.advancedSettingsLayout->update();
auto obj = jsonObj["modalities"];
int count = 0;
for (const auto &value : obj)
{
QLabel *label = new QLabel(QString::fromStdString("<i>" + value.get<std::string>() + "</i>"), this);
m_ModalLabels.push_back(label);
m_Controls.advancedSettingsLayout->addWidget(label, m_UI_ROWS + 1 + count, 0);
count++;
}
m_Controls.advancedSettingsLayout->update();
}
else
{
m_Controls.multiModalBox->setChecked(false);
}
}
}
void QmitknnUNetToolGUI::FillAvailableModelsInfoFromJSON(const QString &jsonPath)
{
std::ifstream file(jsonPath.toStdString());
if (file.is_open() && m_Controls.availableBox->count() < 1)
{
auto jsonObj = nlohmann::json::parse(file, nullptr, false);
if (jsonObj.is_discarded() || !jsonObj.is_object())
{
MITK_ERROR << "Could not parse \"" << jsonPath.toStdString() << "\" as JSON object!";
return;
}
for (const auto &obj : jsonObj.items())
{
m_Controls.availableBox->addItem(QString::fromStdString(obj.key()));
}
}
}
mitk::ModelParams QmitknnUNetToolGUI::MapToRequest(const QString &modelName,
const QString &taskName,
const QString &trainer,
const QString &planId,
const std::vector<std::string> &folds)
{
mitk::ModelParams requestObject;
requestObject.model = modelName.toStdString();
requestObject.trainer = trainer.toStdString();
requestObject.planId = planId.toStdString();
requestObject.task = taskName.toStdString();
requestObject.folds = folds;
mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
requestObject.inputName = tool->GetRefNode()->GetName();
requestObject.timeStamp =
std::to_string(mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint());
return requestObject;
}
void QmitknnUNetToolGUI::SetComboBoxToNone(ctkCheckableComboBox* comboBox)
{
comboBox->clear();
comboBox->addItem("dummy_element_that_nobody_can_see");
qobject_cast<QListView *>(comboBox->view())->setRowHidden(0, true); // For the cosmetic purpose of showing "None" on the combobox.
}
/* ---------------------SLOTS---------------------------------------*/
void QmitknnUNetToolGUI::OnPreviewRequested()
{
mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
if (nullptr != tool)
{
QString pythonPathTextItem = "";
try
{
size_t hashKey(0);
m_Controls.previewButton->setEnabled(false); // To prevent misclicked back2back prediction.
qApp->processEvents();
tool->PredictOn(); // purposefully placed to make tool->GetMTime different than before.
QString modelName = m_Controls.modelBox->currentText();
if (modelName.startsWith("ensemble", Qt::CaseInsensitive))
{
this->ProcessEnsembleModelsParams(tool);
}
else
{
this->ProcessModelParams(tool);
}
pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
QString pythonPath = m_PythonPath;
if (!this->IsNNUNetInstalled(pythonPath))
{
throw std::runtime_error("nnUNet is not detected in the selected python environment. Please select a valid "
"python environment or install nnUNet.");
}
tool->SetPythonPath(pythonPath.toStdString());
tool->SetModelDirectory(m_ParentFolder->getResultsFolder().toStdString());
// checkboxes
tool->SetMirror(m_Controls.mirrorBox->isChecked());
tool->SetMixedPrecision(m_Controls.mixedPrecisionBox->isChecked());
tool->SetNoPip(false);
bool doCache = m_Controls.enableCachingCheckBox->isChecked();
// Spinboxes
tool->SetGpuId(FetchSelectedGPUFromUI());
// Multi-Modal
tool->MultiModalOff();
if (m_Controls.multiModalBox->isChecked())
{
tool->m_OtherModalPaths.clear();
tool->m_OtherModalPaths = FetchMultiModalImagesFromUI();
tool->MultiModalOn();
}
if (doCache)
{
hashKey = nnUNetCache::GetUniqueHash(tool->m_ParamQ);
if (m_Cache.contains(hashKey))
{
tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
}
}
if (tool->GetPredict())
{
tool->m_InputBuffer = nullptr;
this->WriteStatusMessage(
QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
tool->UpdatePreview();
if (nullptr == tool->GetOutputBuffer())
{
this->SegmentationProcessFailed();
}
else
{
this->SegmentationResultHandler(tool);
if (doCache)
{
this->AddToCache(hashKey, tool->GetOutputBuffer());
}
tool->ClearOutputBuffer();
}
tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
}
else
{
MITK_INFO << "won't do segmentation. Key found: " << QString::number(hashKey).toStdString();
if (m_Cache.contains(hashKey))
{
nnUNetCache *cacheObject = m_Cache[hashKey];
MITK_INFO << "fetched pointer " << cacheObject->m_SegCache.GetPointer();
tool->SetOutputBuffer(const_cast<mitk::LabelSetImage *>(cacheObject->m_SegCache.GetPointer()));
this->SegmentationResultHandler(tool, true);
}
}
m_Controls.previewButton->setEnabled(true);
}
catch (const std::exception &e)
{
std::stringstream errorMsg;
errorMsg << "<b>STATUS: </b>Error while processing parameters for nnUNet segmentation. Reason: " << e.what();
this->ShowErrorMessage(errorMsg.str());
this->WriteErrorMessage(QString::fromStdString(errorMsg.str()));
m_Controls.previewButton->setEnabled(true);
tool->PredictOff();
return;
}
catch (...)
{
std::string errorMsg = "Unkown error occured while generation nnUNet segmentation.";
this->ShowErrorMessage(errorMsg);
m_Controls.previewButton->setEnabled(true);
tool->PredictOff();
return;
}
if (!pythonPathTextItem.isEmpty())
{ // only cache if the prediction ended without errors.
m_Settings.setValue("nnUNet/LastPythonPath", pythonPathTextItem);
}
}
}
void QmitknnUNetToolGUI::OnRefreshPresssed()
{
const QString resultsFolder = m_Controls.modeldirectoryBox->directory();
this->OnDirectoryChanged(resultsFolder);
}
void QmitknnUNetToolGUI::OnDirectoryChanged(const QString &resultsFolder)
{
m_IsResultsFolderValid = false;
m_Controls.previewButton->setEnabled(false);
this->ClearAllComboBoxes();
this->ClearAllModalities();
m_ParentFolder = std::make_shared<QmitknnUNetFolderParser>(resultsFolder);
auto tasks = m_ParentFolder->getAllTasks<QStringList>();
tasks.removeDuplicates();
std::for_each(tasks.begin(), tasks.end(), [this](QString task) { m_Controls.taskBox->addItem(task); });
m_Settings.setValue("nnUNet/LastRESULTS_FOLDERPath", resultsFolder);
}
void QmitknnUNetToolGUI::OnModelChanged(const QString &model)
{
if (model.isEmpty())
{
return;
}
this->ClearAllModalities();
auto selectedTask = m_Controls.taskBox->currentText();
ctkComboBox *box = qobject_cast<ctkComboBox *>(sender());
if (box == m_Controls.modelBox)
{
if (model == m_VALID_MODELS.last())
{
m_Controls.trainerBox->setVisible(false);
m_Controls.trainerLabel->setVisible(false);
m_Controls.plannerBox->setVisible(false);
m_Controls.plannerLabel->setVisible(false);
m_Controls.foldBox->setVisible(false);
m_Controls.foldLabel->setVisible(false);
m_Controls.previewButton->setEnabled(false);
this->ShowEnsembleLayout(true);
auto models = m_ParentFolder->getModelsForTask<QStringList>(m_Controls.taskBox->currentText());
models.removeDuplicates();
models.removeOne(m_VALID_MODELS.last());
for (auto &layout : m_EnsembleParams)
{
layout->modelBox->clear();
layout->trainerBox->clear();
layout->plannerBox->clear();
std::for_each(models.begin(),
models.end(),
[&layout, this](QString model)
{
if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
layout->modelBox->addItem(model);
});
}
}
else
{
m_Controls.trainerBox->setVisible(true);
m_Controls.trainerLabel->setVisible(true);
m_Controls.plannerBox->setVisible(true);
m_Controls.plannerLabel->setVisible(true);
m_Controls.foldBox->setVisible(true);
m_Controls.foldLabel->setVisible(true);
m_Controls.previewButton->setEnabled(false);
this->ShowEnsembleLayout(false);
m_Controls.trainerBox->clear();
m_Controls.plannerBox->clear();
auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
if(trainerPlanners.isEmpty())
{
this->ShowErrorMessage("No plans.pkl found for "+model.toStdString()+". Check your directory or download the task again.");
this->SetComboBoxToNone(m_Controls.foldBox);
return;
}
QStringList trainers, planners;
std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
std::for_each(
trainers.begin(), trainers.end(), [this](QString trainer) { m_Controls.trainerBox->addItem(trainer); });
std::for_each(
planners.begin(), planners.end(), [this](QString planner) { m_Controls.plannerBox->addItem(planner); });
}
}
else if (!m_EnsembleParams.empty())
{
m_Controls.previewButton->setEnabled(false);
for (auto &layout : m_EnsembleParams)
{
if (box == layout->modelBox)
{
layout->trainerBox->clear();
layout->plannerBox->clear();
auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
if(trainerPlanners.isEmpty())
{
this->ShowErrorMessage("No plans.pkl found for "+model.toStdString()+". Check your directory or download the task again.");
this->SetComboBoxToNone(layout->foldBox);
return;
}
QStringList trainers, planners;
std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
std::for_each(trainers.begin(),
trainers.end(),
[&layout](const QString &trainer) { layout->trainerBox->addItem(trainer); });
std::for_each(planners.begin(),
planners.end(),
[&layout](const QString &planner) { layout->plannerBox->addItem(planner); });
break;
}
}
}
}
void QmitknnUNetToolGUI::OnTaskChanged(const QString &task)
{
if (task.isEmpty())
{
return;
}
m_Controls.modelBox->clear();
auto models = m_ParentFolder->getModelsForTask<QStringList>(task);
models.removeDuplicates();
if (!models.contains(m_VALID_MODELS.last(), Qt::CaseInsensitive))
{
models << m_VALID_MODELS.last(); // add ensemble even if folder doesn't exist
}
std::for_each(models.begin(),
models.end(),
[this](QString model)
{
if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
m_Controls.modelBox->addItem(model);
});
}
void QmitknnUNetToolGUI::OnTrainerChanged(const QString &plannerSelected)
{
if (plannerSelected.isEmpty())
{
return;
}
m_IsResultsFolderValid = false;
QString parentPath;
auto *box = qobject_cast<ctkComboBox *>(sender());
if (box == m_Controls.plannerBox)
{
m_Controls.foldBox->clear();
auto selectedTrainer = m_Controls.trainerBox->currentText();
auto selectedTask = m_Controls.taskBox->currentText();
auto selectedModel = m_Controls.modelBox->currentText();
auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
selectedTrainer, plannerSelected, selectedTask, selectedModel);
if(folds.isEmpty())
{
this->ShowErrorMessage("No valid folds found. Check your directory or download the task again.");
this->SetComboBoxToNone(m_Controls.foldBox);
return;
}
std::for_each(folds.begin(),
folds.end(),
[this](QString fold)
{
if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
m_Controls.foldBox->addItem(fold);
});
if (m_Controls.foldBox->count() != 0)
{
m_IsResultsFolderValid = true;
this->CheckAllInCheckableComboBox(m_Controls.foldBox);
auto tempPath = QStringList() << m_ParentFolder->getResultsFolder() << "nnUNet" << selectedModel << selectedTask
<< QString("%1__%2").arg(selectedTrainer, plannerSelected);
parentPath = QDir::cleanPath(tempPath.join(QDir::separator()));
}
}
else if (!m_EnsembleParams.empty())
{
for (auto &layout : m_EnsembleParams)
{
if (box == layout->plannerBox)
{
layout->foldBox->clear();
auto selectedTrainer = layout->trainerBox->currentText();
auto selectedTask = m_Controls.taskBox->currentText();
auto selectedModel = layout->modelBox->currentText();
auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
selectedTrainer, plannerSelected, selectedTask, selectedModel);
if(folds.isEmpty())
{
this->ShowErrorMessage("No valid folds found. Check your directory.");
this->SetComboBoxToNone(layout->foldBox);
return;
}
std::for_each(folds.begin(),
folds.end(),
[&layout](const QString &fold)
{
if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
layout->foldBox->addItem(fold);
});
if (layout->foldBox->count() != 0)
{
this->CheckAllInCheckableComboBox(layout->foldBox);
m_IsResultsFolderValid = true;
auto tempPath = QStringList() << m_ParentFolder->getResultsFolder() << "nnUNet" << selectedModel
<< selectedTask << QString("%1__%2").arg(selectedTrainer, plannerSelected);
parentPath = QDir::cleanPath(tempPath.join(QDir::separator()));
}
break;
}
}
}
if (m_IsResultsFolderValid)
{
m_Controls.previewButton->setEnabled(true);
const QString mitkJsonFile = parentPath + QDir::separator() + m_MITK_EXPORT_JSON_FILENAME;
this->DumpJSONfromPickle(parentPath);
if (QFile::exists(mitkJsonFile))
{
this->DisplayMultiModalInfoFromJSON(mitkJsonFile);
}
}
}
void QmitknnUNetToolGUI::OnPythonPathChanged(const QString &pyEnv)
{
if (pyEnv == QString("Select"))
{
QString path =
QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
if (!path.isEmpty())
{
this->OnPythonPathChanged(path); // recall same function for new path validation
m_Controls.pythonEnvComboBox->insertItem(0, path);
m_Controls.pythonEnvComboBox->setCurrentIndex(0);
}
}
else if (!this->IsNNUNetInstalled(pyEnv))
{
std::string warning =
"WARNING: nnUNet is not detected on the Python environment you selected. Please select another "
"environment or create one. For more info refer https://github.com/MIC-DKFZ/nnUNet";
this->ShowErrorMessage(warning);
this->DisableEverything();
m_Controls.availableBox->clear();
}
else
{
m_Controls.modeldirectoryBox->setEnabled(true);
m_Controls.refreshdirectoryBox->setEnabled(true);
m_Controls.multiModalBox->setEnabled(true);
QString setVal = this->FetchResultsFolderFromEnv();
if (!setVal.isEmpty())
{
m_Controls.modeldirectoryBox->setDirectory(setVal);
}
this->OnRefreshPresssed();
m_PythonPath = pyEnv.mid(pyEnv.indexOf(" ") + 1);
#ifdef _WIN32
if (!(m_PythonPath.endsWith("Scripts", Qt::CaseInsensitive) || m_PythonPath.endsWith("Scripts/", Qt::CaseInsensitive)))
{
m_PythonPath += QDir::separator() + QString("Scripts");
}
#else
if (!(m_PythonPath.endsWith("bin", Qt::CaseInsensitive) || m_PythonPath.endsWith("bin/", Qt::CaseInsensitive)))
{
m_PythonPath += QDir::separator() + QString("bin");
}
#endif
// Export available model info as json and fill them for Download
QString tempPath = QString::fromStdString(mitk::IOUtil::GetTempPath());
this->ExportAvailableModelsAsJSON(tempPath);
const QString jsonPath = tempPath + QDir::separator() + m_AVAILABLE_MODELS_JSON_FILENAME;
if (QFile::exists(jsonPath))
{
this->FillAvailableModelsInfoFromJSON(jsonPath);
}
}
}
void QmitknnUNetToolGUI::OnCheckBoxChanged(int state)
{
bool visibility = false;
if (state == Qt::Checked)
{
visibility = true;
}
ctkCheckBox *box = qobject_cast<ctkCheckBox *>(sender());
if (box != nullptr)
{
if (box->objectName() == QString("multiModalBox"))
{
m_Controls.requiredModalitiesLabel->setVisible(visibility);
m_Controls.multiModalValueLabel->setVisible(visibility);
if (!visibility)
{
this->OnModalitiesNumberChanged(0);
m_Controls.multiModalValueLabel->setText("0");
this->ClearAllModalLabels();
}
}
}
}
void QmitknnUNetToolGUI::OnModalitiesNumberChanged(int num)
{
while (num > static_cast<int>(m_Modalities.size()))
{
QmitkSingleNodeSelectionWidget *multiModalBox = new QmitkSingleNodeSelectionWidget(this);
mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
multiModalBox->SetDataStorage(tool->GetDataStorage());
multiModalBox->SetInvalidInfo("Select corresponding modalities");
multiModalBox->SetNodePredicate(m_MultiModalPredicate);
multiModalBox->setObjectName(QString("multiModal_" + QString::number(m_Modalities.size() + 1)));
m_Controls.advancedSettingsLayout->addWidget(multiModalBox, m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
m_Modalities.push_back(multiModalBox);
}
while (num < static_cast<int>(m_Modalities.size()) && !m_Modalities.empty())
{
QmitkSingleNodeSelectionWidget *child = m_Modalities.back();
delete child; // delete the layout item
m_Modalities.pop_back();
}
m_Controls.advancedSettingsLayout->update();
}
void QmitknnUNetToolGUI::AutoParsePythonPaths()
{
QString homeDir = QDir::homePath();
std::vector<QString> searchDirs;
#ifdef _WIN32
searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
QString("anaconda3"));
#else
// Add search locations for possible standard python paths here
searchDirs.push_back(homeDir + QDir::separator() + "environments");
searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
#endif
for (QString searchDir : searchDirs)
{
if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
{
if (QDir(searchDir).exists())
{
m_Controls.pythonEnvComboBox->insertItem(0, "(base): " + searchDir);
searchDir.append((QDir::separator() + QString("envs")));
}
}
for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
{
subIt.next();
QString envName = subIt.fileName();
if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
{
m_Controls.pythonEnvComboBox->insertItem(0, "(" + envName + "): " + subIt.filePath());
}
}
}
m_Controls.pythonEnvComboBox->setCurrentIndex(-1);
}
void QmitknnUNetToolGUI::SegmentationProcessFailed()
{
this->WriteErrorMessage(
"<b>STATUS: </b><i>Error in the segmentation process. <br>No resulting segmentation can be loaded.</i>");
this->setCursor(Qt::ArrowCursor);
std::stringstream stream;
stream << "Error in the segmentation process. No resulting segmentation can be loaded.";
this->ShowErrorMessage(stream.str());
}
void QmitknnUNetToolGUI::SegmentationResultHandler(mitk::nnUNetTool *tool, bool forceRender)
{
if (forceRender)
{
tool->RenderOutputBuffer();
}
m_FirstPreviewComputation = false;
this->SetLabelSetPreview(tool->GetPreviewSegmentation());
this->WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully.</i>");
this->ActualizePreviewLabelVisibility();
}
void QmitknnUNetToolGUI::ShowEnsembleLayout(bool visible)
{
if (m_EnsembleParams.empty())
{
ctkCollapsibleGroupBox *groupBoxModel1 = new ctkCollapsibleGroupBox(this);
auto lay1 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel1);
groupBoxModel1->setObjectName(QString::fromUtf8("model_1_Box"));
groupBoxModel1->setTitle(QString::fromUtf8("Model 1"));
groupBoxModel1->setMinimumSize(QSize(0, 0));
groupBoxModel1->setCollapsedHeight(5);
groupBoxModel1->setCollapsed(false);
groupBoxModel1->setFlat(true);
groupBoxModel1->setAlignment(Qt::AlignRight);
m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 5, 0, 1, 2);
connect(lay1->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
connect(
lay1->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
m_EnsembleParams.push_back(std::move(lay1));
ctkCollapsibleGroupBox *groupBoxModel2 = new ctkCollapsibleGroupBox(this);
auto lay2 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel2);
groupBoxModel2->setObjectName(QString::fromUtf8("model_2_Box"));
groupBoxModel2->setTitle(QString::fromUtf8("Model 2"));
groupBoxModel2->setMinimumSize(QSize(0, 0));
groupBoxModel2->setCollapsedHeight(5);
groupBoxModel2->setCollapsed(false);
groupBoxModel2->setFlat(true);
groupBoxModel2->setAlignment(Qt::AlignLeft);
m_Controls.advancedSettingsLayout->addWidget(groupBoxModel2, 5, 2, 1, 2);
connect(lay2->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
connect(
lay2->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
m_EnsembleParams.push_back(std::move(lay2));
}
for (auto &layout : m_EnsembleParams)
{
layout->setVisible(visible);
}
}
void QmitknnUNetToolGUI::OnDownloadModel()
{
auto selectedTask = m_Controls.availableBox->currentText();
if(!selectedTask.isEmpty())
{
auto spExec = mitk::ProcessExecutor::New();
mitk::ProcessExecutor::ArgumentListType args;
args.push_back(selectedTask.toStdString());
this->WriteStatusMessage(
"Downloading the requested task in to the selected Results Folder. This might take some time "
"depending on your internet connection...");
m_Processes["DOWNLOAD"] = spExec;
if (!m_nnUNetThread->isRunning())
{
MITK_DEBUG << "Starting thread...";
m_nnUNetThread->start();
}
QString resultsFolder = m_ParentFolder->getResultsFolder();
emit Operate(resultsFolder, m_PythonPath, spExec, args);
m_Controls.stopDownloadButton->setVisible(true);
m_Controls.startDownloadButton->setVisible(false);
}
}
void QmitknnUNetToolGUI::OnDownloadWorkerExit(const bool isSuccess, const QString message)
{
if (isSuccess)
{
this->WriteStatusMessage(message + QString(" Click Refresh Results Folder to use the new Task."));
}
else
{
MITK_ERROR << "Download FAILED! " << message.toStdString();
this->WriteStatusMessage(QString("Download failed. Check your internet connection. " + message));
}
m_Controls.stopDownloadButton->setVisible(false);
m_Controls.startDownloadButton->setVisible(true);
}
void QmitknnUNetToolGUI::OnStopDownload()
{
mitk::ProcessExecutor::Pointer spExec = m_Processes["DOWNLOAD"];
spExec->KillProcess();
this->WriteStatusMessage("Download Killed by the user.");
m_Controls.stopDownloadButton->setVisible(false);
m_Controls.startDownloadButton->setVisible(true);
}
void QmitknnUNetToolGUI::OnClearCachePressed()
{
m_Cache.clear();
this->UpdateCacheCountOnUI();
}
diff --git a/Plugins/org.blueberry.core.runtime/src/berryReflection.cpp b/Plugins/org.blueberry.core.runtime/src/berryReflection.cpp
index 069c31cea2..44a847b61e 100644
--- a/Plugins/org.blueberry.core.runtime/src/berryReflection.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/berryReflection.cpp
@@ -1,107 +1,107 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryReflection.h"
#include "berryObject.h"
#include <QStringList>
// Better name demangling for gcc
#if __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ > 0 )
#define GCC_USEDEMANGLE
#endif
#ifdef GCC_USEDEMANGLE
#include <cstdlib>
#include <cxxabi.h>
#endif
#if defined(_WIN32) && defined(NDEBUG)
// exported from VC CRT
extern "C"
char * __unDName(char * outputString, const char * name, int maxStringLength,
void * (* pAlloc )(size_t), void (* pFree )(void *),
unsigned short disableFlags);
#endif
namespace berry {
namespace Reflection {
QString DemangleName(const char* mangledName)
{
QString name(mangledName);
#ifdef GCC_USEDEMANGLE
int status;
char* unmangled = abi::__cxa_demangle(mangledName, nullptr, nullptr, &status);
if(status == 0)
{
name = QString(unmangled);
free(unmangled);
}
#elif defined(_WIN32) && defined(NDEBUG)
char * const unmangled = __unDName(0, mangledName, 0, malloc, free, 0x2800);
if (unmangled)
{
QString unmangledName(unmangled);
- name = unmangledName.split(' ', QString::SkipEmptyParts).back();
+ name = unmangledName.split(' ', Qt::SkipEmptyParts).back();
free(unmangled);
}
#else
- name = name.split(' ', QString::SkipEmptyParts).back();
+ name = name.split(' ', Qt::SkipEmptyParts).back();
#endif
return name;
}
#ifdef GetClassName
// clash with WinUser.h definition
#undef GetClassName
#endif
QString GetClassName(const Object* obj)
{
return DemangleName(typeid(*const_cast<Object*>(obj)).name());
}
TypeInfo::Concept::~Concept(){}
template<>
struct TypeInfo::Model<EmptyType> : Concept {
QString GetName() const override { return QString(); }
QList<TypeInfo> GetSuperclasses() const override { return QList<TypeInfo>(); }
};
TypeInfo::TypeInfo()
: m_Self(std::make_shared<Model<EmptyType> >())
{
}
bool TypeInfo::operator==(const TypeInfo& other) const
{
return this->GetName() == other.GetName();
}
QString TypeInfo::GetName() const
{
return m_Self->GetName();
}
QList<TypeInfo> TypeInfo::GetSuperclasses() const
{
return m_Self->GetSuperclasses();
}
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/berryQtStyleManager.cpp b/Plugins/org.blueberry.ui.qt/src/berryQtStyleManager.cpp
index 2bf59d3112..04692dc19c 100644
--- a/Plugins/org.blueberry.ui.qt/src/berryQtStyleManager.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/berryQtStyleManager.cpp
@@ -1,399 +1,399 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryQtStyleManager.h"
#include <QApplication>
#include <QFile>
#include <QTextStream>
#include <QFileInfo>
#include <QRegularExpression>
#include <QStringList>
#include <QDirIterator>
#include <QFont>
#include <QFontDatabase>
#include <QIcon>
#include <berryLog.h>
#include <berryPlatformUI.h>
#include <berryQtPreferences.h>
#include "berryWorkbenchPlugin.h"
#include <mitkIPreferences.h>
namespace berry
{
static QString ParseColor(const QString &subject, const QString &pattern, const QString &fallback)
{
QRegularExpression re(pattern, QRegularExpression::CaseInsensitiveOption);
auto match = re.match(subject);
return match.hasMatch()
? match.captured(1)
: fallback;
}
QIcon QtStyleManager::ThemeIcon(const QByteArray &originalSVG)
{
auto styleSheet = qApp->styleSheet();
if (styleSheet.isEmpty())
return QPixmap::fromImage(QImage::fromData(originalSVG));
auto iconColor = ParseColor(styleSheet,
QStringLiteral("iconColor\\s*[=:]\\s*(#[0-9a-f]{6})"),
QStringLiteral("#000000"));
auto iconAccentColor = ParseColor(styleSheet,
QStringLiteral("iconAccentColor\\s*[=:]\\s*(#[0-9a-f]{6})"),
QStringLiteral("#ffffff"));
auto themedSVG = QString(originalSVG).replace(QStringLiteral("#00ff00"), iconColor, Qt::CaseInsensitive);
themedSVG = themedSVG.replace(QStringLiteral("#ff00ff"), iconAccentColor, Qt::CaseInsensitive);
return QPixmap::fromImage(QImage::fromData(themedSVG.toLatin1()));
}
QIcon QtStyleManager::ThemeIcon(const QString &resourcePath)
{
QFile resourceFile(resourcePath);
if (resourceFile.open(QIODevice::ReadOnly))
{
auto originalSVG = resourceFile.readAll();
return ThemeIcon(originalSVG);
}
BERRY_WARN << "Could not read " << resourcePath;
return QIcon();
}
QtStyleManager::QtStyleManager()
{
AddDefaultStyle();
AddDefaultFonts();
ReadPreferences();
}
void QtStyleManager::ReadPreferences()
{
auto* stylePref = WorkbenchPlugin::GetDefault()->GetPreferences()->Node(QtPreferences::QT_STYLES_NODE);
QString paths = QString::fromStdString(stylePref->Get(QtPreferences::QT_STYLE_SEARCHPATHS, ""));
- QStringList pathList = paths.split(";", QString::SkipEmptyParts);
+ QStringList pathList = paths.split(";", Qt::SkipEmptyParts);
QStringListIterator it(pathList);
while (it.hasNext())
{
AddStyles(it.next());
}
QString styleName = QString::fromStdString(stylePref->Get(QtPreferences::QT_STYLE_NAME, ""));
// if a style is contributed via the Qt resource mechanism, it may not be
// registered yet.
if (Contains(styleName))
SetStyle(styleName);
else
SetDefaultStyle();
}
QtStyleManager::~QtStyleManager()
{
for (FileNameToStyleMap::const_iterator i = styles.begin(); i != styles.end(); ++i)
{
delete i.value();
}
}
void QtStyleManager::AddDefaultStyle()
{
#ifndef _APPLE_
AddStyle(":/org.blueberry.ui.qt/darkstyle.qss", "Dark");
AddStyle(":/org.blueberry.ui.qt/lightstyle.qss", "Light");
defaultStyle = styles[":/org.blueberry.ui.qt/darkstyle.qss"];
#endif
}
void QtStyleManager::AddDefaultFonts()
{
m_customFontNames.append(QString("<<system>>"));
m_customFontNames.append(QString("Fira Sans"));
QFontDatabase::addApplicationFont(":/org.blueberry.ui.qt/fonts/FiraSans/FiraSans.ttf");
m_customFontNames.append(QString("Light Fira Sans"));
QFontDatabase::addApplicationFont(":/org.blueberry.ui.qt/fonts/LightFiraSans/LightFiraSans.ttf");
m_customFontNames.append(QString("Roboto"));
QFontDatabase::addApplicationFont(":/org.blueberry.ui.qt/fonts/Roboto/Roboto.ttf");
m_customFontNames.push_back(QString("Open Sans"));
QFontDatabase::addApplicationFont(":/org.blueberry.ui.qt/fonts/OpenSans/OpenSans-Regular.ttf");
m_customFontNames.push_back(QString("xkcd"));
QFontDatabase::addApplicationFont(":/org.blueberry.ui.qt/fonts/xkcd/xkcd.ttf");
}
void QtStyleManager::ClearStyles()
{
for (FileNameToStyleMap::iterator i = styles.begin(); i != styles.end(); )
{
if (!i.value()->fileName.startsWith(':'))
{
delete i.value();
i = styles.erase(i);
}
else ++i;
}
SetDefaultStyle();
}
QtStyleManager::Style QtStyleManager::GetStyle() const
{
return Style(currentStyle->name, currentStyle->fileName);
}
QString QtStyleManager::GetStylesheet() const
{
return currentStyle->stylesheet;
}
QString QtStyleManager::GetActiveTabStylesheet() const
{
return currentStyle->activeTabStylesheet;
}
QString QtStyleManager::GetTabStylesheet() const
{
return currentStyle->tabStylesheet;
}
void QtStyleManager::AddStyle(const QString& styleFileName,
const QString& styleName)
{
auto newStyle = new ExtStyle();
if (styleName.isEmpty())
{
QFileInfo info(styleFileName);
newStyle->name = info.completeBaseName();
}
else
{
newStyle->name = styleName;
}
newStyle->fileName = styleFileName;
styles.insert(newStyle->fileName, newStyle);
}
void QtStyleManager::GetFonts(QStringList& fontNames) const
{
fontNames = m_customFontNames;
}
QString QtStyleManager::GetFont() const
{
return m_currentFont;
}
void QtStyleManager::AddStyles(const QString& path)
{
QDirIterator dirIt(path);
while (dirIt.hasNext())
{
QString current = dirIt.next();
QFileInfo info = dirIt.fileInfo();
if (info.isFile() && info.isReadable())
{
QString fileName = info.fileName();
if (fileName.endsWith("-tab.qss") || fileName.endsWith("-activetab.qss"))
continue;
if (fileName.endsWith(".qss"))
AddStyle(current);
}
}
}
void QtStyleManager::ReadStyleData(ExtStyle* style)
{
QString tabStyleFileName(style->fileName);
QString activeTabStyleFileName(style->fileName);
int index = style->fileName.lastIndexOf(".qss");
tabStyleFileName.replace(index, 4, "-tab.qss");
activeTabStyleFileName.replace(index, 4, "-activetab.qss");
QFile styleFile(style->fileName);
if (styleFile.open(QIODevice::ReadOnly))
{
QTextStream in(&styleFile);
style->stylesheet = in.readAll();
}
else
{
BERRY_WARN << "Could not read " << style->fileName.toStdString();
}
QFile tabStyleFile(tabStyleFileName);
if (tabStyleFile.open(QIODevice::ReadOnly))
{
QTextStream in(&tabStyleFile);
style->tabStylesheet = in.readAll();
}
else
{
BERRY_WARN << "Could not read " << tabStyleFileName.toStdString();
}
QFile activeTabStyleFile(activeTabStyleFileName);
if (activeTabStyleFile.open(QIODevice::ReadOnly))
{
QTextStream in(&activeTabStyleFile);
style->activeTabStylesheet = in.readAll();
}
else
{
BERRY_WARN << "Could not read " << activeTabStyleFileName.toStdString();
}
}
void QtStyleManager::RemoveStyle(const QString& styleFileName)
{
if (currentStyle->fileName == styleFileName)
{
SetDefaultStyle();
}
delete styles.take(styleFileName);
}
void QtStyleManager::RemoveStyles(const QString& repo)
{
if (repo.isEmpty())
{
ClearStyles();
return;
}
for (FileNameToStyleMap::iterator i = styles.begin(); i != styles.end();)
{
ExtStyle* style = i.value();
QFileInfo info(style->fileName);
if (info.absolutePath() == repo)
{
if (style->name == currentStyle->name)
{
SetDefaultStyle();
}
i = styles.erase(i);
delete style;
}
else
{
++i;
}
}
}
void QtStyleManager::GetStyles(StyleList& styleNames) const
{
for (FileNameToStyleMap::const_iterator i = styles.begin(); i != styles.end(); ++i)
styleNames.push_back(Style(i.value()->name, i.value()->fileName));
}
void QtStyleManager::SetStyle(const QString& fileName)
{
if (fileName.isEmpty())
{
SetDefaultStyle();
return;
}
FileNameToStyleMap::const_iterator i = styles.find(fileName);
ExtStyle* style = nullptr;
if (i == styles.end())
{
BERRY_WARN << "Style " + fileName.toStdString() << " does not exist";
style = defaultStyle;
}
else
{
style = i.value();
}
currentStyle = style;
ReadStyleData(style);
qApp->setStyleSheet(currentStyle->stylesheet);
try
{
PlatformUI::GetWorkbench()->UpdateTheme();
}
catch (...)
{
// Swallow any exception if the Workbench instance has not been created yet.
// Will be called later again but for now we just want to make sure that the
// application style sheet can be at least already retrieved from qApp to
// theme icons in plugins with eager activation policy.
}
}
void QtStyleManager::SetFont(const QString& fontName)
{
m_currentFont = fontName;
}
void QtStyleManager::SetFontSize(const int fontSize)
{
m_currentFontSize = fontSize;
}
void QtStyleManager::UpdateWorkbenchFont()
{
if( m_currentFont == QString( "<<system>>" ) || m_currentFont == QString( "" ))
{
qApp->setFont(QFontDatabase::systemFont(QFontDatabase::GeneralFont));
}
else
{
QFont font;
font.setFamily(m_currentFont);
font.setPointSize(m_currentFontSize);
qApp->setFont(font);
}
qApp->setStyleSheet(currentStyle->stylesheet);
PlatformUI::GetWorkbench()->UpdateTheme();
}
QtStyleManager::Style QtStyleManager::GetDefaultStyle() const
{
return Style(defaultStyle->name, defaultStyle->fileName);
}
void QtStyleManager::SetDefaultStyle()
{
SetStyle(defaultStyle->fileName);
}
bool QtStyleManager::Contains(const QString& fileName) const
{
return styles.contains(fileName);
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistryReader.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistryReader.cpp
index 4e09f525dc..47ecab1c48 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistryReader.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryEditorRegistryReader.cpp
@@ -1,113 +1,113 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryEditorRegistryReader.h"
#include "berryEditorRegistry.h"
#include "berryEditorDescriptor.h"
#include "berryWorkbenchRegistryConstants.h"
#include "berryPlatformUI.h"
#include "berryPlatform.h"
#include <QStringList>
namespace berry
{
void EditorRegistryReader::AddEditors(EditorRegistry* registry)
{
this->editorRegistry = registry;
this->ReadRegistry(Platform::GetExtensionRegistry(),
PlatformUI::PLUGIN_ID(),
WorkbenchRegistryConstants::PL_EDITOR);
}
bool EditorRegistryReader::ReadElement(const IConfigurationElement::Pointer& element)
{
if (element->GetName() != WorkbenchRegistryConstants::TAG_EDITOR)
{
return false;
}
QString id = element->GetAttribute(WorkbenchRegistryConstants::ATT_ID);
if (id.isEmpty())
{
this->LogMissingAttribute(element, WorkbenchRegistryConstants::ATT_ID);
return true;
}
EditorDescriptor::Pointer editor(new EditorDescriptor(id, element));
QList<QString> extensionsVector;
QList<QString> filenamesVector;
QList<QString> contentTypeVector;
bool defaultEditor = false;
QString value = element->GetAttribute(WorkbenchRegistryConstants::ATT_NAME);
// Get editor name (required field).
if (value.isEmpty())
{
this->LogMissingAttribute(element, WorkbenchRegistryConstants::ATT_NAME);
return true;
}
// Get target extensions (optional field)
QString extensionsString = element->GetAttribute(WorkbenchRegistryConstants::ATT_EXTENSIONS);
if (!extensionsString.isEmpty())
{
- QStringList tokens = extensionsString.split(',', QString::SkipEmptyParts);
+ QStringList tokens = extensionsString.split(',', Qt::SkipEmptyParts);
foreach(QString token, tokens)
{
extensionsVector.push_back(token.trimmed());
}
}
QString filenamesString = element->GetAttribute(WorkbenchRegistryConstants::ATT_FILENAMES);
if (!filenamesString.isEmpty())
{
- QStringList tokens = filenamesString.split(',', QString::SkipEmptyParts);
+ QStringList tokens = filenamesString.split(',', Qt::SkipEmptyParts);
foreach(QString token, tokens)
{
filenamesVector.push_back(token.trimmed());
}
}
QList<IConfigurationElement::Pointer> bindings = element->GetChildren(
WorkbenchRegistryConstants::TAG_CONTENT_TYPE_BINDING);
for (int i = 0; i < bindings.size(); ++i)
{
QString contentTypeId = bindings[i]->GetAttribute(
WorkbenchRegistryConstants::ATT_CONTENT_TYPE_ID);
if (contentTypeId.isEmpty())
{
continue;
}
contentTypeVector.push_back(contentTypeId);
}
// Is this the default editor?
defaultEditor = element->GetAttribute(WorkbenchRegistryConstants::ATT_DEFAULT).compare("true", Qt::CaseInsensitive) == 0;
// Add the editor to the manager.
editorRegistry->AddEditorFromPlugin(editor, extensionsVector,
filenamesVector, contentTypeVector, defaultEditor);
return true;
}
void EditorRegistryReader::ReadElement(EditorRegistry* editorRegistry,
const IConfigurationElement::Pointer& element)
{
this->editorRegistry = editorRegistry;
this->ReadElement(element);
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveDescriptor.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveDescriptor.cpp
index 285624ee04..9f4518b24a 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveDescriptor.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveDescriptor.cpp
@@ -1,334 +1,334 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryPerspectiveDescriptor.h"
#include "berryWorkbenchRegistryConstants.h"
#include "berryWorkbenchPlugin.h"
#include "berryWorkbenchConstants.h"
#include "berryPerspectiveRegistry.h"
#include "berryStatus.h"
#include "berryIContributor.h"
#include <QIcon>
namespace berry
{
PerspectiveDescriptor::PerspectiveDescriptor(const QString& id,
const QString& label, PerspectiveDescriptor::Pointer originalDescriptor)
: singleton(false), fixed(false)
{
this->id = id;
this->label = label;
if (originalDescriptor != 0)
{
this->originalId = originalDescriptor->GetOriginalId();
this->imageDescriptor = originalDescriptor->imageDescriptor;
// This perspective is based on a perspective in some bundle -- if
// that
// bundle goes away then I think it makes sense to treat this
// perspective
// the same as any other -- so store it with the original
// descriptor's
// bundle's list.
//
// It might also make sense the other way...removing the following
// line
// will allow the perspective to stay around when the originating
// bundle
// is unloaded.
//
// This might also have an impact on upgrade cases -- should we
// really be
// destroying all user customized perspectives when the older
// version is
// removed?
//
// I'm leaving this here for now since its a good example, but
// wouldn't be
// surprised if we ultimately decide on the opposite.
//
// The reason this line is important is that this is the value used
// to
// put the object into the UI level registry. When that bundle goes
// away,
// the registry will remove the entire list of objects. So if this
// desc
// has been put into that list -- it will go away.
this->pluginId = originalDescriptor->GetPluginId();
}
}
PerspectiveDescriptor::PerspectiveDescriptor(const QString& id,
IConfigurationElement::Pointer configElement)
: singleton(false), fixed(false)
{
this->configElement = configElement;
this->id = id;
// Sanity check.
if ((this->GetId() == "") || (this->GetLabel() == "")
|| (this->GetFactoryClassName() == ""))
{
IStatus::Pointer status(new Status(
IStatus::ERROR_TYPE,
PlatformUI::PLUGIN_ID(),
nullptr,
QString("Invalid extension (missing label, id or class name): ") + GetId()));
throw CoreException(status);
}
}
IPerspectiveFactory::Pointer PerspectiveDescriptor::CreateFactory()
{
// if there is an originalId, then use that descriptor instead
if (originalId != "")
{
// Get the original descriptor to create the factory. If the
// original is gone then nothing can be done.
IPerspectiveDescriptor::Pointer
target =
dynamic_cast<PerspectiveRegistry*> (WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry()) ->FindPerspectiveWithId(
originalId);
return target == 0 ? IPerspectiveFactory::Pointer(nullptr) : target.Cast<
PerspectiveDescriptor> ()->CreateFactory();
}
// otherwise try to create the executable extension
if (configElement != 0)
{
try
{
IPerspectiveFactory::Pointer factory(
configElement ->CreateExecutableExtension<IPerspectiveFactory> (
WorkbenchRegistryConstants::ATT_CLASS));
return factory;
}
catch (const CoreException& /*e*/)
{
// do nothing
}
}
return IPerspectiveFactory::Pointer(nullptr);
}
void PerspectiveDescriptor::DeleteCustomDefinition()
{
dynamic_cast<PerspectiveRegistry*> (WorkbenchPlugin::GetDefault() ->GetPerspectiveRegistry())->DeleteCustomDefinition(
PerspectiveDescriptor::Pointer(this));
}
QString PerspectiveDescriptor::GetDescription() const
{
return configElement == 0 ? description : RegistryReader::GetDescription(
configElement);
}
void PerspectiveDescriptor::SetDescription(const QString& desc)
{
description = desc;
}
bool PerspectiveDescriptor::GetFixed() const
{
if (configElement == 0)
return fixed;
return configElement->GetAttribute(WorkbenchRegistryConstants::ATT_FIXED).compare("true", Qt::CaseInsensitive) == 0;
}
QStringList PerspectiveDescriptor::GetKeywordReferences() const
{
QStringList result;
if (configElement.IsNull())
{
return result;
}
auto keywordRefs = configElement->GetChildren("keywordReference");
for (auto keywordRefsIt = keywordRefs.begin();
keywordRefsIt != keywordRefs.end(); ++keywordRefsIt) // iterate over all refs
{
result.push_back((*keywordRefsIt)->GetAttribute("id"));
}
return result;
}
QString PerspectiveDescriptor::GetId() const
{
return id;
}
QString PerspectiveDescriptor::GetLocalId() const
{
return GetId();
}
QString PerspectiveDescriptor::GetPluginId() const
{
return configElement == 0 ? pluginId : configElement->GetContributor()->GetName();
}
QIcon PerspectiveDescriptor::GetImageDescriptor() const
{
if (!imageDescriptor.isNull())
return imageDescriptor;
if (configElement)
{
QString icon = configElement->GetAttribute(WorkbenchRegistryConstants::ATT_ICON);
if (!icon.isEmpty())
{
imageDescriptor = AbstractUICTKPlugin::ImageDescriptorFromPlugin(
configElement->GetContributor()->GetName(), icon);
}
}
if (imageDescriptor.isNull())
{
imageDescriptor = AbstractUICTKPlugin::GetMissingIcon();
}
return imageDescriptor;
}
QStringList PerspectiveDescriptor::GetCategoryPath() const
{
if(!categoryPath.empty()) return categoryPath;
if (configElement.IsNotNull())
{
QString category = configElement->GetAttribute(WorkbenchRegistryConstants::TAG_CATEGORY);
- categoryPath = category.split('/', QString::SkipEmptyParts);
+ categoryPath = category.split('/', Qt::SkipEmptyParts);
}
return categoryPath;
}
QString PerspectiveDescriptor::GetLabel() const
{
if (configElement == 0)
return label;
return configElement->GetAttribute(WorkbenchRegistryConstants::ATT_NAME);
}
QString PerspectiveDescriptor::GetOriginalId() const
{
if (originalId == "")
{
return this->GetId();
}
return originalId;
}
bool PerspectiveDescriptor::HasCustomDefinition() const
{
return dynamic_cast<PerspectiveRegistry*> (WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry())->HasCustomDefinition(
PerspectiveDescriptor::ConstPointer(this));
}
bool PerspectiveDescriptor::HasDefaultFlag() const
{
if (configElement == 0)
{
return false;
}
return configElement->GetAttribute(WorkbenchRegistryConstants::ATT_DEFAULT).compare("true", Qt::CaseInsensitive) == 0;
}
bool PerspectiveDescriptor::IsPredefined() const
{
return this->GetFactoryClassName() != "" && configElement != 0;
}
bool PerspectiveDescriptor::IsSingleton() const
{
if (configElement == 0)
return singleton;
return configElement->GetAttribute(WorkbenchRegistryConstants::ATT_SINGLETON).compare("true", Qt::CaseInsensitive) == 0;
}
bool PerspectiveDescriptor::RestoreState(IMemento::Pointer memento)
{
IMemento::Pointer childMem(memento->GetChild(
WorkbenchConstants::TAG_DESCRIPTOR));
if (childMem)
{
childMem->GetString(WorkbenchConstants::TAG_ID, id);
childMem->GetString(WorkbenchConstants::TAG_DESCRIPTOR, originalId);
childMem->GetString(WorkbenchConstants::TAG_LABEL, label);
childMem->GetString(WorkbenchConstants::TAG_CLASS, className);
int singletonVal;
singleton = childMem->GetInteger(WorkbenchConstants::TAG_SINGLETON,
singletonVal);
// Find a descriptor in the registry.
IPerspectiveDescriptor::Pointer
descriptor =
WorkbenchPlugin::GetDefault() ->GetPerspectiveRegistry()->FindPerspectiveWithId(
this->GetOriginalId());
if (descriptor)
{
// Copy the state from the registered descriptor.
imageDescriptor = descriptor->GetImageDescriptor();
}
}
//return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", null); //$NON-NLS-1$
return true;
}
void PerspectiveDescriptor::RevertToPredefined()
{
if (this->IsPredefined())
{
this->DeleteCustomDefinition();
}
}
bool PerspectiveDescriptor::SaveState(IMemento::Pointer memento)
{
IMemento::Pointer childMem(memento->CreateChild(
WorkbenchConstants::TAG_DESCRIPTOR));
childMem->PutString(WorkbenchConstants::TAG_ID, GetId());
if (!originalId.isEmpty())
{
childMem->PutString(WorkbenchConstants::TAG_DESCRIPTOR, originalId);
}
childMem->PutString(WorkbenchConstants::TAG_LABEL, GetLabel());
childMem->PutString(WorkbenchConstants::TAG_CLASS, GetFactoryClassName());
if (singleton)
{
childMem->PutInteger(WorkbenchConstants::TAG_SINGLETON, 1);
}
//return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, 0, "", null);
return true;
}
IConfigurationElement::Pointer PerspectiveDescriptor::GetConfigElement() const
{
return configElement;
}
QString PerspectiveDescriptor::GetFactoryClassName() const
{
return configElement == 0 ? className : RegistryReader::GetClassValue(
configElement, WorkbenchRegistryConstants::ATT_CLASS);
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveRegistry.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveRegistry.cpp
index 4d7f9003d4..fd0371a370 100755
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveRegistry.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryPerspectiveRegistry.cpp
@@ -1,624 +1,624 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryPerspectiveRegistry.h"
#include "berryWorkbench.h"
#include "berryWorkbenchPage.h"
#include "berryWorkbenchPlugin.h"
#include "berryPreferenceConstants.h"
#include "berryPerspective.h"
#include "berryPerspectiveRegistryReader.h"
#include "berryPlatformUI.h"
#include "handlers/berryClosePerspectiveHandler.h"
#include "berryIExtension.h"
#include "berryIExtensionTracker.h"
#include <mitkIPreferences.h>
namespace berry
{
const QString PerspectiveRegistry::EXT = "_persp.xml";
const QString PerspectiveRegistry::ID_DEF_PERSP = "PerspectiveRegistry.DEFAULT_PERSP";
const QString PerspectiveRegistry::PERSP = "_persp";
const char PerspectiveRegistry::SPACE_DELIMITER = ' ';
class PerspectiveRegistry::PreferenceChangeListener
{
PerspectiveRegistry* m_Registry;
public:
PreferenceChangeListener(PerspectiveRegistry* registry)
: m_Registry(registry)
{}
void PropertyChange(const mitk::IPreferences::ChangeEvent& event)
{
/*
* To ensure that no custom perspective definitions are
* deleted when preferences are imported, merge old and new
* values
*/
if (QString::fromStdString(event.GetProperty()).endsWith(PERSP))
{
/* A Perspective is being changed, merge */
this->MergePerspectives(event);
}
else if (event.GetProperty() == PreferenceConstants::PERSPECTIVES)
{
/* The list of perspectives is being changed, merge */
UpdatePreferenceList(event.GetSource());
}
}
void MergePerspectives(const mitk::IPreferences::ChangeEvent& event)
{
auto* store = event.GetSource();
if (event.GetNewValue().empty())
{
/*
* Perspective is being removed; if the user has deleted or
* reverted a custom perspective, let the change pass
* through. Otherwise, restore the custom perspective entry
*/
// Find the matching descriptor in the registry
QList<IPerspectiveDescriptor::Pointer> perspectiveList = m_Registry->GetPerspectives();
for (int i = 0; i < perspectiveList.size(); i++)
{
QString id = perspectiveList[i]->GetId();
const auto property = QString::fromStdString(event.GetProperty());
if (property == id + PERSP)
{ // found
// descriptor
// see if the perspective has been flagged for
// reverting or deleting
if (!m_Registry->perspToRemove.contains(id))
{ // restore
store->Put((id + PERSP).toStdString(), event.GetOldValue());
}
else
{ // remove element from the list
m_Registry->perspToRemove.removeAll(id);
}
}
}
}
else if (event.GetOldValue().empty())
{
/*
* New perspective is being added, update the
* perspectiveRegistry to contain the new custom perspective
*/
auto property = QString::fromStdString(event.GetProperty());
QString id = property.left(property.lastIndexOf(PERSP));
if (m_Registry->FindPerspectiveWithId(id).IsNull())
{
// perspective does not already exist in registry, add
// it
PerspectiveDescriptor::Pointer desc(new PerspectiveDescriptor(
QString::null, QString::null, PerspectiveDescriptor::Pointer()));
std::stringstream reader;
std::string xmlStr = event.GetNewValue();
reader.str(xmlStr);
try
{
XMLMemento::Pointer memento = XMLMemento::CreateReadRoot(reader);
desc->RestoreState(memento);
m_Registry->AddPerspective(desc);
}
catch (const WorkbenchException& e)
{
//m_Registry->UnableToLoadPerspective(e.getStatus());
m_Registry->UnableToLoadPerspective(e.what());
}
}
}
/* If necessary, add to the list of perspectives */
this->UpdatePreferenceList(store);
}
void UpdatePreferenceList(mitk::IPreferences* store)
{
QList<IPerspectiveDescriptor::Pointer> perspectiveList = m_Registry->GetPerspectives();
QStringList perspBuffer;
for (int i = 0; i < perspectiveList.size(); i++)
{
PerspectiveDescriptor::Pointer desc = perspectiveList[i].Cast<PerspectiveDescriptor>();
if (m_Registry->HasCustomDefinition(desc))
{
perspBuffer.push_back(desc->GetId());
}
}
store->Put(PreferenceConstants::PERSPECTIVES, perspBuffer.join(QString(SPACE_DELIMITER)).toStdString());
}
};
PerspectiveRegistry::PerspectiveRegistry()
: preferenceListener(new PreferenceChangeListener(this))
{
IExtensionTracker* tracker = PlatformUI::GetWorkbench()->GetExtensionTracker();
tracker->RegisterHandler(this, QString("org.blueberry.ui.perspectives"));
mitk::IPreferences* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
prefs->OnPropertyChanged +=
mitk::MessageDelegate1<PreferenceChangeListener, const mitk::IPreferences::ChangeEvent&>(
preferenceListener.data(), &PreferenceChangeListener::PropertyChange);
}
void PerspectiveRegistry::AddPerspective(PerspectiveDescriptor::Pointer desc)
{
if (desc == 0)
{
return;
}
this->Add(desc);
}
void PerspectiveRegistry::RevertPerspectives(
const QList<PerspectiveDescriptor::Pointer>& perspToRevert)
{
// indicate that the user is removing these perspectives
for (QList<PerspectiveDescriptor::Pointer>::const_iterator iter = perspToRevert.begin();
iter != perspToRevert.end(); ++iter)
{
PerspectiveDescriptor::Pointer desc = *iter;
perspToRemove.push_back(desc->GetId());
desc->RevertToPredefined();
}
}
void PerspectiveRegistry::DeletePerspectives(
const QList<PerspectiveDescriptor::Pointer>& perspToDelete)
{
for (QList<PerspectiveDescriptor::Pointer>::const_iterator iter = perspToDelete.begin();
iter != perspToDelete.end(); ++iter)
{
this->DeletePerspective(*iter);
}
}
void PerspectiveRegistry::DeletePerspective(IPerspectiveDescriptor::Pointer in)
{
PerspectiveDescriptor::Pointer desc = in.Cast<PerspectiveDescriptor>();
// Don't delete predefined perspectives
if (!desc->IsPredefined())
{
perspToRemove.push_back(desc->GetId());
perspectives.removeAll(desc);
desc->DeleteCustomDefinition();
this->VerifyDefaultPerspective();
}
}
void PerspectiveRegistry::Load()
{
// Load the registries.
this->LoadPredefined();
this->LoadCustom();
// Get default perspective.
// Get it from the R1.0 dialog settings first. Fixes bug 17039
// IDialogSettings dialogSettings =
// WorkbenchPlugin.getDefault() .getDialogSettings();
// QString str = dialogSettings.get(ID_DEF_PERSP);
// if (str != null && str.length() > 0)
// {
// this->SetDefaultPerspective(str);
// dialogSettings.put(ID_DEF_PERSP, ""); //$NON-NLS-1$
// }
this->VerifyDefaultPerspective();
}
void PerspectiveRegistry::SaveCustomPersp(PerspectiveDescriptor::Pointer desc,
XMLMemento* memento)
{
auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
// Save it to the preference store.
std::stringstream ss;
memento->Save(ss);
prefs->Put((desc->GetId() + PERSP).toStdString(), ss.str());
}
IMemento::Pointer PerspectiveRegistry::GetCustomPersp(const QString& id)
{
std::stringstream ss;
auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
const auto xmlString = prefs->Get((id + PERSP).toStdString(), "");
if (!xmlString.empty())
{ // defined in store
ss.str(xmlString);
}
XMLMemento::Pointer memento = XMLMemento::CreateReadRoot(ss);
return memento;
}
bool PerspectiveRegistry::ValidateLabel(const QString& label)
{
return !label.trimmed().isEmpty();
}
IPerspectiveDescriptor::Pointer PerspectiveRegistry::FindPerspectiveWithId(const QString& id)
{
for (QList<PerspectiveDescriptor::Pointer>::iterator iter = perspectives.begin();
iter != perspectives.end(); ++iter)
{
PerspectiveDescriptor::Pointer desc = *iter;
if (desc->GetId() == id)
{
// if (WorkbenchActivityHelper.restrictUseOf(desc))
// {
// return null;
// }
return desc;
}
}
return IPerspectiveDescriptor::Pointer(nullptr);
}
IPerspectiveDescriptor::Pointer PerspectiveRegistry::FindPerspectiveWithLabel(
const QString& label)
{
for (QList<PerspectiveDescriptor::Pointer>::iterator iter = perspectives.begin();
iter != perspectives.end(); ++iter)
{
PerspectiveDescriptor::Pointer desc = *iter;
if (desc->GetLabel() == label)
{
// if (WorkbenchActivityHelper.restrictUseOf(desc))
// {
// return 0;
// }
return desc;
}
}
return IPerspectiveDescriptor::Pointer(nullptr);
}
QString PerspectiveRegistry::GetDefaultPerspective()
{
return defaultPerspID;
}
QList<IPerspectiveDescriptor::Pointer> PerspectiveRegistry::GetPerspectives()
{
// Collection descs = WorkbenchActivityHelper.restrictCollection(perspectives,
// new ArrayList());
// return (IPerspectiveDescriptor[]) descs.toArray(
// new IPerspectiveDescriptor[descs.size()]);
QList<IPerspectiveDescriptor::Pointer> result;
for (QList<PerspectiveDescriptor::Pointer>::iterator iter = perspectives.begin();
iter != perspectives.end(); ++iter)
{
result.push_back(iter->Cast<IPerspectiveDescriptor>());
}
return result;
}
void PerspectiveRegistry::SetDefaultPerspective(const QString& id)
{
IPerspectiveDescriptor::Pointer desc = this->FindPerspectiveWithId(id);
if (desc != 0)
{
defaultPerspID = id;
//TODO Preferences
// PrefUtil.getAPIPreferenceStore().setValue(
// IWorkbenchPreferenceConstants.DEFAULT_PERSPECTIVE_ID, id);
}
}
IPerspectiveDescriptor::Pointer PerspectiveRegistry::CreatePerspective(const QString& label,
IPerspectiveDescriptor::Pointer originalDescriptor)
{
// Sanity check to avoid invalid or duplicate labels.
if (!this->ValidateLabel(label))
{
return IPerspectiveDescriptor::Pointer(nullptr);
}
if (this->FindPerspectiveWithLabel(label) != 0)
{
return IPerspectiveDescriptor::Pointer(nullptr);
}
// Calculate ID.
QString id(label);
id = id.replace(' ', '_').trimmed();
// Create descriptor.
PerspectiveDescriptor::Pointer desc(
new PerspectiveDescriptor(id, label, originalDescriptor.Cast<PerspectiveDescriptor>()));
this->Add(desc);
return IPerspectiveDescriptor::Pointer(static_cast<IPerspectiveDescriptor*>(desc.GetPointer()));
}
IPerspectiveDescriptor::Pointer PerspectiveRegistry::ClonePerspective(const QString& id,
const QString& label,
IPerspectiveDescriptor::Pointer originalDescriptor)
{
// Check for invalid labels
if (label == "" || label.trimmed().isEmpty())
{
throw Poco::InvalidArgumentException();
}
// Check for duplicates
IPerspectiveDescriptor::Pointer desc = this->FindPerspectiveWithId(id);
if (desc != 0)
{
throw Poco::InvalidArgumentException();
}
// Create descriptor.
desc
= new PerspectiveDescriptor(id, label, originalDescriptor.Cast<PerspectiveDescriptor>());
this->Add(desc.Cast<PerspectiveDescriptor>());
return desc;
}
void PerspectiveRegistry::RevertPerspective(IPerspectiveDescriptor::Pointer perspToRevert)
{
PerspectiveDescriptor::Pointer desc = perspToRevert.Cast<PerspectiveDescriptor>();
perspToRemove.push_back(desc->GetId());
desc->RevertToPredefined();
}
PerspectiveRegistry::~PerspectiveRegistry()
{
// PlatformUI::GetWorkbench()->GetExtensionTracker()->UnregisterHandler(this);
// WorkbenchPlugin::GetDefault()->GetPreferences()->RemovePropertyChangeListener(preferenceListener);
}
void PerspectiveRegistry::DeleteCustomDefinition(PerspectiveDescriptor::Pointer desc)
{
// remove the entry from the preference store.
auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
prefs->Remove((desc->GetId() + PERSP).toStdString());
}
bool PerspectiveRegistry::HasCustomDefinition(PerspectiveDescriptor::ConstPointer desc) const
{
auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
const auto keys = prefs->Keys();
return std::find(keys.begin(), keys.end(), (desc->GetId() + PERSP).toStdString()) != keys.end();
}
void PerspectiveRegistry::Add(PerspectiveDescriptor::Pointer desc)
{
perspectives.push_back(desc);
IConfigurationElement::Pointer element = desc->GetConfigElement();
if (element.IsNotNull())
{
PlatformUI::GetWorkbench()->GetExtensionTracker()->RegisterObject(
element->GetDeclaringExtension(), desc, IExtensionTracker::REF_WEAK);
}
}
void PerspectiveRegistry::InternalDeletePerspective(PerspectiveDescriptor::Pointer desc)
{
perspToRemove.push_back(desc->GetId());
perspectives.removeAll(desc);
desc->DeleteCustomDefinition();
this->VerifyDefaultPerspective();
}
void PerspectiveRegistry::LoadCustom()
{
QScopedPointer<std::istream> reader;
/* Get the entries from the Preference store */
auto* prefs = WorkbenchPlugin::GetDefault()->GetPreferences();
/* Get the space-delimited list of custom perspective ids */
QString customPerspectives = QString::fromStdString(prefs->Get(PreferenceConstants::PERSPECTIVES, ""));
- QStringList perspectivesList = customPerspectives.split(' ', QString::SkipEmptyParts);
+ QStringList perspectivesList = customPerspectives.split(' ', Qt::SkipEmptyParts);
for (int i = 0; i < perspectivesList.size(); i++)
{
try
{
const auto xmlString = prefs->Get((perspectivesList[i] + PERSP).toStdString(), "");
if (!xmlString.empty())
{
reader.reset(new std::stringstream(xmlString));
//reader->exceptions(std::ios_base::failbit);
}
else
{
throw WorkbenchException(QString("Description of '%1' perspective could not be found.").arg(perspectivesList[i]));
}
// Restore the layout state.
XMLMemento::Pointer memento = XMLMemento::CreateReadRoot(*reader);
PerspectiveDescriptor::Pointer newPersp(new PerspectiveDescriptor(
QString::null, QString::null,
PerspectiveDescriptor::Pointer(nullptr)));
newPersp->RestoreState(memento);
QString id = newPersp->GetId();
IPerspectiveDescriptor::Pointer oldPersp = FindPerspectiveWithId(id);
if (oldPersp.IsNull())
{
Add(newPersp);
}
}
catch (const std::ios_base::failure&)
{
UnableToLoadPerspective(QString::null);
}
catch (const WorkbenchException& e)
{
UnableToLoadPerspective(e.message());
}
}
// // Get the entries from files, if any
// // if -data @noDefault specified the state location may not be
// // initialized
// IPath path = WorkbenchPlugin.getDefault().getDataLocation();
// if (path == null)
// {
// return;
// }
// File folder = path.toFile();
// if (folder.isDirectory())
// {
// File[] fileList = folder.listFiles();
// int nSize = fileList.length;
// for (int nX = 0; nX < nSize; nX++)
// {
// File file = fileList[nX];
// if (file.getName().endsWith(EXT))
// {
// // get the memento
// InputStream stream = null;
// try
// {
// stream = new FileInputStream(file);
// reader = new BufferedReader(new InputStreamReader(stream, "utf-8")); //$NON-NLS-1$
// // Restore the layout state.
// XMLMemento memento = XMLMemento.createReadRoot(reader);
// PerspectiveDescriptor newPersp =
// new PerspectiveDescriptor(null, null, null);
// newPersp.restoreState(memento);
// IPerspectiveDescriptor oldPersp = findPerspectiveWithId(
// newPersp .getId());
// if (oldPersp == null)
// {
// add(newPersp);
// }
// // save to the preference store
// saveCustomPersp(newPersp, memento);
// // delete the file
// file.delete();
// reader.close();
// stream.close();
// } catch (IOException e)
// {
// unableToLoadPerspective(null);
// } catch (WorkbenchException e)
// {
// unableToLoadPerspective(e.getStatus());
// }
// }
// }
// }
}
void PerspectiveRegistry::UnableToLoadPerspective(const QString& status)
{
QString msg = "Unable to load perspective";
if (status == "")
{
WorkbenchPlugin::Log(msg);
//IStatus errStatus =
// new Status(IStatus.ERR, WorkbenchPlugin.PI_WORKBENCH, msg);
//StatusManager.getManager().handle(errStatus, StatusManager.SHOW);
}
else
{
WorkbenchPlugin::Log(status + ": " + msg);
//IStatus errStatus = StatusUtil.newStatus(status, msg);
//StatusManager.getManager().handle(errStatus, StatusManager.SHOW);
}
}
void PerspectiveRegistry::LoadPredefined()
{
PerspectiveRegistryReader reader(this);
reader.ReadPerspectives(Platform::GetExtensionRegistry());
}
void PerspectiveRegistry::VerifyDefaultPerspective()
{
// Step 1: Try current defPerspId value.
IPerspectiveDescriptor::Pointer desc;
if (defaultPerspID != "")
{
desc = this->FindPerspectiveWithId(defaultPerspID);
}
if (desc != 0)
{
return;
}
// Step 2. Read default value.
//TODO Preferences
// QString str = PrefUtil.getAPIPreferenceStore().getString(
// IWorkbenchPreferenceConstants.DEFAULT_PERSPECTIVE_ID);
// if (str != null && str.length() > 0)
// {
// desc = this->FindPerspectiveWithId(str);
// }
// if (desc != 0)
// {
// defaultPerspID = str;
// return;
// }
// Step 3. Use application-specific default
defaultPerspID = Workbench::GetInstance()->GetDefaultPerspectiveId();
}
void PerspectiveRegistry::RemoveExtension(const IExtension::Pointer& /*source*/,
const QList<Object::Pointer>& objects)
{
for (int i = 0; i < objects.size(); i++)
{
if (PerspectiveDescriptor::Pointer desc = objects[i].Cast<PerspectiveDescriptor>())
{
// close the perspective in all windows
QList<IWorkbenchWindow::Pointer> windows = PlatformUI::GetWorkbench()->GetWorkbenchWindows();
for (int w = 0; w < windows.size(); ++w)
{
IWorkbenchWindow::Pointer window = windows[w];
QList<IWorkbenchPage::Pointer> pages = window->GetPages();
for (int p = 0; p < pages.size(); ++p)
{
WorkbenchPage::Pointer page = pages[p].Cast<WorkbenchPage>();
ClosePerspectiveHandler::ClosePerspective(page, page->FindPerspective(desc));
}
}
// ((Workbench)PlatformUI.getWorkbench()).getPerspectiveHistory().removeItem(desc);
this->InternalDeletePerspective(desc);
}
}
}
void PerspectiveRegistry::AddExtension(IExtensionTracker* /*tracker*/,
const IExtension::Pointer& addedExtension)
{
QList<IConfigurationElement::Pointer> addedElements = addedExtension->GetConfigurationElements();
for (int i = 0; i < addedElements.size(); i++)
{
PerspectiveRegistryReader reader(this);
reader.ReadElement(addedElements[i]);
}
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryQtStylePreferencePage.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryQtStylePreferencePage.cpp
index 489840defb..281326281c 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryQtStylePreferencePage.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryQtStylePreferencePage.cpp
@@ -1,272 +1,272 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryQtStylePreferencePage.h"
#include "berryWorkbenchPlugin.h"
#include <berryQtPreferences.h>
#include <QFileDialog>
#include <QDirIterator>
#include <QFontDatabase>
#include <mitkIPreferences.h>
namespace
{
mitk::IPreferences* GetPreferences()
{
return berry::WorkbenchPlugin::GetDefault()->GetPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
}
}
namespace berry
{
QtStylePreferencePage::QtStylePreferencePage()
{
}
void QtStylePreferencePage::Init(IWorkbench::Pointer )
{
}
void QtStylePreferencePage::CreateQtControl(QWidget* parent)
{
mainWidget = new QWidget(parent);
controls.setupUi(mainWidget);
ctkPluginContext* context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
if (styleManagerRef)
{
styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
}
Update();
connect(controls.m_StylesCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(StyleChanged(int)));
connect(controls.m_FontComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(FontChanged(int)));
connect(controls.m_FontSizeSpinBox, SIGNAL(valueChanged(int)), this, SLOT(FontChanged(int)));
connect(controls.m_PathList, SIGNAL(itemSelectionChanged()), this, SLOT(UpdatePathListButtons()));
connect(controls.m_AddButton, SIGNAL(clicked(bool)), this, SLOT(AddPathClicked(bool)));
connect(controls.m_EditButton, SIGNAL(clicked(bool)), this, SLOT(EditPathClicked(bool)));
connect(controls.m_RemoveButton, SIGNAL(clicked(bool)), this, SLOT(RemovePathClicked(bool)));
}
void QtStylePreferencePage::FillStyleCombo(const berry::IQtStyleManager::Style& currentStyle)
{
controls.m_StylesCombo->clear();
styles.clear();
styleManager->GetStyles(styles);
qSort(styles);
for (int i = 0; i < styles.size(); ++i)
{
controls.m_StylesCombo->addItem(styles.at(i).name, QVariant(styles.at(i).fileName));
}
controls.m_StylesCombo->setCurrentIndex(styles.indexOf(currentStyle));
}
void QtStylePreferencePage::FillFontCombo(const QString& currentFont)
{
controls.m_FontComboBox->clear();
QStringList fonts;
styleManager->GetFonts(fonts);
for (int i = 0; i < fonts.size(); ++i)
{
controls.m_FontComboBox->addItem(fonts.at(i));
}
controls.m_FontComboBox->setCurrentIndex(fonts.indexOf(currentFont));
if (currentFont == QString("<<system>>"))
{
controls.m_FontSizeSpinBox->setEnabled(false);
}
else
{
controls.m_FontSizeSpinBox->setEnabled(true);
}
}
void QtStylePreferencePage::AddPath(const QString& path, bool updateCombo)
{
if (!controls.m_PathList->findItems(path, Qt::MatchCaseSensitive).isEmpty()) return;
new QListWidgetItem(path, controls.m_PathList);
styleManager->AddStyles(path);
if (updateCombo)
FillStyleCombo(oldStyle);
}
void QtStylePreferencePage::StyleChanged(int /*index*/)
{
QString fileName = controls.m_StylesCombo->itemData(controls.m_StylesCombo->currentIndex()).toString();
styleManager->SetStyle(fileName);
}
void QtStylePreferencePage::FontChanged(int /*index*/)
{
QString fontName = controls.m_FontComboBox->currentText();
int fontSize = controls.m_FontSizeSpinBox->value();
if (fontName == QString("<<system>>"))
{
controls.m_FontSizeSpinBox->setEnabled(false);
}
else
{
controls.m_FontSizeSpinBox->setEnabled(true);
}
styleManager->SetFont(fontName);
styleManager->SetFontSize(fontSize);
styleManager->UpdateWorkbenchFont();
}
void QtStylePreferencePage::AddPathClicked(bool /*checked*/)
{
QListWidgetItem* item = controls.m_PathList->currentItem();
QString initialDir;
if (item) initialDir = item->text();
QString dir = QFileDialog::getExistingDirectory(mainWidget, "", initialDir);
if (!dir.isEmpty()) this->AddPath(dir, true);
}
void QtStylePreferencePage::RemovePathClicked(bool /*checked*/)
{
QList<QListWidgetItem*> selection = controls.m_PathList->selectedItems();
QListIterator<QListWidgetItem*> it(selection);
while (it.hasNext())
{
QListWidgetItem* item = it.next();
QString dir = item->text();
controls.m_PathList->takeItem(controls.m_PathList->row(item));
delete item;
styleManager->RemoveStyles(dir);
}
if (!styleManager->Contains(oldStyle.fileName))
{
oldStyle = styleManager->GetDefaultStyle();
}
FillStyleCombo(oldStyle);
}
void QtStylePreferencePage::EditPathClicked(bool checked)
{
QListWidgetItem* item = controls.m_PathList->currentItem();
QString initialDir = item->text();
QString dir = QFileDialog::getExistingDirectory(mainWidget, "", initialDir);
if (!dir.isEmpty())
{
this->RemovePathClicked(checked);
this->AddPath(dir, true);
}
}
void QtStylePreferencePage::UpdatePathListButtons()
{
int s = controls.m_PathList->selectedItems().size();
if (s == 0)
{
controls.m_EditButton->setEnabled(false);
controls.m_RemoveButton->setEnabled(false);
}
else if (s == 1)
{
controls.m_EditButton->setEnabled(true);
controls.m_RemoveButton->setEnabled(true);
}
else
{
controls.m_EditButton->setEnabled(false);
controls.m_RemoveButton->setEnabled(true);
}
}
QWidget* QtStylePreferencePage::GetQtControl() const
{
return mainWidget;
}
bool QtStylePreferencePage::PerformOk()
{
auto* prefs = GetPreferences();
prefs->Put(berry::QtPreferences::QT_STYLE_NAME, controls.m_StylesCombo->itemData(controls.m_StylesCombo->currentIndex()).toString().toStdString());
QString paths;
for (int i = 0; i < controls.m_PathList->count(); ++i)
{
QString path = controls.m_PathList->item(i)->text() + ";";
paths += path;
}
prefs->Put(berry::QtPreferences::QT_STYLE_SEARCHPATHS, paths.toStdString());
prefs->Put(berry::QtPreferences::QT_FONT_NAME, controls.m_FontComboBox->currentText().toStdString());
prefs->Put(berry::QtPreferences::QT_FONT_SIZE, std::to_string(controls.m_FontSizeSpinBox->value()));
prefs->PutBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES,
controls.m_ToolbarCategoryCheckBox->isChecked());
return true;
}
void QtStylePreferencePage::PerformCancel()
{
Update();
}
void QtStylePreferencePage::Update()
{
styleManager->RemoveStyles();
auto* prefs = GetPreferences();
auto paths = QString::fromStdString(prefs->Get(berry::QtPreferences::QT_STYLE_SEARCHPATHS, ""));
- QStringList pathList = paths.split(";", QString::SkipEmptyParts);
+ QStringList pathList = paths.split(";", Qt::SkipEmptyParts);
QStringListIterator it(pathList);
while (it.hasNext())
{
AddPath(it.next(), false);
}
auto styleName = QString::fromStdString(prefs->Get(berry::QtPreferences::QT_STYLE_NAME, ""));
styleManager->SetStyle(styleName);
oldStyle = styleManager->GetStyle();
FillStyleCombo(oldStyle);
auto fontName = QString::fromStdString(prefs->Get(berry::QtPreferences::QT_FONT_NAME, "Open Sans"));
styleManager->SetFont(fontName);
auto fontSize = std::stoi(prefs->Get(berry::QtPreferences::QT_FONT_SIZE, "9"));
styleManager->SetFontSize(fontSize);
controls.m_FontSizeSpinBox->setValue(fontSize);
styleManager->UpdateWorkbenchFont();
FillFontCombo(styleManager->GetFont());
controls.m_ToolbarCategoryCheckBox->setChecked(
prefs->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true));
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
index 38bd69cefb..ed9001b401 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryReopenEditorMenu.cpp
@@ -1,300 +1,300 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryReopenEditorMenu.h"
#include <berryIWorkbench.h>
#include <berryIWorkbenchPage.h>
#include <berryMenuManager.h>
#include <berrySafeRunner.h>
#include "berryEditorHistory.h"
#include "berryEditorHistoryItem.h"
#include "berryWorkbench.h"
#include "berryWorkbenchPlugin.h"
#include "berryPreferenceConstants.h"
#include <QAction>
#include <QMenu>
#include <QMessageBox>
#include <mitkIPreferences.h>
namespace berry {
ReopenEditorMenu::ReopenEditorMenu(IWorkbenchWindow* window, const QString& id, bool showSeparator)
: ContributionItem(id)
, window(window)
, history(nullptr)
, showSeparator(showSeparator)
, dirty(true)
{
IWorkbench* workbench = window->GetWorkbench();
if (Workbench* w = dynamic_cast<Workbench*>(workbench))
{
history = w->GetEditorHistory();
}
}
QString ReopenEditorMenu::CalcText(int index, const QString& name, const QString& toolTip, bool rtl)
{
QString sb;
int mnemonic = index + 1;
QString nm = QString::number(mnemonic);
if (mnemonic <= MAX_MNEMONIC_SIZE)
{
nm.prepend('&');
}
QString fileName = name;
QString pathName = toolTip;
if (pathName == fileName)
{
// tool tip text isn't necessarily a path;
// sometimes it's the same as name, so it shouldn't be treated as a path then
pathName.clear();
}
QFileInfo path(pathName);
// if last segment in path is the fileName, remove it
if (path.fileName() == fileName)
{
path.setFile(path.path());
pathName = path.absoluteFilePath();
}
if ((fileName.size() + pathName.size()) <= (MAX_TEXT_LENGTH - 4))
{
// entire item name fits within maximum length
sb += fileName;
if (!pathName.isEmpty())
{
sb += " [" + pathName + "]";
}
}
else
{
// need to shorten the item name
int length = fileName.size();
if (length > MAX_TEXT_LENGTH)
{
// file name does not fit within length, truncate it
sb += fileName.leftRef(MAX_TEXT_LENGTH - 3);
sb += "...";
}
else if (length > MAX_TEXT_LENGTH - 7)
{
sb += fileName;
}
else
{
sb += fileName;
- QStringList pathSegments = path.absoluteFilePath().split('/', QString::SkipEmptyParts);
+ QStringList pathSegments = path.absoluteFilePath().split('/', Qt::SkipEmptyParts);
int segmentCount = pathSegments.size();
if (segmentCount > 0)
{
length += 7; // 7 chars are taken for " [...]"
sb += " [";
// Add first n segments that fit
int i = 0;
while (i < segmentCount && length < MAX_TEXT_LENGTH)
{
const QString& segment = pathSegments[i];
if (length + segment.size() < MAX_TEXT_LENGTH)
{
sb += segment + QDir::separator();
length += segment.size() + 1;
i++;
}
else if (i == 0)
{
// append at least part of the first segment
sb += segment.leftRef(MAX_TEXT_LENGTH - length);
length = MAX_TEXT_LENGTH;
break;
}
else
{
break;
}
}
sb += "...";
i = segmentCount - 1;
// Add last n segments that fit
while (i > 0 && length < MAX_TEXT_LENGTH)
{
const QString& segment = pathSegments[i];
if (length + segment.size() < MAX_TEXT_LENGTH)
{
sb += QDir::separator();
sb += segment;
length += segment.size() + 1;
i--;
}
else
{
break;
}
}
sb.append("]");
}
}
}
QString process;
if (rtl)
{
process = sb + " " + nm;
}
else
{
process = nm + " " + sb;
}
//return TextProcessor.process(process, TextProcessor.getDefaultDelimiters() + "[]");
return process;
}
void ReopenEditorMenu::Fill(QMenu* menu, QAction* before)
{
if (window->GetActivePage() == nullptr
|| window->GetActivePage()->GetPerspective().IsNull())
{
return;
}
if (MenuManager* mm = dynamic_cast<MenuManager*>(this->GetParent()))
{
mm->connect(mm, SIGNAL(AboutToShow(IMenuManager*)), this, SLOT(MenuAboutToShow(IMenuManager*)));
}
int itemsToShow = WorkbenchPlugin::GetDefault()->GetPreferences()->GetInt(PreferenceConstants::RECENT_FILES, 6);
if (itemsToShow == 0 || history == nullptr)
{
return;
}
// Get items.
QList<EditorHistoryItem::Pointer> historyItems = history->GetItems();
int n = std::min(itemsToShow, historyItems.size());
if (n <= 0)
{
return;
}
if (showSeparator)
{
menu->addSeparator();
}
struct _SafeRunnable : public ISafeRunnable
{
QMenu* menu;
QAction* before;
EditorHistoryItem::Pointer item;
const int historyIndex;
_SafeRunnable(QMenu* menu, QAction* before, EditorHistoryItem::Pointer item, int index)
: menu(menu), before(before), item(item), historyIndex(index) {}
void Run() override
{
QString text = ReopenEditorMenu::CalcText(historyIndex, item);
auto mi = new QAction(text, nullptr);
menu->insertAction(before, mi);
mi->setData(QVariant::fromValue(item));
}
void HandleException(const ctkException& e) override
{
// just skip the item if there's an error,
// e.g. in the calculation of the shortened name
WorkbenchPlugin::Log(this->GetClassName(), "Fill", e);
}
};
for (int i = 0; i < n; i++)
{
EditorHistoryItem::Pointer item = historyItems[i];
ISafeRunnable::Pointer runnable(new _SafeRunnable(menu, before, item, i));
SafeRunner::Run(runnable);
}
dirty = false;
}
bool ReopenEditorMenu::IsDirty() const
{
return dirty;
}
bool ReopenEditorMenu::IsDynamic() const
{
return true;
}
void ReopenEditorMenu::Open(const EditorHistoryItem::Pointer& item)
{
IWorkbenchPage::Pointer page = window->GetActivePage();
if (page.IsNotNull())
{
try
{
QString itemName = item->GetName();
if (!item->IsRestored())
{
item->RestoreState();
}
IEditorInput::Pointer input = item->GetInput();
IEditorDescriptor::Pointer desc = item->GetDescriptor();
if (!input || !desc)
{
QString title = "Problems opening editor";
QString msg = QString("Unable to open %1.").arg(itemName);
QMessageBox::warning(window->GetShell()->GetControl(), title, msg);
history->Remove(item);
}
else
{
page->OpenEditor(input, desc->GetId());
}
}
catch (const PartInitException& e2)
{
QString title = "Problems opening editor";
QMessageBox::warning(window->GetShell()->GetControl(), title, e2.what());
history->Remove(item);
}
}
}
QString ReopenEditorMenu::CalcText(int index, const EditorHistoryItem::Pointer& item)
{
// IMPORTANT: avoid accessing the item's input since
// this can require activating plugins.
// Instead, ask the item for the info, which can
// consult its memento if it is not restored yet.
return CalcText(index, item->GetName(), item->GetToolTipText(), false);
// Window::GetDefaultOrientation() == SWT.RIGHT_TO_LEFT);
}
void ReopenEditorMenu::MenuAboutToShow(IMenuManager* manager)
{
manager->MarkDirty();
dirty = true;
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryViewDescriptor.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryViewDescriptor.cpp
index f0a5255a50..c50c98b456 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryViewDescriptor.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryViewDescriptor.cpp
@@ -1,206 +1,206 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryViewDescriptor.h"
#include "berryIConfigurationElement.h"
#include "berryCoreException.h"
#include "berryIExtension.h"
#include "berryIContributor.h"
#include "berryStatus.h"
#include "berryRegistryReader.h"
#include "berryWorkbenchRegistryConstants.h"
#include "berryAbstractUICTKPlugin.h"
#include "handlers/berryIHandlerActivation.h"
namespace berry
{
ViewDescriptor::ViewDescriptor(const IConfigurationElement::Pointer& e) :
configElement(e)
{
this->LoadFromExtension();
}
IViewPart::Pointer ViewDescriptor::CreateView()
{
IViewPart::Pointer part(configElement->CreateExecutableExtension<IViewPart> (
WorkbenchRegistryConstants::ATT_CLASS));
return part;
}
QStringList ViewDescriptor::GetCategoryPath() const
{
return categoryPath;
}
IConfigurationElement::Pointer ViewDescriptor::GetConfigurationElement() const
{
return configElement;
}
QString ViewDescriptor::GetDescription() const
{
return RegistryReader::GetDescription(configElement);
}
QString ViewDescriptor::GetId() const
{
return id;
}
bool ViewDescriptor::operator==(const Object* o) const
{
if (const IViewDescriptor* other = dynamic_cast<const IViewDescriptor*>(o))
return this->GetId() == other->GetId();
return false;
}
QIcon ViewDescriptor::GetImageDescriptor() const
{
if (!imageDescriptor.isNull())
{
return imageDescriptor;
}
QString iconName = configElement->GetAttribute(WorkbenchRegistryConstants::ATT_ICON);
// If the icon attribute was omitted, use the default one
if (iconName.isEmpty())
{
//TODO default image descriptor
//return PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_DEF_VIEW);
return AbstractUICTKPlugin::GetMissingIcon();
}
IExtension::Pointer extension(configElement->GetDeclaringExtension());
const QString extendingPluginId(extension->GetContributor()->GetName());
imageDescriptor = AbstractUICTKPlugin::ImageDescriptorFromPlugin(
extendingPluginId, iconName);
// If the icon attribute was invalid, use the error icon
if (imageDescriptor.isNull())
{
imageDescriptor = AbstractUICTKPlugin::GetMissingIcon();
}
return imageDescriptor;
}
QString ViewDescriptor::GetLabel() const
{
return configElement->GetAttribute(WorkbenchRegistryConstants::ATT_NAME);
}
QString ViewDescriptor::GetAccelerator() const
{
return configElement->GetAttribute(WorkbenchRegistryConstants::ATT_ACCELERATOR);
}
bool ViewDescriptor::GetAllowMultiple() const
{
return configElement->GetAttribute(WorkbenchRegistryConstants::ATT_ALLOW_MULTIPLE).compare("true", Qt::CaseInsensitive) == 0;
}
bool ViewDescriptor::IsRestorable() const
{
QString str = configElement->GetAttribute(WorkbenchRegistryConstants::ATT_RESTORABLE);
return str.isNull() ? true : str.compare("true", Qt::CaseInsensitive) == 0;
}
Object* ViewDescriptor::GetAdapter(const QString& adapter) const
{
if (adapter == qobject_interface_iid<IConfigurationElement*>())
{
return GetConfigurationElement().GetPointer();
}
return nullptr;
}
void
ViewDescriptor::ActivateHandler()
{
//TODO ViewDescriptor handler activation
// if (!handlerActivation)
// {
// IHandler::Pointer handler(new ShowViewHandler(this->GetId()));
// IHandlerService::Pointer handlerService(
// PlatformUI::GetWorkbench()->GetService(IHandlerService::GetManifestName()).Cast<IHandlerService>());
// handlerActivation = handlerService
// ->ActivateHandler(this->GetId(), handler);
// }
}
void
ViewDescriptor::DeactivateHandler()
{
//TODO ViewDescriptor handler deactivation
// if (handlerActivation)
// {
// IHandlerService::Pointer handlerService(
// PlatformUI::GetWorkbench()->GetService(IHandlerService::GetManifestName()).Cast<IHandlerService>());
// handlerService->DeactivateHandler(handlerActivation);
// handlerActivation = 0;
// }
}
QStringList ViewDescriptor::GetKeywordReferences() const
{
QStringList result;
auto keywordRefs = configElement->GetChildren("keywordReference");
for (auto keywordRefsIt = keywordRefs.begin();
keywordRefsIt != keywordRefs.end(); ++keywordRefsIt) // iterate over all refs
{
result.push_back((*keywordRefsIt)->GetAttribute("id"));
}
return result;
}
QString ViewDescriptor::GetPluginId() const
{
return configElement->GetContributor()->GetName();
}
QString ViewDescriptor::GetLocalId() const
{
return this->GetId();
}
void ViewDescriptor::LoadFromExtension()
{
id = configElement->GetAttribute(WorkbenchRegistryConstants::ATT_ID);
// Sanity check.
QString name = configElement->GetAttribute(WorkbenchRegistryConstants::ATT_NAME);
if (name.isEmpty() ||
RegistryReader::GetClassValue(configElement, WorkbenchRegistryConstants::ATT_CLASS).isEmpty())
{
IStatus::Pointer status(new Status(IStatus::ERROR_TYPE, configElement->GetContributor()->GetName(), nullptr,
QString("Invalid extension (missing label or class name): ") + id));
throw CoreException(status);
}
QString category = configElement->GetAttribute(WorkbenchRegistryConstants::TAG_CATEGORY);
if (!category.isEmpty())
{
// Parse the path tokens and store them
- foreach (QString pathElement, category.split('/', QString::SkipEmptyParts))
+ foreach (QString pathElement, category.split('/', Qt::SkipEmptyParts))
{
if (!pathElement.trimmed().isEmpty())
{
categoryPath.push_back(pathElement.trimmed());
}
}
}
}
} // namespace berry
diff --git a/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp b/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp
index 76a1a1f3ef..aa35cdf59a 100644
--- a/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/internal/berryWorkbenchPage.cpp
@@ -1,4100 +1,4100 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryLog.h"
#include "tweaklets/berryGuiWidgetsTweaklet.h"
#include "tweaklets/berryWorkbenchPageTweaklet.h"
#include "berryWorkbenchPage.h"
#include "berryPartSite.h"
#include "berryWorkbenchRegistryConstants.h"
#include "berryPerspective.h"
#include "berryLayoutPartSash.h"
#include "berryWorkbenchPlugin.h"
#include "berryEditorAreaHelper.h"
#include "berrySaveablesList.h"
#include "berryPerspectiveHelper.h"
#include "berryLayoutTreeNode.h"
#include "berryWorkbench.h"
#include "berryWorkbenchConstants.h"
#include "berryPartService.h"
#include "berryStickyViewManager.h"
#include "berryUIExtensionTracker.h"
#include "intro/berryIntroConstants.h"
#include "intro/berryViewIntroAdapterPart.h"
#include "berryWorkbenchWindow.h"
#include "berryUIException.h"
#include "berryPlatformUI.h"
#include "berryPartPane.h"
#include <berryPlatform.h>
#include <QMessageBox>
namespace berry
{
WorkbenchPage::ActivationOrderPred::ActivationOrderPred(
WorkbenchPage::ActivationList* al) :
activationList(al)
{
}
bool WorkbenchPage::ActivationOrderPred::operator()(
const IViewReference::Pointer o1, const IViewReference::Pointer o2) const
{
auto pos1 = activationList->IndexOf(
o1.Cast<IWorkbenchPartReference> ());
auto pos2 = activationList->IndexOf(
o2.Cast<IWorkbenchPartReference> ());
return pos1 < pos2;
}
void WorkbenchPage::PerspectiveList::UpdateActionSets(
Perspective::Pointer /*oldPersp*/, Perspective::Pointer /*newPersp*/)
{
//TODO WorkbenchPage action sets
// // Update action sets
//
// IContextService service = (IContextService) window
// .getService(IContextService.class);
// try {
// service.activateContext(ContextAuthority.DEFER_EVENTS);
// if (newPersp != 0) {
// IActionSetDescriptor[] newAlwaysOn = newPersp
// .getAlwaysOnActionSets();
// for (int i = 0; i < newAlwaysOn.length; i++) {
// IActionSetDescriptor descriptor = newAlwaysOn[i];
//
// actionSets.showAction(descriptor);
// }
//
// IActionSetDescriptor[] newAlwaysOff = newPersp
// .getAlwaysOffActionSets();
// for (int i = 0; i < newAlwaysOff.length; i++) {
// IActionSetDescriptor descriptor = newAlwaysOff[i];
//
// actionSets.maskAction(descriptor);
// }
// }
//
// if (oldPersp != 0) {
// IActionSetDescriptor[] newAlwaysOn = oldPersp
// .getAlwaysOnActionSets();
// for (int i = 0; i < newAlwaysOn.length; i++) {
// IActionSetDescriptor descriptor = newAlwaysOn[i];
//
// actionSets.hideAction(descriptor);
// }
//
// IActionSetDescriptor[] newAlwaysOff = oldPersp
// .getAlwaysOffActionSets();
// for (int i = 0; i < newAlwaysOff.length; i++) {
// IActionSetDescriptor descriptor = newAlwaysOff[i];
//
// actionSets.unmaskAction(descriptor);
// }
// }
// } finally {
// service.activateContext(ContextAuthority.SEND_EVENTS);
// }
}
WorkbenchPage::PerspectiveList::PerspectiveList()
{
}
void WorkbenchPage::PerspectiveList::Reorder(
IPerspectiveDescriptor::Pointer perspective, int newLoc)
{
PerspectiveListType::iterator oldLocation = openedList.end();
Perspective::Pointer movedPerspective;
for (PerspectiveListType::iterator iterator = openedList.begin(); iterator
!= openedList.end(); ++iterator)
{
Perspective::Pointer openPerspective = *iterator;
if (openPerspective->GetDesc() == perspective)
{
oldLocation = std::find(openedList.begin(), openedList.end(),
openPerspective);
movedPerspective = openPerspective;
}
}
PerspectiveListType::iterator newLocation = openedList.begin();
for (int i = 0; i < newLoc; ++i, ++newLocation)
;
if (oldLocation == newLocation)
{
return;
}
openedList.erase(oldLocation);
openedList.insert(newLocation, movedPerspective);
}
WorkbenchPage::PerspectiveList::PerspectiveListType WorkbenchPage::PerspectiveList::GetSortedPerspectives()
{
return usedList;
}
bool WorkbenchPage::PerspectiveList::Add(Perspective::Pointer perspective)
{
openedList.push_back(perspective);
usedList.push_front(perspective);
//It will be moved to top only when activated.
return true;
}
WorkbenchPage::PerspectiveList::PerspectiveListType::iterator WorkbenchPage::PerspectiveList::Begin()
{
return openedList.begin();
}
WorkbenchPage::PerspectiveList::PerspectiveListType::iterator WorkbenchPage::PerspectiveList::End()
{
return openedList.end();
}
WorkbenchPage::PerspectiveList::PerspectiveListType WorkbenchPage::PerspectiveList::GetOpenedPerspectives()
{
return openedList;
}
bool WorkbenchPage::PerspectiveList::Remove(Perspective::Pointer perspective)
{
if (active == perspective)
{
this->UpdateActionSets(active, Perspective::Pointer(nullptr));
active = nullptr;
}
usedList.removeAll(perspective);
PerspectiveListType::size_type origSize = openedList.size();
openedList.removeAll(perspective);
return openedList.size() != origSize;
}
void WorkbenchPage::PerspectiveList::Swap(Perspective::Pointer oldPerspective,
Perspective::Pointer newPerspective)
{
PerspectiveListType::iterator oldIter = std::find(openedList.begin(),
openedList.end(), oldPerspective);
PerspectiveListType::iterator newIter = std::find(openedList.begin(),
openedList.end(), newPerspective);
if (oldIter == openedList.end() || newIter == openedList.end())
{
return;
}
std::iter_swap(oldIter, newIter);
}
bool WorkbenchPage::PerspectiveList::IsEmpty()
{
return openedList.empty();
}
Perspective::Pointer WorkbenchPage::PerspectiveList::GetActive()
{
return active;
}
Perspective::Pointer WorkbenchPage::PerspectiveList::GetNextActive()
{
if (active == 0)
{
if (usedList.empty())
{
return Perspective::Pointer(nullptr);
}
else
{
return usedList.back();
}
}
else
{
if (usedList.size() < 2)
{
return Perspective::Pointer(nullptr);
}
else
{
return *(usedList.end() - 2);
}
}
}
WorkbenchPage::PerspectiveList::PerspectiveListType::size_type WorkbenchPage::PerspectiveList::Size()
{
return openedList.size();
}
void WorkbenchPage::PerspectiveList::SetActive(Perspective::Pointer perspective)
{
if (perspective == active)
{
return;
}
this->UpdateActionSets(active, perspective);
active = perspective;
if (perspective != 0)
{
usedList.removeAll(perspective);
usedList.push_back(perspective);
}
}
WorkbenchPage::ActivationList::ActivationList(WorkbenchPage* page) :
page(page)
{
}
void WorkbenchPage::ActivationList::SetActive(SmartPointer<IWorkbenchPart> part)
{
if (parts.empty())
{
return;
}
IWorkbenchPartReference::Pointer ref(page->GetReference(part));
if (ref)
{
if (ref == parts.back())
{
return;
}
parts.erase(std::find(parts.begin(), parts.end(), ref));
parts.push_back(ref);
}
}
void WorkbenchPage::ActivationList::BringToTop(SmartPointer<
IWorkbenchPartReference> ref)
{
ILayoutContainer::Pointer targetContainer(page->GetContainer(ref));
auto newIndex = this->LastIndexOfContainer(targetContainer);
if (newIndex != parts.end() && ref == *newIndex)
{
return;
}
if (newIndex == parts.end())
{
parts.push_back(ref);
}
else
{
PartListType::size_type index = newIndex - parts.begin();
parts.erase(std::find(parts.begin(), parts.end(), ref));
auto insertIndex = parts.begin() + index;
parts.insert(insertIndex, ref);
}
}
WorkbenchPage::ActivationList::PartListIter WorkbenchPage::ActivationList::LastIndexOfContainer(
SmartPointer<ILayoutContainer> container)
{
auto i = parts.rbegin();
while (i != parts.rend())
{
IWorkbenchPartReference::Pointer ref(*i);
ILayoutContainer::Pointer cnt(page->GetContainer(ref));
if (cnt == container)
{
return --i.base();
}
++i;
}
return parts.end();
}
void WorkbenchPage::ActivationList::SetActive(SmartPointer<
IWorkbenchPartReference> ref)
{
this->SetActive(ref->GetPart(true));
}
void WorkbenchPage::ActivationList::Add(
SmartPointer<IWorkbenchPartReference> ref)
{
if (std::find(parts.begin(), parts.end(), ref) != parts.end())
{
return;
}
ref->GetPart(false);
parts.push_front(ref);
}
SmartPointer<IWorkbenchPart> WorkbenchPage::ActivationList::GetActive()
{
if (parts.empty())
{
return IWorkbenchPart::Pointer(nullptr);
}
return this->GetActive(parts.end());
}
SmartPointer<IWorkbenchPart> WorkbenchPage::ActivationList::GetPreviouslyActive()
{
if (parts.size() < 2)
{
return IWorkbenchPart::Pointer(nullptr);
}
return this->GetActive(--parts.end());
}
SmartPointer<IWorkbenchPartReference> WorkbenchPage::ActivationList::GetActiveReference(
bool editorsOnly)
{
return this->GetActiveReference(parts.end(), editorsOnly);
}
WorkbenchPage::ActivationList::PartListIter WorkbenchPage::ActivationList::IndexOf(
SmartPointer<IWorkbenchPart> part)
{
IWorkbenchPartReference::Pointer ref(page->GetReference(part));
if (ref == 0)
{
return parts.end();
}
return std::find(parts.begin(), parts.end(), ref);
}
WorkbenchPage::ActivationList::PartListIter WorkbenchPage::ActivationList::IndexOf(
SmartPointer<IWorkbenchPartReference> ref)
{
return std::find(parts.begin(), parts.end(), ref);
}
bool WorkbenchPage::ActivationList::Remove(
SmartPointer<IWorkbenchPartReference> ref)
{
bool contains = std::find(parts.begin(), parts.end(), ref) != parts.end();
parts.erase(std::find(parts.begin(), parts.end(), ref));
return contains;
}
SmartPointer<IEditorPart> WorkbenchPage::ActivationList::GetTopEditor()
{
IEditorReference::Pointer editor =
this->GetActiveReference(parts.end(), true).Cast<IEditorReference> ();
if (editor == 0)
{
return IEditorPart::Pointer(nullptr);
}
return editor->GetEditor(true);
}
SmartPointer<IWorkbenchPart> WorkbenchPage::ActivationList::GetActive(
PartListIter start)
{
IWorkbenchPartReference::Pointer ref(this->GetActiveReference(start, false));
if (!ref)
{
return IWorkbenchPart::Pointer(nullptr);
}
return ref->GetPart(true);
}
SmartPointer<IWorkbenchPartReference> WorkbenchPage::ActivationList::GetActiveReference(
PartListIter start, bool editorsOnly)
{
// First look for parts that aren't obscured by the current zoom state
IWorkbenchPartReference::Pointer nonObscured = this->GetActiveReference(
start, editorsOnly, true);
if (nonObscured)
{
return nonObscured;
}
// Now try all the rest of the parts
return this->GetActiveReference(start, editorsOnly, false);
}
SmartPointer<IWorkbenchPartReference> WorkbenchPage::ActivationList::GetActiveReference(
PartListIter start, bool editorsOnly, bool /*skipPartsObscuredByZoom*/)
{
QList<IViewReference::Pointer> views = page->GetViewReferences();
PartListReverseIter i(start);
while (i != parts.rend())
{
WorkbenchPartReference::Pointer ref(i->Cast<WorkbenchPartReference> ());
if (editorsOnly && (ref.Cast<IEditorReference> () == 0))
{
++i;
continue;
}
// Skip parts whose containers have disabled auto-focus
PartPane::Pointer pane(ref->GetPane());
if (pane)
{
if (!pane->AllowsAutoFocus())
{
++i;
continue;
}
// if (skipPartsObscuredByZoom) {
// if (pane.isObscuredByZoom()) {
// continue;
// }
// }
}
// Skip fastviews (unless overridden)
if (IViewReference::Pointer viewRef = ref.Cast<IViewReference>())
{
//if (ref == getActiveFastView() || !((IViewReference) ref).isFastView()) {
for (int j = 0; j < views.size(); j++)
{
if (views[j] == viewRef)
{
return viewRef.Cast<IWorkbenchPartReference> ();
}
}
//}
}
else
{
return ref.Cast<IWorkbenchPartReference> ();
}
++i;
}
return IWorkbenchPartReference::Pointer(nullptr);
}
QList<SmartPointer<IEditorReference> > WorkbenchPage::ActivationList::GetEditors()
{
QList<IEditorReference::Pointer> editors;
for (auto i = parts.begin(); i != parts.end(); ++i)
{
if (IEditorReference::Pointer part = i->Cast<IEditorReference>())
{
editors.push_back(part);
}
}
return editors;
}
QList<SmartPointer<IWorkbenchPartReference> > WorkbenchPage::ActivationList::GetParts()
{
QList<IViewReference::Pointer> views(page->GetViewReferences());
QList<IWorkbenchPartReference::Pointer> resultList;
for (auto iterator = parts.begin(); iterator != parts.end(); ++iterator)
{
if (IViewReference::Pointer ref = iterator->Cast<IViewReference>())
{
//Filter views from other perspectives
for (int i = 0; i < views.size(); i++)
{
if (ref == views[i])
{
resultList.push_back(ref);
break;
}
}
}
else
{
resultList.push_back(*iterator);
}
}
return resultList;
}
WorkbenchPage::ActionSwitcher::ActionSwitcher(WorkbenchPage* page)
: page(page)
{
}
void WorkbenchPage::ActionSwitcher::UpdateActivePart(
IWorkbenchPart::Pointer newPart)
{
IWorkbenchPart::Pointer _activePart = this->activePart.Lock();
IEditorPart::Pointer _topEditor = this->topEditor.Lock();
if (_activePart == newPart)
{
return;
}
bool isNewPartAnEditor = newPart.Cast<IEditorPart> ().IsNotNull();
if (isNewPartAnEditor)
{
QString oldId;
if (_topEditor)
{
oldId = _topEditor->GetSite()->GetId();
}
QString newId = newPart->GetSite()->GetId();
// if the active part is an editor and the new editor
// is the same kind of editor, then we don't have to do
// anything
if (activePart == topEditor && newId == oldId)
{
activePart = newPart;
topEditor = newPart.Cast<IEditorPart> ();
return;
}
// remove the contributions of the old editor
// if it is a different kind of editor
if (oldId != newId)
{
this->DeactivateContributions(_topEditor, true);
}
// if a view was the active part, disable its contributions
if (_activePart && _activePart != _topEditor)
{
this->DeactivateContributions(_activePart, true);
}
// show (and enable) the contributions of the new editor
// if it is a different kind of editor or if the
// old active part was a view
if (newId != oldId || _activePart != _topEditor)
{
this->ActivateContributions(newPart, true);
}
}
else if (newPart.IsNull())
{
if (_activePart)
{
// remove all contributions
this->DeactivateContributions(_activePart, true);
}
}
else
{
// new part is a view
// if old active part is a view, remove all contributions,
// but if old part is an editor only disable
if (_activePart)
{
this->DeactivateContributions(_activePart,
_activePart.Cast<IViewPart> ().IsNotNull());
}
this->ActivateContributions(newPart, true);
}
//TODO WorkbenchPage action sets
// ArrayList newActionSets = 0;
// if (isNewPartAnEditor || (activePart == topEditor && newPart == 0))
// {
// newActionSets = calculateActionSets(newPart, 0);
// }
// else
// {
// newActionSets = calculateActionSets(newPart, topEditor);
// }
//
// if (!updateActionSets(newActionSets))
// {
page->UpdateActionBars();
// }
if (isNewPartAnEditor)
{
topEditor = newPart.Cast<IEditorPart> ();
}
else if (activePart == topEditor && newPart.IsNull())
{
// since we removed all the contributions, we clear the top
// editor
topEditor.Reset();
}
activePart = newPart;
}
void WorkbenchPage::ActionSwitcher::UpdateTopEditor(
IEditorPart::Pointer newEditor)
{
if (topEditor.Lock() == newEditor)
{
return;
}
if (activePart == topEditor)
{
this->UpdateActivePart(newEditor);
return;
}
QString oldId;
if (!topEditor.Expired())
{
oldId = topEditor.Lock()->GetSite()->GetId();
}
QString newId;
if (newEditor.IsNotNull())
{
newId = newEditor->GetSite()->GetId();
}
if (oldId == newId)
{
// we don't have to change anything
topEditor = newEditor;
return;
}
// Remove the contributions of the old editor
if (!topEditor.Expired())
{
this->DeactivateContributions(topEditor.Lock(), true);
}
// Show (disabled) the contributions of the new editor
if (newEditor.IsNotNull())
{
this->ActivateContributions(newEditor, false);
}
// ArrayList newActionSets = calculateActionSets(activePart, newEditor);
// if (!updateActionSets(newActionSets))
// {
page->UpdateActionBars();
// }
topEditor = newEditor;
}
void WorkbenchPage::ActionSwitcher::ActivateContributions(
IWorkbenchPart::Pointer /*part*/, bool /*enable*/)
{
//PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
//site->ActivateActionBars(enable);
}
void WorkbenchPage::ActionSwitcher::DeactivateContributions(
IWorkbenchPart::Pointer /*part*/, bool /*remove*/)
{
//PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
//site->DeactivateActionBars(remove);
}
IExtensionPoint::Pointer WorkbenchPage::GetPerspectiveExtensionPoint()
{
return Platform::GetExtensionRegistry()->GetExtensionPoint(
PlatformUI::PLUGIN_ID(), WorkbenchRegistryConstants::PL_PERSPECTIVE_EXTENSIONS);
}
WorkbenchPage::WorkbenchPage(WorkbenchWindow* w, const QString& layoutID,
IAdaptable* input)
: actionSwitcher(this)
{
if (layoutID == "")
{
throw WorkbenchException("Perspective ID is undefined");
}
this->Register();
this->Init(w, layoutID, input, true);
this->UnRegister(false);
}
WorkbenchPage::WorkbenchPage(WorkbenchWindow* w, IAdaptable* input)
: actionSwitcher(this)
{
this->Register();
this->Init(w, "", input, false);
this->UnRegister(false);
}
void WorkbenchPage::Activate(IWorkbenchPart::Pointer part)
{
// Sanity check.
if (!this->CertifyPart(part))
{
return;
}
if (window->IsClosing())
{
return;
}
// if (composite!=0 && composite.isVisible() && !((GrabFocus)Tweaklets.get(GrabFocus.KEY)).grabFocusAllowed(part))
// {
// return;
// }
// Activate part.
//if (window.getActivePage() == this) {
IWorkbenchPartReference::Pointer ref = this->GetReference(part);
this->InternalBringToTop(ref);
this->SetActivePart(part);
}
void WorkbenchPage::ActivatePart(const IWorkbenchPart::Pointer part)
{
// Platform.run(new SafeRunnable(WorkbenchMessages.WorkbenchPage_ErrorActivatingView)
// {
// public void WorkbenchPage::run()
// {
if (part.IsNotNull())
{
//part.setFocus();
PartPane::Pointer pane = this->GetPane(part);
pane->SetFocus();
PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
pane->ShowFocus(true);
//this->UpdateTabList(part);
//SubActionBars bars = (SubActionBars) site.getActionBars();
//bars.partChanged(part);
}
// }
// }
// );
}
void WorkbenchPage::AddPartListener(IPartListener* l)
{
partList->GetPartService()->AddPartListener(l);
}
void WorkbenchPage::AddSelectionListener(ISelectionListener* listener)
{
selectionService->AddSelectionListener(listener);
}
void WorkbenchPage::AddSelectionListener(const QString& partId,
ISelectionListener* listener)
{
selectionService->AddSelectionListener(partId, listener);
}
void WorkbenchPage::AddPostSelectionListener(
ISelectionListener* listener)
{
selectionService->AddPostSelectionListener(listener);
}
void WorkbenchPage::AddPostSelectionListener(const QString& partId,
ISelectionListener* listener)
{
selectionService->AddPostSelectionListener(partId, listener);
}
ILayoutContainer::Pointer WorkbenchPage::GetContainer(
IWorkbenchPart::Pointer part)
{
PartPane::Pointer pane = this->GetPane(part);
if (pane == 0)
{
return ILayoutContainer::Pointer(nullptr);
}
return pane->GetContainer();
}
ILayoutContainer::Pointer WorkbenchPage::GetContainer(
IWorkbenchPartReference::Pointer part)
{
PartPane::Pointer pane = this->GetPane(part);
if (pane == 0)
{
return ILayoutContainer::Pointer(nullptr);
}
return pane->GetContainer();
}
PartPane::Pointer WorkbenchPage::GetPane(IWorkbenchPart::Pointer part)
{
if (part.IsNull())
{
return PartPane::Pointer(nullptr);
}
return this->GetPane(this->GetReference(part));
}
PartPane::Pointer WorkbenchPage::GetPane(IWorkbenchPartReference::Pointer part)
{
if (part.IsNull())
{
return PartPane::Pointer(nullptr);
}
return part.Cast<WorkbenchPartReference> ()->GetPane();
}
bool WorkbenchPage::InternalBringToTop(IWorkbenchPartReference::Pointer part)
{
bool broughtToTop = false;
// Move part.
if (part.Cast<IEditorReference> ().IsNotNull())
{
ILayoutContainer::Pointer container = this->GetContainer(part);
if (container.Cast<PartStack> () != 0)
{
PartStack::Pointer stack = container.Cast<PartStack> ();
PartPane::Pointer newPart = this->GetPane(part);
if (stack->GetSelection() != newPart)
{
stack->SetSelection(newPart);
}
broughtToTop = true;
}
}
else if (part.Cast<IViewReference> ().IsNotNull())
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
broughtToTop = persp->BringToTop(part.Cast<IViewReference> ());
}
}
// Ensure that this part is considered the most recently activated part
// in this stack
activationList->BringToTop(part);
return broughtToTop;
}
void WorkbenchPage::BringToTop(IWorkbenchPart::Pointer part)
{
// Sanity check.
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0 || !this->CertifyPart(part))
{
return;
}
// if (!((GrabFocus)Tweaklets.get(GrabFocus.KEY)).grabFocusAllowed(part))
// {
// return;
// }
// QString label; // debugging only
// if (UIStats.isDebugging(UIStats.BRING_PART_TO_TOP))
// {
// label = part != 0 ? part.getTitle() : "none"; //$NON-NLS-1$
// }
IWorkbenchPartReference::Pointer ref = this->GetReference(part);
ILayoutContainer::Pointer activeEditorContainer = this->GetContainer(
this->GetActiveEditor().Cast<IWorkbenchPart> ());
ILayoutContainer::Pointer activePartContainer = this->GetContainer(
this->GetActivePart());
ILayoutContainer::Pointer newPartContainer = this->GetContainer(part);
if (newPartContainer == activePartContainer)
{
this->MakeActive(ref);
}
else if (newPartContainer == activeEditorContainer)
{
if (ref.Cast<IEditorReference> () != 0)
{
if (part != 0)
{
IWorkbenchPartSite::Pointer site = part->GetSite();
if (site.Cast<PartSite> () != 0)
{
ref = site.Cast<PartSite> ()->GetPane()->GetPartReference();
}
}
this->MakeActiveEditor(ref.Cast<IEditorReference> ());
}
else
{
this->MakeActiveEditor(IEditorReference::Pointer(nullptr));
}
}
else
{
this->InternalBringToTop(ref);
if (ref != 0)
{
partList->FirePartBroughtToTop(ref);
}
}
}
void WorkbenchPage::BusyResetPerspective()
{
ViewIntroAdapterPart::Pointer
introViewAdapter =
dynamic_cast<WorkbenchIntroManager*> (GetWorkbenchWindow() ->GetWorkbench()->GetIntroManager())->GetIntroAdapterPart().Cast<
ViewIntroAdapterPart> ();
// PartPane introPane = 0;
// boolean introFullScreen = false;
// if (introViewAdapter != 0)
// {
// introPane = ((PartSite) introViewAdapter.getSite()).getPane();
// introViewAdapter.setHandleZoomEvents(false);
// introFullScreen = introPane.isZoomed();
// }
// //try to prevent intro flicker.
// if (introFullScreen)
// {
// window.getShell().setRedraw(false);
// }
// try
// {
// // Always unzoom
// if (isZoomed())
// {
// zoomOut();
// }
// Get the current perspective.
// This describes the working layout of the page and differs from
// the original template.
Perspective::Pointer oldPersp = this->GetActivePerspective();
// Map the current perspective to the original template.
// If the original template cannot be found then it has been deleted.
// In that case just return. (PR#1GDSABU).
IPerspectiveRegistry* reg =
WorkbenchPlugin::GetDefault() ->GetPerspectiveRegistry();
PerspectiveDescriptor::Pointer desc = reg->FindPerspectiveWithId(
oldPersp->GetDesc()->GetId()).Cast<PerspectiveDescriptor> ();
if (desc == 0)
{
desc
= reg->FindPerspectiveWithId(oldPersp ->GetDesc().Cast<
PerspectiveDescriptor> ()->GetOriginalId()).Cast<
PerspectiveDescriptor> ();
}
if (desc == 0)
{
return;
}
// Notify listeners that we are doing a reset.
window->FirePerspectiveChanged(IWorkbenchPage::Pointer(this), desc,
CHANGE_RESET);
// Create new persp from original template.
// Suppress the perspectiveOpened and perspectiveClosed events otherwise it looks like two
// instances of the same perspective are open temporarily (see bug 127470).
Perspective::Pointer newPersp = this->CreatePerspective(desc, false);
if (newPersp == 0)
{
// We're not going through with the reset, so it is complete.
window->FirePerspectiveChanged(IWorkbenchPage::Pointer(this), desc,
CHANGE_RESET_COMPLETE);
return;
}
// Update the perspective list and shortcut
perspList.Swap(oldPersp, newPersp);
// Install new persp.
this->SetPerspective(newPersp);
// Destroy old persp.
this->DisposePerspective(oldPersp, false);
// Update the Coolbar layout.
this->ResetToolBarLayout();
// restore the maximized intro
if (introViewAdapter)
{
try
{
// ensure that the intro is visible in the new perspective
ShowView(IntroConstants::INTRO_VIEW_ID);
// if (introFullScreen)
// {
// toggleZoom(introPane.getPartReference());
// }
} catch (PartInitException& e)
{
//TODO IStatus
WorkbenchPlugin::Log("Could not restore intro", e);
// WorkbenchPlugin.getStatus(e));
}
// finally
// {
// // we want the intro back to a normal state before we fire the event
// introViewAdapter.setHandleZoomEvents(true);
// }
}
// Notify listeners that we have completed our reset.
window->FirePerspectiveChanged(IWorkbenchPage::Pointer(this), desc,
CHANGE_RESET_COMPLETE);
// }
// finally
// {
// // reset the handling of zoom events (possibly for the second time) in case there was
// // an exception thrown
// if (introViewAdapter != 0)
// {
// introViewAdapter.setHandleZoomEvents(true);
// }
//
// if (introFullScreen)
// {
// window.getShell().setRedraw(true);
// }
// }
}
void WorkbenchPage::RemovePerspective(IPerspectiveDescriptor::Pointer desc)
{
Perspective::Pointer newPersp;
PerspectiveDescriptor::Pointer realDesc = desc.Cast<PerspectiveDescriptor> ();
newPersp = this->FindPerspective(desc);
perspList.Remove(newPersp);
}
void WorkbenchPage::BusySetPerspective(IPerspectiveDescriptor::Pointer desc)
{
// Create new layout.
QString label = desc->GetId(); // debugging only
Perspective::Pointer newPersp;
//try
//{
//UIStats.start(UIStats.SWITCH_PERSPECTIVE, label);
PerspectiveDescriptor::Pointer realDesc = desc.Cast<PerspectiveDescriptor> ();
newPersp = this->FindPerspective(realDesc);
if (newPersp == 0)
{
newPersp = this->CreatePerspective(realDesc, true);
if (newPersp == 0)
{
return;
}
}
// Change layout.
this->SetPerspective(newPersp);
// }
// catch (std::exception& e)
// {
// UIStats.end(UIStats.SWITCH_PERSPECTIVE, desc.getId(), label);
// throw e;
// }
}
IViewPart::Pointer WorkbenchPage::BusyShowView(const QString& viewID,
const QString& secondaryID, int mode)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return IViewPart::Pointer(nullptr);
}
// If this view is already visible just return.
IViewReference::Pointer ref = persp->FindView(viewID, secondaryID);
IViewPart::Pointer view;
if (ref != 0)
{
view = ref->GetView(true);
}
if (view != 0)
{
this->BusyShowView(view, mode);
return view;
}
// Show the view.
view = persp->ShowView(viewID, secondaryID);
if (view != 0)
{
this->BusyShowView(view, mode);
IWorkbenchPartReference::Pointer partReference = this->GetReference(view);
PartPane::Pointer partPane = this->GetPane(partReference);
partPane->SetInLayout(true);
IWorkbenchPage::Pointer thisPage(this);
window->FirePerspectiveChanged(thisPage, GetPerspective(), partReference,
CHANGE_VIEW_SHOW);
window->FirePerspectiveChanged(thisPage, GetPerspective(), CHANGE_VIEW_SHOW);
}
return view;
}
void WorkbenchPage::UpdateActionBars()
{
window->UpdateActionBars();
}
void WorkbenchPage::BusyShowView(IViewPart::Pointer part, int mode)
{
// if (!((GrabFocus) Tweaklets.get(GrabFocus.KEY)).grabFocusAllowed(part))
// {
// return;
// }
if (mode == VIEW_ACTIVATE)
{
this->Activate(part);
}
else if (mode == VIEW_VISIBLE)
{
IWorkbenchPartReference::Pointer ref = this->GetActivePartReference();
// if there is no active part or it's not a view, bring to top
if (ref == 0 || ref.Cast<IViewReference> () == 0)
{
this->BringToTop(part);
}
else
{
// otherwise check to see if the we're in the same stack as the active view
IViewReference::Pointer activeView = ref.Cast<IViewReference> ();
QList<IViewReference::Pointer> viewStack =
this->GetViewReferenceStack(part);
for (int i = 0; i < viewStack.size(); i++)
{
if (viewStack[i] == activeView)
{
return;
}
}
this->BringToTop(part);
}
}
}
bool WorkbenchPage::CertifyPart(IWorkbenchPart::Pointer part)
{
//Workaround for bug 22325
if (part != 0 && part->GetSite().Cast<PartSite> () == 0)
{
return false;
}
if (part.Cast<IEditorPart> () != 0)
{
IEditorReference::Pointer ref = this->GetReference(part).Cast<
IEditorReference> ();
return ref != 0 && this->GetEditorManager()->ContainsEditor(ref);
}
if (part.Cast<IViewPart> () != 0)
{
Perspective::Pointer persp = this->GetActivePerspective();
return persp != 0 && persp->ContainsView(part.Cast<IViewPart> ());
}
return false;
}
bool WorkbenchPage::Close()
{
bool ret;
//BusyIndicator.showWhile(0, new Runnable()
// {
// public void WorkbenchPage::run()
// {
ret = window->ClosePage(IWorkbenchPage::Pointer(this), true);
// }
// });
return ret;
}
bool WorkbenchPage::CloseAllSavedEditors()
{
// get the Saved editors
QList<IEditorReference::Pointer> editors = this->GetEditorReferences();
QList<IEditorReference::Pointer> savedEditors;
for (QList<IEditorReference::Pointer>::iterator iter = editors.begin(); iter
!= editors.end(); ++iter)
{
IEditorReference::Pointer editor = *iter;
if (!editor->IsDirty())
{
savedEditors.push_back(editor);
}
}
//there are no unsaved editors
if (savedEditors.empty())
{
return true;
}
return this->CloseEditors(savedEditors, false);
}
bool WorkbenchPage::CloseAllEditors(bool save)
{
return this->CloseEditors(this->GetEditorReferences(), save);
}
void WorkbenchPage::UpdateActivePart()
{
if (this->IsDeferred())
{
return;
}
IWorkbenchPartReference::Pointer oldActivePart =
partList->GetActivePartReference();
IWorkbenchPartReference::Pointer oldActiveEditor =
partList->GetActiveEditorReference();
IWorkbenchPartReference::Pointer newActivePart;
IEditorReference::Pointer newActiveEditor;
if (!window->IsClosing())
{
// If an editor is active, try to keep an editor active
if (oldActiveEditor && oldActivePart == oldActiveEditor)
{
newActiveEditor = activationList->GetActiveReference(true).Cast<
IEditorReference> ();
newActivePart = newActiveEditor;
if (newActivePart == 0)
{
// Only activate a non-editor if there's no editors left
newActivePart = activationList->GetActiveReference(false);
}
}
else
{
// If a non-editor is active, activate whatever was activated most recently
newActivePart = activationList->GetActiveReference(false);
if (newActivePart.Cast<IEditorReference> () != 0)
{
// If that happens to be an editor, make it the active editor as well
newActiveEditor = newActivePart.Cast<IEditorReference> ();
}
else
{
// Otherwise, select whatever editor was most recently active
newActiveEditor = activationList->GetActiveReference(true).Cast<
IEditorReference> ();
}
}
}
if (oldActiveEditor != newActiveEditor)
{
this->MakeActiveEditor(newActiveEditor);
}
if (newActivePart != oldActivePart)
{
this->MakeActive(newActivePart);
}
}
void WorkbenchPage::MakeActive(IWorkbenchPartReference::Pointer ref)
{
if (ref == 0)
{
this->SetActivePart(IWorkbenchPart::Pointer(nullptr));
}
else
{
IWorkbenchPart::Pointer newActive = ref->GetPart(true);
if (newActive == 0)
{
this->SetActivePart(IWorkbenchPart::Pointer(nullptr));
}
else
{
this->Activate(newActive);
}
}
}
void WorkbenchPage::MakeActiveEditor(IEditorReference::Pointer ref)
{
if (ref == this->GetActiveEditorReference())
{
return;
}
IEditorPart::Pointer part = (ref == 0) ? IEditorPart::Pointer(nullptr)
: ref->GetEditor(true);
if (part)
{
editorMgr->SetVisibleEditor(ref, false);
//navigationHistory.MarkEditor(part);
}
actionSwitcher.UpdateTopEditor(part);
if (ref)
{
activationList->BringToTop(this->GetReference(part));
}
partList->SetActiveEditor(ref);
}
bool WorkbenchPage::CloseEditors(
const QList<IEditorReference::Pointer>& refArray, bool save)
{
if (refArray.empty())
{
return true;
}
IWorkbenchPage::Pointer thisPage(this);
// Check if we're being asked to close any parts that are already closed or cannot
// be closed at this time
QList<IEditorReference::Pointer> editorRefs;
for (QList<IEditorReference::Pointer>::const_iterator iter =
refArray.begin(); iter != refArray.end(); ++iter)
{
IEditorReference::Pointer reference = *iter;
// If we're in the middle of creating this part, this is a programming error. Abort the entire
// close operation. This usually occurs if someone tries to open a dialog in a method that
// isn't allowed to do so, and a *syncExec tries to close the part. If this shows up in a log
// file with a dialog's event loop on the stack, then the code that opened the dialog is usually
// at fault.
if (partBeingActivated == reference)
{
ctkRuntimeException re(
"WARNING: Blocked recursive attempt to close part "
+ partBeingActivated->GetId()
+ " while still in the middle of activating it");
WorkbenchPlugin::Log(re);
return false;
}
// if (reference.Cast<WorkbenchPartReference> () != 0)
// {
// WorkbenchPartReference::Pointer ref = reference.Cast<WorkbenchPartReference>();
//
// // If we're being asked to close a part that is disposed (ie: already closed),
// // skip it and proceed with closing the remaining parts.
// if (ref.isDisposed())
// {
// continue;
// }
// }
editorRefs.push_back(reference);
}
// notify the model manager before the close
QList<IWorkbenchPart::Pointer> partsToClose;
for (int i = 0; i < editorRefs.size(); i++)
{
IWorkbenchPart::Pointer refPart = editorRefs[i]->GetPart(false);
if (refPart != 0)
{
partsToClose.push_back(refPart);
}
}
SaveablesList::Pointer modelManager;
SaveablesList::PostCloseInfo::Pointer postCloseInfo;
if (partsToClose.size() > 0)
{
modelManager = dynamic_cast<SaveablesList*>(
this->GetWorkbenchWindow()->GetService<ISaveablesLifecycleListener>());
// this may prompt for saving and return 0 if the user canceled:
postCloseInfo = modelManager->PreCloseParts(partsToClose, save,
this->GetWorkbenchWindow());
if (postCloseInfo == 0)
{
return false;
}
}
// Fire pre-removal changes
for (int i = 0; i < editorRefs.size(); i++)
{
IEditorReference::Pointer ref = editorRefs[i];
// Notify interested listeners before the close
window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
CHANGE_EDITOR_CLOSE);
}
this->DeferUpdates(true);
try
{
if (modelManager != 0)
{
modelManager->PostClose(postCloseInfo);
}
// Close all editors.
for (int i = 0; i < editorRefs.size(); i++)
{
IEditorReference::Pointer ref = editorRefs[i];
// Remove editor from the presentation
editorPresentation->CloseEditor(ref);
this->PartRemoved(ref.Cast<WorkbenchPartReference> ());
}
} catch (...)
{
}
this->DeferUpdates(false);
// Notify interested listeners after the close
window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
CHANGE_EDITOR_CLOSE);
// Return true on success.
return true;
}
void WorkbenchPage::DeferUpdates(bool shouldDefer)
{
if (shouldDefer)
{
if (deferCount == 0)
{
this->StartDeferring();
}
deferCount++;
}
else
{
deferCount--;
if (deferCount == 0)
{
this->HandleDeferredEvents();
}
}
}
void WorkbenchPage::StartDeferring()
{
//editorPresentation.getLayoutPart().deferUpdates(true);
}
void WorkbenchPage::HandleDeferredEvents()
{
editorPresentation->GetLayoutPart()->DeferUpdates(false);
this->UpdateActivePart();
QList<WorkbenchPartReference::Pointer> disposals = pendingDisposals;
pendingDisposals.clear();
for (int i = 0; i < disposals.size(); i++)
{
this->DisposePart(disposals[i]);
}
}
bool WorkbenchPage::IsDeferred()
{
return deferCount > 0;
}
bool WorkbenchPage::CloseEditor(IEditorReference::Pointer editorRef, bool save)
{
QList<IEditorReference::Pointer> list;
list.push_back(editorRef);
return this->CloseEditors(list, save);
}
bool WorkbenchPage::CloseEditor(IEditorPart::Pointer editor, bool save)
{
IWorkbenchPartReference::Pointer ref = this->GetReference(editor);
if (ref.Cast<IEditorReference> ().IsNotNull())
{
QList<IEditorReference::Pointer> list;
list.push_back(ref.Cast<IEditorReference> ());
return this->CloseEditors(list, save);
}
return false;
}
void WorkbenchPage::CloseCurrentPerspective(bool saveParts, bool closePage)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
this->ClosePerspective(persp, saveParts, closePage);
}
}
void WorkbenchPage::ClosePerspective(IPerspectiveDescriptor::Pointer desc,
bool saveParts, bool closePage)
{
Perspective::Pointer persp = this->FindPerspective(desc);
if (persp != 0)
{
this->ClosePerspective(persp, saveParts, closePage);
}
}
void WorkbenchPage::ClosePerspective(Perspective::Pointer persp,
bool saveParts, bool closePage)
{
// // Always unzoom
// if (isZoomed())
// {
// zoomOut();
// }
QList<IWorkbenchPart::Pointer> partsToSave;
QList<IWorkbenchPart::Pointer> viewsToClose;
// collect views that will go away and views that are dirty
QList<IViewReference::Pointer> viewReferences =
persp->GetViewReferences();
for (int i = 0; i < viewReferences.size(); i++)
{
IViewReference::Pointer reference = viewReferences[i];
if (this->GetViewFactory()->GetReferenceCount(reference) == 1)
{
IViewPart::Pointer viewPart = reference->GetView(false);
if (viewPart != 0)
{
viewsToClose.push_back(viewPart);
if (saveParts && reference->IsDirty())
{
partsToSave.push_back(viewPart);
}
}
}
}
if (saveParts && perspList.Size() == 1)
{
// collect editors that are dirty
QList<IEditorReference::Pointer> editorReferences =
this->GetEditorReferences();
for (QList<IEditorReference::Pointer>::iterator refIter =
editorReferences.begin(); refIter != editorReferences.end(); ++refIter)
{
IEditorReference::Pointer reference = *refIter;
if (reference->IsDirty())
{
IEditorPart::Pointer editorPart = reference->GetEditor(false);
if (editorPart != 0)
{
partsToSave.push_back(editorPart);
}
}
}
}
if (saveParts && !partsToSave.empty())
{
if (!EditorManager::SaveAll(partsToSave, true, true, false,
IWorkbenchWindow::Pointer(window)))
{
// user canceled
return;
}
}
// Close all editors on last perspective close
if (perspList.Size() == 1 && this->GetEditorManager()->GetEditorCount() > 0)
{
// Close all editors
if (!this->CloseAllEditors(false))
{
return;
}
}
// closeAllEditors already notified the saveables list about the editors.
SaveablesList::Pointer saveablesList(
dynamic_cast<SaveablesList*>(
this->GetWorkbenchWindow()->GetWorkbench()->GetService<ISaveablesLifecycleListener>()));
// we took care of the saving already, so pass in false (postCloseInfo will be non-0)
SaveablesList::PostCloseInfo::Pointer postCloseInfo =
saveablesList->PreCloseParts(viewsToClose, false,
this->GetWorkbenchWindow());
saveablesList->PostClose(postCloseInfo);
// Dispose of the perspective
bool isActive = (perspList.GetActive() == persp);
if (isActive)
{
this->SetPerspective(perspList.GetNextActive());
}
this->DisposePerspective(persp, true);
if (closePage && perspList.Size() == 0)
{
this->Close();
}
}
void WorkbenchPage::CloseAllPerspectives(bool saveEditors, bool closePage)
{
if (perspList.IsEmpty())
{
return;
}
// // Always unzoom
// if (isZoomed())
// {
// zoomOut();
// }
if (saveEditors)
{
if (!this->SaveAllEditors(true))
{
return;
}
}
// Close all editors
if (!this->CloseAllEditors(false))
{
return;
}
// Deactivate the active perspective and part
this->SetPerspective(Perspective::Pointer(nullptr));
// Close each perspective in turn
PerspectiveList oldList = perspList;
perspList = PerspectiveList();
for (PerspectiveList::iterator itr = oldList.Begin(); itr != oldList.End(); ++itr)
{
this->ClosePerspective(*itr, false, false);
}
if (closePage)
{
this->Close();
}
}
void WorkbenchPage::CreateClientComposite()
{
QWidget* parent = window->GetPageComposite();
// StartupThreading.runWithoutExceptions(new StartupRunnable()
// {
//
// public void WorkbenchPage::runWithException()
// {
composite
= Tweaklets::Get(WorkbenchPageTweaklet::KEY)->CreateClientComposite(
parent);
Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetVisible(composite, false); // Make visible on activate.
// force the client composite to be layed out
// parent.layout();
// }
// });
}
Perspective::Pointer WorkbenchPage::CreatePerspective(
PerspectiveDescriptor::Pointer desc, bool notify)
{
QString label = desc->GetId(); // debugging only
try
{
//UIStats.start(UIStats.CREATE_PERSPECTIVE, label);
WorkbenchPage::Pointer thisPage(this);
Perspective::Pointer persp(new Perspective(desc, thisPage));
perspList.Add(persp);
if (notify)
{
window->FirePerspectiveOpened(thisPage, desc);
}
//if the perspective is fresh and uncustomzied then it is not dirty
//no reset will be prompted for
if (!desc->HasCustomDefinition())
{
dirtyPerspectives.erase(desc->GetId());
}
return persp;
} catch (WorkbenchException& /*e*/)
{
if (!window->GetWorkbenchImpl()->IsStarting())
{
QMessageBox::critical(reinterpret_cast<QWidget*>(window->GetShell()->GetControl()),
"Error",
"Problems opening perspective \"" + desc->GetId() + "\"");
}
return Perspective::Pointer(nullptr);
}
// finally
// {
// UIStats.end(UIStats.CREATE_PERSPECTIVE, desc.getId(), label);
// }
}
void WorkbenchPage::PartAdded(WorkbenchPartReference::Pointer ref)
{
activationList->Add(ref);
partList->AddPart(ref);
this->UpdateActivePart();
}
void WorkbenchPage::PartRemoved(WorkbenchPartReference::Pointer ref)
{
activationList->Remove(ref);
this->DisposePart(ref);
}
void WorkbenchPage::DisposePart(WorkbenchPartReference::Pointer ref)
{
if (this->IsDeferred())
{
pendingDisposals.push_back(ref);
}
else
{
partList->RemovePart(ref);
ref->Dispose();
}
}
void WorkbenchPage::DeactivatePart(IWorkbenchPart::Pointer part)
{
if (part.IsNotNull())
{
PartSite::Pointer site = part->GetSite().Cast<PartSite> ();
site->GetPane()->ShowFocus(false);
}
}
void WorkbenchPage::DetachView(IViewReference::Pointer ref)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return;
}
PerspectiveHelper* presentation = persp->GetPresentation();
presentation->DetachPart(ref);
}
void WorkbenchPage::AttachView(IViewReference::Pointer ref)
{
PerspectiveHelper* presentation = this->GetPerspectivePresentation();
presentation->AttachPart(ref);
}
WorkbenchPage::~WorkbenchPage()
{
// increment reference count to prevent recursive deletes
this->Register();
{
{
this->MakeActiveEditor(IEditorReference::Pointer(nullptr));
this->MakeActive(IWorkbenchPartReference::Pointer(nullptr));
// Close and dispose the editors.
this->CloseAllEditors(false);
// Need to make sure model data is cleaned up when the page is
// disposed. Collect all the views on the page and notify the
// saveable list of a pre/post close. This will free model data.
QList<IWorkbenchPartReference::Pointer> partsToClose =
this->GetOpenParts();
QList<IWorkbenchPart::Pointer> dirtyParts;
for (int i = 0; i < partsToClose.size(); i++)
{
IWorkbenchPart::Pointer part = partsToClose[i]->GetPart(false);
if (part != 0 && part.Cast<IViewPart> () != 0)
{
dirtyParts.push_back(part);
}
}
SaveablesList::Pointer saveablesList(dynamic_cast<SaveablesList*>(
this->GetWorkbenchWindow()->GetWorkbench()->GetService<ISaveablesLifecycleListener>()));
SaveablesList::PostCloseInfo::Pointer postCloseInfo =
saveablesList->PreCloseParts(dirtyParts, false,
this->GetWorkbenchWindow());
saveablesList->PostClose(postCloseInfo);
IWorkbenchPage::Pointer thisPage(this);
// Get rid of perspectives. This will close the views
for (PerspectiveList::iterator itr = perspList.Begin(); itr
!= perspList.End(); ++itr)
{
Perspective::Pointer perspective = *itr;
window->FirePerspectiveClosed(thisPage, perspective->GetDesc());
//perspective->Dispose();
}
perspList = PerspectiveList();
// Get rid of editor presentation.
//editorPresentation->Dispose();
// Get rid of composite.
//composite.dispose();
//navigationHistory.dispose();
//stickyViewMan.clear();
// if (tracker != 0)
// {
// tracker.close();
// }
// // if we're destroying a window in a non-shutdown situation then we should
// // clean up the working set we made.
// if (!window->GetWorkbench()->IsClosing())
// {
// if (aggregateWorkingSet != 0)
// {
// PlatformUI.getWorkbench().getWorkingSetManager().removeWorkingSet(
// aggregateWorkingSet);
// }
// }
}
partBeingActivated = nullptr;
pendingDisposals.clear();
stickyViewMan = nullptr;
delete viewFactory;
delete editorPresentation;
delete editorMgr;
delete activationList;
deferredActivePersp = nullptr;
dirtyPerspectives.clear();
delete selectionService;
partList.reset();
}
// decrement reference count again, without explicit deletion
this->UnRegister(false);
}
void WorkbenchPage::DisposePerspective(Perspective::Pointer persp, bool notify)
{
// Get rid of perspective.
perspList.Remove(persp);
if (notify)
{
IWorkbenchPage::Pointer thisPage(this);
window->FirePerspectiveClosed(thisPage, persp->GetDesc());
}
//persp->Dispose();
stickyViewMan->Remove(persp->GetDesc()->GetId());
}
Perspective::Pointer WorkbenchPage::FindPerspective(
IPerspectiveDescriptor::Pointer desc)
{
for (PerspectiveList::iterator itr = perspList.Begin(); itr
!= perspList.End(); ++itr)
{
Perspective::Pointer mgr = *itr;
if (desc->GetId() == mgr->GetDesc()->GetId())
{
return mgr;
}
}
return Perspective::Pointer(nullptr);
}
IViewPart::Pointer WorkbenchPage::FindView(const QString& id)
{
IViewReference::Pointer ref = this->FindViewReference(id);
if (ref == 0)
{
return IViewPart::Pointer(nullptr);
}
return ref->GetView(true);
}
IViewReference::Pointer WorkbenchPage::FindViewReference(
const QString& viewId)
{
return this->FindViewReference(viewId, "");
}
IViewReference::Pointer WorkbenchPage::FindViewReference(
const QString& viewId, const QString& secondaryId)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return IViewReference::Pointer(nullptr);
}
return persp->FindView(viewId, secondaryId);
}
IEditorPart::Pointer WorkbenchPage::GetActiveEditor()
{
return partList->GetActiveEditor();
}
IEditorReference::Pointer WorkbenchPage::GetActiveEditorReference()
{
return partList->GetActiveEditorReference();
}
IWorkbenchPart::Pointer WorkbenchPage::GetActivePart()
{
return partList->GetActivePart();
}
IWorkbenchPartReference::Pointer WorkbenchPage::GetActivePartReference()
{
return partList->GetActivePartReference();
}
Perspective::Pointer WorkbenchPage::GetActivePerspective()
{
return perspList.GetActive();
}
QWidget* WorkbenchPage::GetClientComposite()
{
return composite;
}
EditorManager* WorkbenchPage::GetEditorManager()
{
return editorMgr;
}
PerspectiveHelper* WorkbenchPage::GetPerspectivePresentation()
{
if (this->GetActivePerspective() != 0)
{
return this->GetActivePerspective()->GetPresentation();
}
return nullptr;
}
bool WorkbenchPage::HasView(const QString& perspectiveId, const QString& viewId)
{
PerspectiveList::PerspectiveListType list = perspList.GetSortedPerspectives();
for ( PerspectiveList::PerspectiveListType::iterator it = list.begin(); it!=list.end(); it++)
{
SmartPointer<Perspective> p = *it;
if (p->GetDesc()->GetId() == perspectiveId)
{
if (p->ContainsView(viewId))
{
return true;
}
}
}
return false;
}
/**
* Answer the editor presentation.
*/
EditorAreaHelper* WorkbenchPage::GetEditorPresentation()
{
return editorPresentation;
}
QList<IEditorPart::Pointer> WorkbenchPage::GetEditors()
{
QList<IEditorReference::Pointer> refs = this->GetEditorReferences();
QList<IEditorPart::Pointer> result;
//Display d = getWorkbenchWindow().getShell().getDisplay();
//Must be backward compatible.
// d.syncExec(new Runnable()
// {
// public void WorkbenchPage::run()
// {
for (QList<IEditorReference::Pointer>::iterator iter = refs.begin(); iter
!= refs.end(); ++iter)
{
IEditorPart::Pointer part = (*iter)->GetEditor(true);
if (part != 0)
{
result.push_back(part);
}
}
// }
// });
return result;
}
QList<IEditorPart::Pointer> WorkbenchPage::GetDirtyEditors()
{
return this->GetEditorManager()->GetDirtyEditors();
}
QList<ISaveablePart::Pointer> WorkbenchPage::GetDirtyParts()
{
QList<ISaveablePart::Pointer> result;
QList<IWorkbenchPartReference::Pointer> allParts = this->GetAllParts();
for (int i = 0; i < allParts.size(); i++)
{
IWorkbenchPartReference::Pointer reference = allParts[i];
IWorkbenchPart::Pointer part = reference->GetPart(false);
if (part != 0 && part.Cast<ISaveablePart> () != 0)
{
ISaveablePart::Pointer saveable = part.Cast<ISaveablePart> ();
if (saveable->IsDirty())
{
result.push_back(saveable);
}
}
}
return result;
}
IEditorPart::Pointer WorkbenchPage::FindEditor(IEditorInput::Pointer input)
{
return this->GetEditorManager()->FindEditor(input);
}
QList<IEditorReference::Pointer> WorkbenchPage::FindEditors(
IEditorInput::Pointer input, const QString& editorId, int matchFlags)
{
return this->GetEditorManager()->FindEditors(input, editorId, matchFlags);
}
QList<IEditorReference::Pointer> WorkbenchPage::GetEditorReferences()
{
return editorPresentation->GetEditors();
}
IAdaptable* WorkbenchPage::GetInput()
{
return input;
}
QString WorkbenchPage::GetLabel()
{
QString label = "<Unknown label>";
// IWorkbenchAdapter adapter = (IWorkbenchAdapter) Util.getAdapter(input,
// IWorkbenchAdapter.class);
// if (adapter != 0)
// {
// label = adapter.getLabel(input);
// }
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
label = label + " - " + persp->GetDesc()->GetLabel();
}
else if (deferredActivePersp != 0)
{
label = label + " - " + deferredActivePersp->GetLabel();
}
return label;
}
IPerspectiveDescriptor::Pointer WorkbenchPage::GetPerspective()
{
if (deferredActivePersp != 0)
{
return deferredActivePersp;
}
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
return persp->GetDesc();
}
else
{
return IPerspectiveDescriptor::Pointer(nullptr);
}
}
ISelection::ConstPointer WorkbenchPage::GetSelection() const
{
return selectionService->GetSelection();
}
ISelection::ConstPointer WorkbenchPage::GetSelection(const QString& partId)
{
return selectionService->GetSelection(partId);
}
//ISelectionService::SelectionEvents& WorkbenchPage::GetSelectionEvents(const QString& partId)
//{
// return selectionService->GetSelectionEvents(partId);
//}
ViewFactory* WorkbenchPage::GetViewFactory()
{
if (viewFactory == nullptr)
{
viewFactory = new ViewFactory(this,
WorkbenchPlugin::GetDefault()->GetViewRegistry());
}
return viewFactory;
}
QList<IViewReference::Pointer> WorkbenchPage::GetViewReferences()
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
return persp->GetViewReferences();
}
else
{
return QList<IViewReference::Pointer>();
}
}
QList<IViewPart::Pointer> WorkbenchPage::GetViews()
{
return this->GetViews(Perspective::Pointer(nullptr), true);
}
QList<IViewPart::Pointer> WorkbenchPage::GetViews(
Perspective::Pointer persp, bool restore)
{
if (persp == 0)
{
persp = this->GetActivePerspective();
}
QList<IViewPart::Pointer> parts;
if (persp != 0)
{
QList<IViewReference::Pointer> refs = persp->GetViewReferences();
for (int i = 0; i < refs.size(); i++)
{
IViewPart::Pointer part = refs[i]->GetPart(restore).Cast<IViewPart> ();
if (part != 0)
{
parts.push_back(part);
}
}
}
return parts;
}
IWorkbenchWindow::Pointer WorkbenchPage::GetWorkbenchWindow() const
{
return IWorkbenchWindow::Pointer(window);
}
void WorkbenchPage::HideView(IViewReference::Pointer ref)
{
// Sanity check.
if (ref == 0)
{
return;
}
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return;
}
bool promptedForSave = false;
IViewPart::Pointer view = ref->GetView(false);
if (view != 0)
{
if (!this->CertifyPart(view))
{
return;
}
// Confirm.
if (view.Cast<ISaveablePart> () != 0)
{
ISaveablePart::Pointer saveable = view.Cast<ISaveablePart> ();
if (saveable->IsSaveOnCloseNeeded())
{
IWorkbenchWindow::Pointer window =
view->GetSite()->GetWorkbenchWindow();
QList<IWorkbenchPart::Pointer> partsToSave;
partsToSave.push_back(view);
bool success = EditorManager::SaveAll(partsToSave, true, true, false,
window);
if (!success)
{
// the user cancelled.
return;
}
promptedForSave = true;
}
}
}
int refCount = this->GetViewFactory()->GetReferenceCount(ref);
SaveablesList* saveablesList = nullptr;
SaveablesList::PostCloseInfo::Pointer postCloseInfo;
if (refCount == 1)
{
IWorkbenchPart::Pointer actualPart = ref->GetPart(false);
if (actualPart != 0)
{
saveablesList = dynamic_cast<SaveablesList*>(
actualPart->GetSite()->GetService<ISaveablesLifecycleListener>());
QList<IWorkbenchPart::Pointer> partsToClose;
partsToClose.push_back(actualPart);
postCloseInfo = saveablesList->PreCloseParts(partsToClose,
!promptedForSave, this->GetWorkbenchWindow());
if (postCloseInfo == 0)
{
// cancel
return;
}
}
}
IWorkbenchPage::Pointer thisPage(this);
// Notify interested listeners before the hide
window->FirePerspectiveChanged(thisPage, persp->GetDesc(), ref,
CHANGE_VIEW_HIDE);
PartPane::Pointer pane = this->GetPane(ref.Cast<IWorkbenchPartReference> ());
pane->SetInLayout(false);
this->UpdateActivePart();
if (saveablesList != nullptr)
{
saveablesList->PostClose(postCloseInfo);
}
// Hide the part.
persp->HideView(ref);
// Notify interested listeners after the hide
window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
CHANGE_VIEW_HIDE);
}
void WorkbenchPage::RefreshActiveView()
{
this->UpdateActivePart();
}
void WorkbenchPage::HideView(IViewPart::Pointer view)
{
this->HideView(this->GetReference(view).Cast<IViewReference> ());
}
void WorkbenchPage::Init(WorkbenchWindow* w, const QString& layoutID,
IAdaptable* input, bool openExtras)
{
// Save args.
this->window = w;
this->input = input;
this->composite = nullptr;
this->viewFactory = nullptr;
this->activationList = new ActivationList(this);
this->selectionService = new PageSelectionService(this);
this->partList.reset(new WorkbenchPagePartList(this->selectionService));
this->stickyViewMan = new StickyViewManager(this);
//actionSets = new ActionSetManager(w);
deferCount = 0;
// Create presentation.
this->CreateClientComposite();
editorPresentation = new EditorAreaHelper(this);
editorMgr = new EditorManager(WorkbenchWindow::Pointer(window),
WorkbenchPage::Pointer(this), editorPresentation);
//TODO WorkbenchPage perspective reorder listener?
// // add this page as a client to be notified when the UI has re-ordered perspectives
// // so that the order can be properly maintained in the receiver.
// // E.g. a UI might support drag-and-drop and will need to make this known to ensure
// // #saveState and #restoreState do not lose this re-ordering
// w.addPerspectiveReorderListener(new IReorderListener()
// {
// public void WorkbenchPage::reorder(Object perspective, int newLoc)
// {
// perspList.reorder((IPerspectiveDescriptor)perspective, newLoc);
// }
// });
if (openExtras)
{
this->OpenPerspectiveExtras();
}
// Get perspective descriptor.
if (layoutID != "")
{
PerspectiveDescriptor::Pointer
desc =
WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry()->FindPerspectiveWithId(
layoutID).Cast<PerspectiveDescriptor> ();
if (desc == 0)
{
throw WorkbenchException("Unable to create Perspective " + layoutID
+ ". There is no corresponding perspective extension.");
}
Perspective::Pointer persp = this->FindPerspective(desc);
if (persp == 0)
{
persp = this->CreatePerspective(desc, true);
}
perspList.SetActive(persp);
window->FirePerspectiveActivated(IWorkbenchPage::Pointer(this), desc);
}
//this->GetExtensionTracker()->RegisterHandler(perspectiveChangeHandler,
// ExtensionTracker::CreateExtensionPointFilter(
// GetPerspectiveExtensionPoint()));
}
void WorkbenchPage::OpenPerspectiveExtras()
{
//TODO WorkbenchPage perspectice extras
QString extras = ""; //PrefUtil.getAPIPreferenceStore().getString(
// IWorkbenchPreferenceConstants.PERSPECTIVE_BAR_EXTRAS);
QList<IPerspectiveDescriptor::Pointer> descs;
- foreach (QString id, extras.split(", ", QString::SkipEmptyParts))
+ foreach (QString id, extras.split(", ", Qt::SkipEmptyParts))
{
if (id.trimmed().isEmpty()) continue;
IPerspectiveDescriptor::Pointer desc =
WorkbenchPlugin::GetDefault()->GetPerspectiveRegistry()->FindPerspectiveWithId(id);
if (desc != 0)
{
descs.push_back(desc);
}
}
// HACK: The perspective switcher currently adds the button for a new perspective to the beginning of the list.
// So, we process the extra perspectives in reverse order here to have their buttons appear in the order declared.
for (int i = (int) descs.size(); --i >= 0;)
{
PerspectiveDescriptor::Pointer desc =
descs[i].Cast<PerspectiveDescriptor> ();
if (this->FindPerspective(desc) == 0)
{
this->CreatePerspective(desc, true);
}
}
}
bool WorkbenchPage::IsPartVisible(IWorkbenchPart::Pointer part)
{
PartPane::Pointer pane = this->GetPane(part);
return pane != 0 && pane->GetVisible();
}
bool WorkbenchPage::IsEditorAreaVisible()
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return false;
}
return persp->IsEditorAreaVisible();
}
bool WorkbenchPage::IsFastView(IViewReference::Pointer /*ref*/)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
//return persp->IsFastView(ref);
return false;
}
else
{
return false;
}
}
bool WorkbenchPage::IsCloseable(IViewReference::Pointer ref)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
return persp->IsCloseable(ref);
}
return false;
}
bool WorkbenchPage::IsMoveable(IViewReference::Pointer ref)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
return persp->IsMoveable(ref);
}
return false;
}
bool WorkbenchPage::IsFixedLayout()
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
return persp->IsFixedLayout();
}
else
{
return false;
}
}
bool WorkbenchPage::IsSaveNeeded()
{
return this->GetEditorManager()->IsSaveAllNeeded();
}
void WorkbenchPage::OnActivate()
{
Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetVisible(composite, true);
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
persp->OnActivate();
this->UpdateVisibility(Perspective::Pointer(nullptr), persp);
}
}
void WorkbenchPage::OnDeactivate()
{
this->MakeActiveEditor(IEditorReference::Pointer(nullptr));
this->MakeActive(IWorkbenchPartReference::Pointer(nullptr));
if (this->GetActivePerspective() != 0)
{
this->GetActivePerspective()->OnDeactivate();
}
Tweaklets::Get(GuiWidgetsTweaklet::KEY)->SetVisible(composite, false);
}
void WorkbenchPage::ReuseEditor(IReusableEditor::Pointer editor,
IEditorInput::Pointer input)
{
// Rather than calling editor.setInput on the editor directly, we do it through the part reference.
// This case lets us detect badly behaved editors that are not firing a PROP_INPUT event in response
// to the input change... but if all editors obeyed their API contract, the "else" branch would be
// sufficient.
IWorkbenchPartReference::Pointer ref = this->GetReference(editor);
if (ref.Cast<EditorReference> () != 0)
{
EditorReference::Pointer editorRef = ref.Cast<EditorReference> ();
editorRef->SetInput(input);
}
else
{
editor->SetInput(input);
}
//navigationHistory.markEditor(editor);
}
IEditorPart::Pointer WorkbenchPage::OpenEditor(IEditorInput::Pointer input,
const QString& editorID)
{
return this->OpenEditor(input, editorID, true, MATCH_INPUT);
}
IEditorPart::Pointer WorkbenchPage::OpenEditor(IEditorInput::Pointer input,
const QString& editorID, bool activate)
{
return this->OpenEditor(input, editorID, activate, MATCH_INPUT);
}
IEditorPart::Pointer WorkbenchPage::OpenEditor(
const IEditorInput::Pointer input, const QString& editorID,
bool activate, int matchFlags)
{
return this->OpenEditor(input, editorID, activate, matchFlags,
IMemento::Pointer(nullptr));
}
IEditorPart::Pointer WorkbenchPage::OpenEditor(
const IEditorInput::Pointer input, const QString& editorID,
bool activate, int matchFlags, IMemento::Pointer editorState)
{
if (input == 0 || editorID == "")
{
throw Poco::InvalidArgumentException();
}
// BusyIndicator.showWhile(window.getWorkbench().getDisplay(),
// new Runnable()
// {
// public void WorkbenchPage::run()
// {
return this->BusyOpenEditor(input, editorID, activate, matchFlags,
editorState);
}
IEditorPart::Pointer WorkbenchPage::OpenEditorFromDescriptor(
IEditorInput::Pointer input, IEditorDescriptor::Pointer editorDescriptor,
bool activate, IMemento::Pointer editorState)
{
if (input == 0 || !(editorDescriptor.Cast<EditorDescriptor> () != 0))
{
throw Poco::InvalidArgumentException();
}
// BusyIndicator.showWhile(window.getWorkbench().getDisplay(),
// new Runnable()
// {
// public void WorkbenchPage::run()
// {
return this->BusyOpenEditorFromDescriptor(input, editorDescriptor.Cast<
EditorDescriptor> (), activate, editorState);
// }
// });
}
IEditorPart::Pointer WorkbenchPage::BusyOpenEditor(IEditorInput::Pointer input,
const QString& editorID, bool activate, int matchFlags,
IMemento::Pointer editorState)
{
Workbench* workbench =
this->GetWorkbenchWindow().Cast<WorkbenchWindow> ()->GetWorkbenchImpl();
workbench->LargeUpdateStart();
IEditorPart::Pointer result;
try
{
result = this->BusyOpenEditorBatched(input, editorID, activate, matchFlags,
editorState);
} catch (std::exception& e)
{
workbench->LargeUpdateEnd();
throw e;
}
workbench->LargeUpdateEnd();
return result;
}
IEditorPart::Pointer WorkbenchPage::BusyOpenEditorFromDescriptor(
IEditorInput::Pointer input, EditorDescriptor::Pointer editorDescriptor,
bool activate, IMemento::Pointer editorState)
{
Workbench* workbench =
this->GetWorkbenchWindow().Cast<WorkbenchWindow> ()->GetWorkbenchImpl();
workbench->LargeUpdateStart();
IEditorPart::Pointer result;
try
{
result = this->BusyOpenEditorFromDescriptorBatched(input, editorDescriptor,
activate, editorState);
} catch (std::exception& e)
{
workbench->LargeUpdateEnd();
throw e;
}
workbench->LargeUpdateEnd();
return result;
}
IEditorPart::Pointer WorkbenchPage::BusyOpenEditorBatched(
IEditorInput::Pointer input, const QString& editorID, bool activate,
int matchFlags, IMemento::Pointer editorState)
{
// If an editor already exists for the input, use it.
IEditorPart::Pointer editor;
// Reuse an existing open editor, unless we are in "new editor tab management" mode
editor = this->GetEditorManager()->FindEditor(editorID, input, matchFlags);
if (editor != 0)
{
if (IEditorRegistry::SYSTEM_EXTERNAL_EDITOR_ID == editorID)
{
if (editor->IsDirty())
{
QMessageBox::StandardButton saveFile = QMessageBox::question(
this->GetWorkbenchWindow()->GetShell()->GetControl(),
"Save", "\"" + input->GetName() + "\" is opened and has unsaved changes. Do you want to save it?",
QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel, QMessageBox::Cancel);
if (saveFile == QMessageBox::Yes)
{
// try
// {
IEditorPart::Pointer editorToSave = editor;
// getWorkbenchWindow().run(false, false,
// new IRunnableWithProgress()
// {
// public void WorkbenchPage::run(IProgressMonitor monitor)
// throws InvocationTargetException,
// InterruptedException
// {
//TODO progress monitor
editorToSave->DoSave();//monitor);
// }
// });
// }
// catch (InvocationTargetException& e)
// {
// throw(RuntimeException) e->GetTargetException();
// }
// catch (InterruptedException& e)
// {
// return 0;
// }
}
else if (saveFile == QMessageBox::Cancel)
{
return IEditorPart::Pointer(nullptr);
}
}
}
else
{
// // do the IShowEditorInput notification before showing the editor
// // to reduce flicker
// if (editor.Cast<IShowEditorInput> () != 0)
// {
// ((IShowEditorInput) editor).showEditorInput(input);
// }
this->ShowEditor(activate, editor);
return editor;
}
}
// Otherwise, create a new one. This may cause the new editor to
// become the visible (i.e top) editor.
IEditorReference::Pointer ref = this->GetEditorManager()->OpenEditor(
editorID, input, true, editorState);
if (ref != 0)
{
editor = ref->GetEditor(true);
}
if (editor != 0)
{
this->SetEditorAreaVisible(true);
if (activate)
{
this->Activate(editor);
}
else
{
this->BringToTop(editor);
}
IWorkbenchPage::Pointer thisPage(this);
window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
CHANGE_EDITOR_OPEN);
window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
CHANGE_EDITOR_OPEN);
}
return editor;
}
/*
* Added to fix Bug 178235 [EditorMgmt] DBCS 3.3 - Cannot open file with external program.
* See openEditorFromDescriptor().
*/
IEditorPart::Pointer WorkbenchPage::BusyOpenEditorFromDescriptorBatched(
IEditorInput::Pointer input, EditorDescriptor::Pointer editorDescriptor,
bool activate, IMemento::Pointer editorState)
{
IEditorPart::Pointer editor;
// Create a new one. This may cause the new editor to
// become the visible (i.e top) editor.
IEditorReference::Pointer ref;
ref = this->GetEditorManager()->OpenEditorFromDescriptor(editorDescriptor,
input, editorState);
if (ref != 0)
{
editor = ref->GetEditor(true);
}
if (editor != 0)
{
this->SetEditorAreaVisible(true);
if (activate)
{
this->Activate(editor);
}
else
{
this->BringToTop(editor);
}
IWorkbenchPage::Pointer thisPage(this);
window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
CHANGE_EDITOR_OPEN);
window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
CHANGE_EDITOR_OPEN);
}
return editor;
}
void WorkbenchPage::OpenEmptyTab()
{
IEditorPart::Pointer editor;
EditorReference::Pointer ref;
ref = this->GetEditorManager()->OpenEmptyTab().Cast<EditorReference> ();
if (ref != 0)
{
editor
= ref->GetEmptyEditor(
dynamic_cast<EditorRegistry*> (WorkbenchPlugin::GetDefault()->GetEditorRegistry())->FindEditor(
EditorRegistry::EMPTY_EDITOR_ID).Cast<EditorDescriptor> ());
}
if (editor != 0)
{
this->SetEditorAreaVisible(true);
this->Activate(editor);
IWorkbenchPage::Pointer thisPage(this);
window->FirePerspectiveChanged(thisPage, this->GetPerspective(), ref,
CHANGE_EDITOR_OPEN);
window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
CHANGE_EDITOR_OPEN);
}
}
void WorkbenchPage::ShowEditor(bool activate, IEditorPart::Pointer editor)
{
this->SetEditorAreaVisible(true);
if (activate)
{
//zoomOutIfNecessary(editor);
this->Activate(editor);
}
else
{
this->BringToTop(editor);
}
}
bool WorkbenchPage::IsEditorPinned(IEditorPart::Pointer editor)
{
WorkbenchPartReference::Pointer ref = this->GetReference(editor).Cast<
WorkbenchPartReference> ();
return ref != 0 && ref->IsPinned();
}
/**
* Removes an IPartListener from the part service.
*/
void WorkbenchPage::RemovePartListener(IPartListener* l)
{
partList->GetPartService()->RemovePartListener(l);
}
/**
* Implements IWorkbenchPage
*
* @see org.blueberry.ui.IWorkbenchPage#removePropertyChangeListener(IPropertyChangeListener)
* @since 2.0
* @deprecated individual views should store a working set if needed and
* register a property change listener directly with the
* working set manager to receive notification when the view
* working set is removed.
*/
// void WorkbenchPage::RemovePropertyChangeListener(IPropertyChangeListener listener) {
// propertyChangeListeners.remove(listener);
// }
void WorkbenchPage::RemoveSelectionListener(ISelectionListener* listener)
{
selectionService->RemoveSelectionListener(listener);
}
void WorkbenchPage::RemoveSelectionListener(const QString& partId,
ISelectionListener* listener)
{
selectionService->RemoveSelectionListener(partId, listener);
}
void WorkbenchPage::RemovePostSelectionListener(ISelectionListener* listener)
{
selectionService->RemovePostSelectionListener(listener);
}
void WorkbenchPage::RemovePostSelectionListener(const QString& partId,
ISelectionListener* listener)
{
selectionService->RemovePostSelectionListener(partId, listener);
}
void WorkbenchPage::RequestActivation(IWorkbenchPart::Pointer part)
{
// Sanity check.
if (!this->CertifyPart(part))
{
return;
}
// Real work.
this->SetActivePart(part);
}
/**
* Resets the layout for the perspective. The active part in the old layout
* is activated in the new layout for consistent user context.
*/
void WorkbenchPage::ResetPerspective()
{
// Run op in busy cursor.
// Use set redraw to eliminate the "flash" that can occur in the
// coolbar as the perspective is reset.
// ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
// try
// {
// mgr.getControl2().setRedraw(false);
// BusyIndicator.showWhile(0, new Runnable()
// {
// public void WorkbenchPage::run()
// {
this->BusyResetPerspective();
// }
// });
// }finally
// {
// mgr.getControl2().setRedraw(true);
// }
}
bool WorkbenchPage::RestoreState(IMemento::Pointer memento,
const IPerspectiveDescriptor::Pointer activeDescriptor)
{
// StartupThreading.runWithoutExceptions(new StartupRunnable()
// {
//
// public void WorkbenchPage::runWithException() throws Throwable
// {
this->DeferUpdates(true);
// }});
try
{
// Restore working set
QString pageName;
memento->GetString(WorkbenchConstants::TAG_LABEL, pageName);
// String label = 0; // debugging only
// if (UIStats.isDebugging(UIStats.RESTORE_WORKBENCH))
// {
// label = pageName == 0 ? "" : "::" + pageName; //$NON-NLS-1$ //$NON-NLS-2$
// }
try
{
//UIStats.start(UIStats.RESTORE_WORKBENCH, "WorkbenchPage" + label); //$NON-NLS-1$
// MultiStatus result =
// new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, NLS.bind(
// WorkbenchMessages.WorkbenchPage_unableToRestorePerspective,
// pageName), 0);
bool result = true;
// String workingSetName = memento .getString(
// IWorkbenchConstants.TAG_WORKING_SET);
// if (workingSetName != 0)
// {
// AbstractWorkingSetManager
// workingSetManager =
// (AbstractWorkingSetManager) getWorkbenchWindow() .getWorkbench().getWorkingSetManager();
// setWorkingSet(workingSetManager.getWorkingSet(workingSetName));
// }
//
// IMemento workingSetMem = memento .getChild(
// IWorkbenchConstants.TAG_WORKING_SETS);
// if (workingSetMem != 0)
// {
// QList<IMemento::Pointer> workingSetChildren =
// workingSetMem .getChildren(IWorkbenchConstants.TAG_WORKING_SET);
// List workingSetList = new ArrayList(workingSetChildren.length);
// for (int i = 0; i < workingSetChildren.length; i++)
// {
// IWorkingSet
// set =
// getWorkbenchWindow().getWorkbench() .getWorkingSetManager().getWorkingSet(
// workingSetChildren[i].getID());
// if (set != 0)
// {
// workingSetList.add(set);
// }
// }
//
// workingSets = (IWorkingSet[]) workingSetList .toArray(
// new IWorkingSet[workingSetList.size()]);
// }
//
// aggregateWorkingSetId = memento.getString(ATT_AGGREGATE_WORKING_SET_ID);
//
// IWorkingSet setWithId =
// window.getWorkbench().getWorkingSetManager().getWorkingSet(
// aggregateWorkingSetId);
//
// // check to see if the set has already been made and assign it if it has
// if (setWithId.Cast<AggregateWorkingSet> () != 0)
// {
// aggregateWorkingSet = (AggregateWorkingSet) setWithId;
// }
// Restore editor manager.
IMemento::Pointer childMem = memento->GetChild(
WorkbenchConstants::TAG_EDITORS);
//result.merge(getEditorManager().restoreState(childMem));
result &= this->GetEditorManager()->RestoreState(childMem);
childMem = memento->GetChild(WorkbenchConstants::TAG_VIEWS);
if (childMem)
{
//result.merge(getViewFactory().restoreState(childMem));
result &= this->GetViewFactory()->RestoreState(childMem);
}
// Get persp block.
childMem = memento->GetChild(WorkbenchConstants::TAG_PERSPECTIVES);
QString activePartID;
childMem->GetString(WorkbenchConstants::TAG_ACTIVE_PART, activePartID);
QString activePartSecondaryID;
if (!activePartID.isEmpty())
{
activePartSecondaryID = ViewFactory::ExtractSecondaryId(activePartID);
if (!activePartSecondaryID.isEmpty())
{
activePartID = ViewFactory::ExtractPrimaryId(activePartID);
}
}
QString activePerspectiveID;
childMem->GetString(WorkbenchConstants::TAG_ACTIVE_PERSPECTIVE,
activePerspectiveID);
// Restore perspectives.
QList<IMemento::Pointer> perspMems(childMem->GetChildren(
WorkbenchConstants::TAG_PERSPECTIVE));
Perspective::Pointer activePerspective;
for (int i = 0; i < perspMems.size(); i++)
{
IMemento::Pointer current = perspMems[i];
// StartupThreading
// .runWithoutExceptions(new StartupRunnable()
// {
//
// public void WorkbenchPage::runWithException() throws Throwable
// {
Perspective::Pointer persp(new Perspective(
PerspectiveDescriptor::Pointer(nullptr), WorkbenchPage::Pointer(this)));
//result.merge(persp.restoreState(current));
result &= persp->RestoreState(current);
IPerspectiveDescriptor::Pointer desc = persp->GetDesc();
if (desc == activeDescriptor)
{
activePerspective = persp;
}
else if ((activePerspective == 0) && desc->GetId()
== activePerspectiveID)
{
activePerspective = persp;
}
perspList.Add(persp);
window->FirePerspectiveOpened(WorkbenchPage::Pointer(this), desc);
// }
// });
}
bool restoreActivePerspective = false;
if (!activeDescriptor)
{
restoreActivePerspective = true;
}
else if (activePerspective && activePerspective->GetDesc()
== activeDescriptor)
{
restoreActivePerspective = true;
}
else
{
restoreActivePerspective = false;
activePerspective = this->CreatePerspective(activeDescriptor.Cast<
PerspectiveDescriptor> (), true);
if (activePerspective == 0)
{
// result .merge(
// new Status(IStatus.ERR, PlatformUI.PLUGIN_ID, 0, NLS.bind(
// WorkbenchMessages.Workbench_showPerspectiveError,
// activeDescriptor.getId()), 0));
result &= false;
}
}
perspList.SetActive(activePerspective);
// Make sure we have a valid perspective to work with,
// otherwise return.
activePerspective = perspList.GetActive();
if (activePerspective == 0)
{
activePerspective = perspList.GetNextActive();
perspList.SetActive(activePerspective);
}
if (activePerspective && restoreActivePerspective)
{
//result.merge(activePerspective.restoreState());
result &= activePerspective->RestoreState();
}
if (activePerspective)
{
Perspective::Pointer myPerspective = activePerspective;
QString myActivePartId = activePartID;
QString mySecondaryId = activePartSecondaryID;
// StartupThreading.runWithoutExceptions(new StartupRunnable()
// {
//
// public void WorkbenchPage::runWithException() throws Throwable
// {
window->FirePerspectiveActivated(WorkbenchPage::Pointer(this),
myPerspective->GetDesc());
// Restore active part.
if (!myActivePartId.isEmpty())
{
IWorkbenchPartReference::Pointer ref = myPerspective->FindView(
myActivePartId, mySecondaryId);
if (ref)
{
activationList->SetActive(ref);
}
}
// }});
}
// childMem = memento->GetChild(WorkbenchConstants::TAG_NAVIGATION_HISTORY);
// if (childMem)
// {
// navigationHistory.restoreState(childMem);
// }
// else if (GetActiveEditor())
// {
// navigationHistory.markEditor(getActiveEditor());
// }
//
// restore sticky view state
stickyViewMan->Restore(memento);
// QString blame = activeDescriptor == 0 ? pageName
// : activeDescriptor.getId();
// UIStats.end(UIStats.RESTORE_WORKBENCH, blame, "WorkbenchPage" + label); //$NON-NLS-1$
// StartupThreading.runWithoutExceptions(new StartupRunnable()
// {
// public void WorkbenchPage::runWithException() throws Throwable
// {
DeferUpdates(false);
// }
// });
return result;
} catch (...)
{
// QString blame = activeDescriptor == 0 ? pageName
// : activeDescriptor.getId();
// UIStats.end(UIStats.RESTORE_WORKBENCH, blame, "WorkbenchPage" + label); //$NON-NLS-1$
throw ;
}
}
catch (...)
{
// StartupThreading.runWithoutExceptions(new StartupRunnable()
// {
// public void WorkbenchPage::runWithException() throws Throwable
// {
DeferUpdates(false);
// }
// });
throw;
}
}
bool WorkbenchPage::SaveAllEditors(bool confirm)
{
return this->SaveAllEditors(confirm, false);
}
bool WorkbenchPage::SaveAllEditors(bool confirm, bool addNonPartSources)
{
return this->GetEditorManager()->SaveAll(confirm, false, addNonPartSources);
}
bool WorkbenchPage::SavePart(ISaveablePart::Pointer saveable,
IWorkbenchPart::Pointer part, bool confirm)
{
// Do not certify part do allow editors inside a multipageeditor to
// call this.
return this->GetEditorManager()->SavePart(saveable, part, confirm);
}
bool WorkbenchPage::SaveEditor(IEditorPart::Pointer editor, bool confirm)
{
return this->SavePart(editor, editor, confirm);
}
/**
* Saves the current perspective.
*/
void WorkbenchPage::SavePerspective()
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return;
}
// // Always unzoom.
// if (isZoomed())
// {
// zoomOut();
// }
persp->SaveDesc();
}
/**
* Saves the perspective.
*/
void WorkbenchPage::SavePerspectiveAs(IPerspectiveDescriptor::Pointer newDesc)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return;
}
IPerspectiveDescriptor::Pointer oldDesc = persp->GetDesc();
// // Always unzoom.
// if (isZoomed())
// {
// zoomOut();
// }
persp->SaveDescAs(newDesc);
window->FirePerspectiveSavedAs(IWorkbenchPage::Pointer(this), oldDesc, newDesc);
}
/**
* Save the state of the page.
*/
bool WorkbenchPage::SaveState(IMemento::Pointer memento)
{
// // We must unzoom to get correct layout.
// if (isZoomed())
// {
// zoomOut();
// }
// MultiStatus
// result =
// new MultiStatus(PlatformUI.PLUGIN_ID, IStatus.OK, NLS.bind(
// WorkbenchMessages.WorkbenchPage_unableToSavePerspective,
// getLabel()), 0);
bool result = true;
// Save editor manager.
IMemento::Pointer childMem = memento->CreateChild(WorkbenchConstants::TAG_EDITORS);
//result.merge(editorMgr.saveState(childMem));
result &= editorMgr->SaveState(childMem);
childMem = memento->CreateChild(WorkbenchConstants::TAG_VIEWS);
//result.merge(getViewFactory().saveState(childMem));
result &= this->GetViewFactory()->SaveState(childMem);
// Create persp block.
childMem = memento->CreateChild(WorkbenchConstants::TAG_PERSPECTIVES);
if (this->GetPerspective())
{
childMem->PutString(WorkbenchConstants::TAG_ACTIVE_PERSPECTIVE,
this->GetPerspective()->GetId());
}
if (this->GetActivePart() != 0)
{
if (this->GetActivePart().Cast<IViewPart> ())
{
IViewReference::Pointer ref = this->GetReference(this->GetActivePart()).Cast<IViewReference>();
if (ref)
{
childMem->PutString(WorkbenchConstants::TAG_ACTIVE_PART,
ViewFactory::GetKey(ref));
}
}
else
{
childMem->PutString(WorkbenchConstants::TAG_ACTIVE_PART,
this->GetActivePart()->GetSite()->GetId());
}
}
// Save each perspective in opened order
for (PerspectiveList::PerspectiveListType::iterator itr = perspList.Begin();
itr != perspList.End(); ++itr)
{
IMemento::Pointer gChildMem = childMem->CreateChild(
WorkbenchConstants::TAG_PERSPECTIVE);
//result.merge(persp.saveState(gChildMem));
result &= (*itr)->SaveState(gChildMem);
}
// // Save working set if set
// if (workingSet != 0)
// {
// memento.putString(IWorkbenchConstants.TAG_WORKING_SET,
// workingSet .getName());
// }
//
// IMemento workingSetMem = memento .createChild(
// IWorkbenchConstants.TAG_WORKING_SETS);
// for (int i = 0; i < workingSets.length; i++)
// {
// workingSetMem.createChild(IWorkbenchConstants.TAG_WORKING_SET,
// workingSets[i].getName());
// }
//
// if (aggregateWorkingSetId != 0)
// {
// memento.putString(ATT_AGGREGATE_WORKING_SET_ID, aggregateWorkingSetId);
// }
//
// navigationHistory.saveState(memento .createChild(
// IWorkbenchConstants.TAG_NAVIGATION_HISTORY));
//
// save the sticky activation state
stickyViewMan->Save(memento);
return result;
}
QString WorkbenchPage::GetId(IWorkbenchPart::Pointer part)
{
return this->GetId(this->GetReference(part));
}
QString WorkbenchPage::GetId(IWorkbenchPartReference::Pointer ref)
{
if (ref == 0)
{
return "0"; //$NON-NLS-1$
}
return ref->GetId();
}
void WorkbenchPage::SetActivePart(IWorkbenchPart::Pointer newPart)
{
// Optimize it.
if (this->GetActivePart() == newPart)
{
return;
}
if (partBeingActivated != 0)
{
if (partBeingActivated->GetPart(false) != newPart)
{
WorkbenchPlugin::Log(ctkRuntimeException(
QString("WARNING: Prevented recursive attempt to activate part ")
+ this->GetId(newPart)
+ " while still in the middle of activating part " + this->GetId(
partBeingActivated)));
}
return;
}
//No need to change the history if the active editor is becoming the
// active part
// String label = 0; // debugging only
// if (UIStats.isDebugging(UIStats.ACTIVATE_PART))
// {
// label = newPart != 0 ? newPart.getTitle() : "none"; //$NON-NLS-1$
// }
try
{
IWorkbenchPartReference::Pointer partref = this->GetReference(newPart);
IWorkbenchPartReference::Pointer realPartRef;
if (newPart != 0)
{
IWorkbenchPartSite::Pointer site = newPart->GetSite();
if (site.Cast<PartSite> () != 0)
{
realPartRef = site.Cast<PartSite> ()->GetPane()->GetPartReference();
}
}
partBeingActivated = realPartRef;
//UIStats.start(UIStats.ACTIVATE_PART, label);
// Notify perspective. It may deactivate fast view.
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
persp->PartActivated(newPart);
}
// Deactivate old part
IWorkbenchPart::Pointer oldPart = this->GetActivePart();
if (oldPart != 0)
{
this->DeactivatePart(oldPart);
}
// Set active part.
if (newPart != 0)
{
activationList->SetActive(newPart);
if (newPart.Cast<IEditorPart> () != 0)
{
this->MakeActiveEditor(realPartRef.Cast<IEditorReference> ());
}
}
this->ActivatePart(newPart);
actionSwitcher.UpdateActivePart(newPart);
partList->SetActivePart(partref);
}
catch (std::exception& e)
{
partBeingActivated = nullptr;
// Object blame = newPart == 0 ? (Object) this : newPart;
// UIStats.end(UIStats.ACTIVATE_PART, blame, label);
throw e;
}
partBeingActivated = nullptr;
}
void WorkbenchPage::SetEditorAreaVisible(bool showEditorArea)
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return;
}
if (showEditorArea == persp->IsEditorAreaVisible())
{
return;
}
// // If parts change always update zoom.
// if (isZoomed())
// {
// zoomOut();
// }
// Update editor area visibility.
IWorkbenchPage::Pointer thisPage(this);
if (showEditorArea)
{
persp->ShowEditorArea();
window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
CHANGE_EDITOR_AREA_SHOW);
}
else
{
persp->HideEditorArea();
this->UpdateActivePart();
window->FirePerspectiveChanged(thisPage, this->GetPerspective(),
CHANGE_EDITOR_AREA_HIDE);
}
}
/**
* Sets the layout of the page. Assumes the new perspective is not 0.
* Keeps the active part if possible. Updates the window menubar and
* toolbar if necessary.
*/
void WorkbenchPage::SetPerspective(Perspective::Pointer newPersp)
{
// Don't do anything if already active layout
Perspective::Pointer oldPersp = this->GetActivePerspective();
if (oldPersp == newPersp)
{
return;
}
window->LargeUpdateStart();
std::exception exc;
bool exceptionOccured = false;
try
{
IWorkbenchPage::Pointer thisPage(this);
if (oldPersp != 0)
{
// fire the pre-deactivate
window->FirePerspectivePreDeactivate(thisPage, oldPersp->GetDesc());
}
if (newPersp != 0)
{
bool status = newPersp->RestoreState();
if (!status)
{
QString title = "Restoring problems";
QString msg = "Unable to read workbench state.";
QMessageBox::critical(reinterpret_cast<QWidget*>(this->GetWorkbenchWindow()->GetShell()->GetControl()),
title, msg);
}
}
// Deactivate the old layout
if (oldPersp != 0)
{
oldPersp->OnDeactivate();
// Notify listeners of deactivation
window->FirePerspectiveDeactivated(thisPage, oldPersp->GetDesc());
}
// Activate the new layout
perspList.SetActive(newPersp);
if (newPersp != 0)
{
newPersp->OnActivate();
// Notify listeners of activation
window->FirePerspectiveActivated(thisPage, newPersp->GetDesc());
}
this->UpdateVisibility(oldPersp, newPersp);
// Update the window
//TODO action sets
//window->UpdateActionSets();
// Update sticky views
stickyViewMan->Update(oldPersp, newPersp);
}
catch (std::exception& e)
{
exc = e;
exceptionOccured = true;
}
window->LargeUpdateEnd();
if (newPersp == 0)
{
return;
}
IPerspectiveDescriptor::Pointer desc = newPersp->GetDesc();
if (desc == 0)
{
return;
}
if (dirtyPerspectives.erase(desc->GetId()))
{
this->SuggestReset();
}
if (exceptionOccured)
throw exc;
}
void WorkbenchPage::UpdateVisibility(Perspective::Pointer oldPersp,
Perspective::Pointer newPersp)
{
// Flag all parts in the old perspective
QList<IViewReference::Pointer> oldRefs;
if (oldPersp != 0)
{
oldRefs = oldPersp->GetViewReferences();
for (int i = 0; i < oldRefs.size(); i++)
{
PartPane::Pointer pane =
oldRefs[i].Cast<WorkbenchPartReference> ()->GetPane();
pane->SetInLayout(false);
}
}
PerspectiveHelper* pres = nullptr;
// Make parts in the new perspective visible
if (newPersp != 0)
{
pres = newPersp->GetPresentation();
QList<IViewReference::Pointer> newRefs =
newPersp->GetViewReferences();
for (int i = 0; i < newRefs.size(); i++)
{
WorkbenchPartReference::Pointer ref = newRefs[i].Cast<
WorkbenchPartReference> ();
PartPane::Pointer pane = ref->GetPane();
if (pres->IsPartVisible(ref))
{
activationList->BringToTop(ref);
}
pane->SetInLayout(true);
}
}
this->UpdateActivePart();
// Hide any parts in the old perspective that are no longer visible
for (int i = 0; i < oldRefs.size(); i++)
{
WorkbenchPartReference::Pointer ref = oldRefs[i].Cast<
WorkbenchPartReference> ();
PartPane::Pointer pane = ref->GetPane();
if (pres == nullptr || !pres->IsPartVisible(ref))
{
pane->SetVisible(false);
}
}
}
/**
* Sets the perspective.
*
* @param desc
* identifies the new perspective.
*/
void WorkbenchPage::SetPerspective(IPerspectiveDescriptor::Pointer desc)
{
if (this->GetPerspective() == desc)
{
return;
}
// // Going from multiple to single rows can make the coolbar
// // and its adjacent views appear jumpy as perspectives are
// // switched. Turn off redraw to help with this.
// ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
std::exception exc;
bool exceptionOccured = false;
try
{
//mgr.getControl2().setRedraw(false);
//getClientComposite().setRedraw(false);
// Run op in busy cursor.
// BusyIndicator.showWhile(0, new Runnable()
// {
// public void WorkbenchPage::run()
// {
this->BusySetPerspective(desc);
// }
// });
}
catch (std::exception& e)
{
exc = e;
exceptionOccured = true;
}
// getClientComposite().setRedraw(true);
// mgr.getControl2().setRedraw(true);
IWorkbenchPart::Pointer part = this->GetActivePart();
if (part != 0)
{
part->SetFocus();
}
if (exceptionOccured)
throw exc;
}
PartService* WorkbenchPage::GetPartService()
{
return dynamic_cast<PartService*> (partList->GetPartService());
}
void WorkbenchPage::ResetToolBarLayout()
{
// ICoolBarManager2 mgr = (ICoolBarManager2) window.getCoolBarManager2();
// mgr.resetItemOrder();
}
IViewPart::Pointer WorkbenchPage::ShowView(const QString& viewID)
{
return this->ShowView(viewID, "", VIEW_ACTIVATE);
}
IViewPart::Pointer WorkbenchPage::ShowView(const QString& viewID,
const QString& secondaryID, int mode)
{
if (secondaryID != "")
{
if (secondaryID.size() == 0 || secondaryID.indexOf(ViewFactory::ID_SEP) != -1)
{
throw ctkInvalidArgumentException(
"Illegal secondary id (cannot be empty or contain a colon)");
}
}
if (!this->CertifyMode(mode))
{
throw ctkInvalidArgumentException("Illegal view mode");
}
// Run op in busy cursor.
// BusyIndicator.showWhile(0, new Runnable()
// {
// public void WorkbenchPage::run()
// {
// try
// {
return this->BusyShowView(viewID, secondaryID, mode);
// } catch (PartInitException& e)
// {
// result = e;
// }
// }
// });
}
bool WorkbenchPage::CertifyMode(int mode)
{
if (mode == VIEW_ACTIVATE || mode == VIEW_VISIBLE || mode == VIEW_CREATE)
return true;
return false;
}
QList<IEditorReference::Pointer> WorkbenchPage::GetSortedEditors()
{
return activationList->GetEditors();
}
QList<IPerspectiveDescriptor::Pointer> WorkbenchPage::GetOpenPerspectives()
{
QList<Perspective::Pointer> opened = perspList.GetOpenedPerspectives();
QList<IPerspectiveDescriptor::Pointer> result;
for (QList<Perspective::Pointer>::iterator iter = opened.begin(); iter
!= opened.end(); ++iter)
{
result.push_back((*iter)->GetDesc());
}
return result;
}
QList<Perspective::Pointer> WorkbenchPage::GetOpenInternalPerspectives()
{
return perspList.GetOpenedPerspectives();
}
Perspective::Pointer WorkbenchPage::GetFirstPerspectiveWithView(
IViewPart::Pointer part)
{
QListIterator<Perspective::Pointer> iter(perspList.GetSortedPerspectives());
iter.toBack();
while(iter.hasPrevious())
{
Perspective::Pointer p = iter.previous();
if (p->ContainsView(part))
{
return p;
}
};
// we should never get here
return Perspective::Pointer(nullptr);
}
QList<IPerspectiveDescriptor::Pointer> WorkbenchPage::GetSortedPerspectives()
{
QList<Perspective::Pointer> sortedArray =
perspList.GetSortedPerspectives();
QList<IPerspectiveDescriptor::Pointer> result;
for (QList<Perspective::Pointer>::iterator iter = sortedArray.begin();
iter != sortedArray.end(); ++iter)
{
result.push_back((*iter)->GetDesc());
}
return result;
}
QList<IWorkbenchPartReference::Pointer> WorkbenchPage::GetSortedParts()
{
//return partList->GetParts(this->GetViewReferences());
return activationList->GetParts();
}
IWorkbenchPartReference::Pointer WorkbenchPage::GetReference(
IWorkbenchPart::Pointer part)
{
if (part == 0)
{
return IWorkbenchPartReference::Pointer(nullptr);
}
IWorkbenchPartSite::Pointer site = part->GetSite();
if (site.Cast<PartSite> () == 0)
{
return IWorkbenchPartReference::Pointer(nullptr);
}
PartSite::Pointer partSite = site.Cast<PartSite> ();
PartPane::Pointer pane = partSite->GetPane();
return partSite->GetPartReference();
}
// for dynamic UI
void WorkbenchPage::AddPerspective(Perspective::Pointer persp)
{
perspList.Add(persp);
IWorkbenchPage::Pointer thisPage(this);
window->FirePerspectiveOpened(thisPage, persp->GetDesc());
}
QList<IViewReference::Pointer> WorkbenchPage::GetViewReferenceStack(
IViewPart::Pointer part)
{
// Sanity check.
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0 || !this->CertifyPart(part))
{
return QList<IViewReference::Pointer>();
}
ILayoutContainer::Pointer container =
part->GetSite().Cast<PartSite> ()->GetPane()->GetContainer();
if (container.Cast<PartStack> () != 0)
{
PartStack::Pointer folder = container.Cast<PartStack> ();
QList<IViewReference::Pointer> list;
ILayoutContainer::ChildrenType children = folder->GetChildren();
for (ILayoutContainer::ChildrenType::iterator childIter =
children.begin(); childIter != children.end(); ++childIter)
{
LayoutPart::Pointer stackablePart = *childIter;
if (stackablePart.Cast<PartPane> () != 0)
{
IViewReference::Pointer view =
stackablePart.Cast<PartPane> ()->GetPartReference().Cast<
IViewReference> ();
if (view != 0)
{
list.push_back(view);
}
}
}
// sort the list by activation order (most recently activated first)
std::sort(list.begin(), list.end(), ActivationOrderPred(activationList));
return list;
}
QList<IViewReference::Pointer> result;
result.push_back(this->GetReference(part).Cast<IViewReference> ());
return result;
}
QList<IViewPart::Pointer> WorkbenchPage::GetViewStack(
IViewPart::Pointer part)
{
QList<IViewReference::Pointer> refStack = this->GetViewReferenceStack(
part);
QList<IViewPart::Pointer> result;
for (int i = 0; i < refStack.size(); i++)
{
IViewPart::Pointer next = refStack[i]->GetView(false);
if (next != 0)
{
result.push_back(next);
}
}
return result;
}
void WorkbenchPage::ResizeView(IViewPart::Pointer part, int width, int height)
{
SashInfo sashInfo;
PartPane::Pointer pane = part->GetSite().Cast<PartSite> ()->GetPane();
ILayoutContainer::Pointer container = pane->GetContainer();
LayoutTree::Pointer tree =
this->GetPerspectivePresentation()->GetLayout()->GetLayoutTree()->Find(
container.Cast<PartStack> ());
// retrieve our layout sashes from the layout tree
this->FindSashParts(tree, pane->FindSashes(), sashInfo);
// first set the width
int deltaWidth = width - pane->GetBounds().width();
if (sashInfo.right != 0)
{
QRect rightBounds = sashInfo.rightNode->GetBounds();
// set the new ratio
sashInfo.right->SetRatio(static_cast<float>((deltaWidth + sashInfo.right->GetBounds().x())
- rightBounds.x()) / rightBounds.width());
// complete the resize
sashInfo.rightNode->SetBounds(rightBounds);
}
else if (sashInfo.left != 0)
{
QRect leftBounds = sashInfo.leftNode->GetBounds();
// set the ratio
sashInfo.left->SetRatio(static_cast<float>((sashInfo.left->GetBounds().x() - deltaWidth)
- leftBounds.x()) / leftBounds.width());
// complete the resize
sashInfo.leftNode->SetBounds(sashInfo.leftNode->GetBounds());
}
// next set the height
int deltaHeight = height - pane->GetBounds().height();
if (sashInfo.bottom != 0)
{
QRect bottomBounds = sashInfo.bottomNode->GetBounds();
// set the new ratio
sashInfo.bottom->SetRatio(static_cast<float>((deltaHeight + sashInfo.bottom->GetBounds().y())
- bottomBounds.y()) / bottomBounds.height());
// complete the resize
sashInfo.bottomNode->SetBounds(bottomBounds);
}
else if (sashInfo.top != 0)
{
QRect topBounds = sashInfo.topNode->GetBounds();
// set the ratio
sashInfo.top->SetRatio(static_cast<float>((sashInfo.top->GetBounds().y() - deltaHeight)
- topBounds.y()) / topBounds.height());
// complete the resize
sashInfo.topNode->SetBounds(topBounds);
}
}
void WorkbenchPage::FindSashParts(LayoutTree::Pointer tree,
const PartPane::Sashes& sashes, SashInfo& info)
{
LayoutTree::Pointer parent(tree->GetParent());
if (parent == 0)
{
return;
}
if (parent->part.Cast<LayoutPartSash> () != 0)
{
// get the layout part sash from this tree node
LayoutPartSash::Pointer sash = parent->part.Cast<LayoutPartSash> ();
// make sure it has a sash control
QWidget* control = sash->GetControl();
if (control != nullptr)
{
// check for a vertical sash
if (sash->IsVertical())
{
if (sashes.left == control)
{
info.left = sash;
info.leftNode = parent->FindSash(sash);
}
else if (sashes.right == control)
{
info.right = sash;
info.rightNode = parent->FindSash(sash);
}
}
// check for a horizontal sash
else
{
if (sashes.top == control)
{
info.top = sash;
info.topNode = parent->FindSash(sash);
}
else if (sashes.bottom == control)
{
info.bottom = sash;
info.bottomNode = parent->FindSash(sash);
}
}
}
}
// recursive call to continue up the tree
this->FindSashParts(parent, sashes, info);
}
QList<IWorkbenchPartReference::Pointer> WorkbenchPage::GetAllParts()
{
QList<IViewReference::Pointer> views = this->GetViewFactory()->GetViews();
QList<IEditorReference::Pointer> editors = this->GetEditorReferences();
QList<IWorkbenchPartReference::Pointer> result;
for (int i = 0; i < views.size(); i++)
{
result.push_back(views[i]);
}
for (QList<IEditorReference::Pointer>::iterator iter = editors.begin(); iter
!= editors.end(); ++iter)
{
result.push_back(*iter);
}
return result;
}
QList<IWorkbenchPartReference::Pointer> WorkbenchPage::GetOpenParts()
{
QList<IWorkbenchPartReference::Pointer> refs = this->GetAllParts();
QList<IWorkbenchPartReference::Pointer> result;
for (int i = 0; i < refs.size(); i++)
{
IWorkbenchPartReference::Pointer reference = refs[i];
IWorkbenchPart::Pointer part = reference->GetPart(false);
if (part != 0)
{
result.push_back(reference);
}
}
return result;
}
void WorkbenchPage::TestInvariants()
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp != 0)
{
persp->TestInvariants();
// When we have widgets, ensure that there is no situation where the editor area is visible
// and the perspective doesn't want an editor area.
if (this->GetClientComposite()
&& editorPresentation->GetLayoutPart()->IsVisible())
{
poco_assert(persp->IsEditorAreaVisible());
}
}
}
IExtensionTracker* WorkbenchPage::GetExtensionTracker() const
{
if (tracker.isNull())
{
tracker.reset(new UIExtensionTracker(GetWorkbenchWindow()->GetWorkbench()->GetDisplay()));
}
return tracker.data();
}
/*
* (non-Javadoc)
*
* @see org.blueberry.ui.IWorkbenchPage#getPerspectiveShortcuts()
*/
QList<QString> WorkbenchPage::GetPerspectiveShortcuts()
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return QList<QString>();
}
return persp->GetPerspectiveShortcuts();
}
QList<QString> WorkbenchPage::GetShowViewShortcuts()
{
Perspective::Pointer persp = this->GetActivePerspective();
if (persp == 0)
{
return QList<QString>();
}
return persp->GetShowViewShortcuts();
}
void WorkbenchPage::SuggestReset()
{
IWorkbench* workbench = this->GetWorkbenchWindow()->GetWorkbench();
// workbench.getDisplay().asyncExec(new Runnable()
// {
// public void WorkbenchPage::run()
// {
Shell::Pointer parentShell;
IWorkbenchWindow::Pointer window = workbench->GetActiveWorkbenchWindow();
if (window == 0)
{
if (workbench->GetWorkbenchWindowCount() == 0)
{
return;
}
window = workbench->GetWorkbenchWindows()[0];
}
parentShell = window->GetShell();
if (QMessageBox::question(parentShell.IsNull() ? nullptr : reinterpret_cast<QWidget*>(parentShell->GetControl()),
"Reset Perspective?",
"Changes to installed plug-ins have affected this perspective. Would you like to reset this perspective to accept these changes?") ==
QMessageBox::Yes)
{
IWorkbenchPage::Pointer page = window->GetActivePage();
if (page == 0)
{
return;
}
page->ResetPerspective();
}
// }
// });
}
bool WorkbenchPage::IsPartVisible(
IWorkbenchPartReference::Pointer reference)
{
IWorkbenchPart::Pointer part = reference->GetPart(false);
// Can't be visible if it isn't created yet
if (part == 0)
{
return false;
}
return this->IsPartVisible(part);
}
}
diff --git a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
index 790bb57380..30fe80c3fd 100644
--- a/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
+++ b/Plugins/org.blueberry.ui.qt/src/model/berryViewTreeModel.cpp
@@ -1,460 +1,460 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "berryViewTreeModel.h"
#include "berryIViewRegistry.h"
#include "berryIViewCategory.h"
#include "berryIWorkbench.h"
#include "berryIWorkbenchWindow.h"
#include "berryIWorkbenchPage.h"
#include "internal/intro/berryIntroConstants.h"
#include "internal/berryKeywordRegistry.h"
#include <QIcon>
#include <QBrush>
namespace berry {
// --------------------------- Tree Item Classes ---------------------------
struct ViewTreeItem;
bool CompareViewTreeItem(ViewTreeItem* item1, ViewTreeItem* item2);
struct ViewTreeItem
{
ViewTreeItem(ViewTreeModel* model)
: m_parent(nullptr)
, m_model(model)
{}
virtual ~ViewTreeItem()
{
QList<ViewTreeItem*> children = m_children;
if (m_parent) m_parent->removeChild(this);
qDeleteAll(children);
}
virtual QVariant data(int role)
{
if (role == ViewTreeModel::Keywords)
{
if (m_keywordCache.isEmpty())
{
m_keywordCache = QStringList(keywordLabels().toList());
}
return m_keywordCache;
}
return QVariant();
}
virtual Qt::ItemFlags flags() const
{
return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
virtual QSet<QString> keywordLabels() const
{
return QSet<QString>();
}
void appendChild(ViewTreeItem* child)
{
m_children.push_back(child);
child->m_parent = this;
qSort(m_children.begin(), m_children.end(), CompareViewTreeItem);
}
void removeChild(ViewTreeItem* child)
{
m_children.removeAll(child);
}
QList<ViewTreeItem*> takeChildren()
{
QList<ViewTreeItem*> children = m_children;
m_children.clear();
return children;
}
ViewTreeItem* childItem(int row) const
{
if (row < 0 || row >= m_children.size()) return nullptr;
return m_children.at(row);
}
ViewTreeItem* parentItem() const
{
return m_parent;
}
int childCount() const
{
return m_children.size();
}
int row() const
{
if (m_parent) return m_parent->rowIndex(this);
return 0;
}
int rowIndex(const ViewTreeItem* child) const
{
return m_children.indexOf(const_cast<ViewTreeItem*>(child));
}
QList<ViewTreeItem*> m_children;
ViewTreeItem* m_parent;
ViewTreeModel* m_model;
private:
QStringList m_keywordCache;
};
bool CompareViewTreeItem(ViewTreeItem* item1, ViewTreeItem* item2)
{
return item1->data(Qt::DisplayRole).toString() < item2->data(Qt::DisplayRole).toString();
}
struct RootTreeItem : ViewTreeItem
{
RootTreeItem(ViewTreeModel* model) : ViewTreeItem(model) {}
QVariant data(int /*role*/) override { return QVariant(); }
};
struct DescriptorTreeItem : ViewTreeItem
{
DescriptorTreeItem(ViewTreeModel* model, IViewDescriptor::Pointer descriptor, ViewTreeItem* parent = nullptr);
QVariant data(int role) override;
protected:
QSet<QString> keywordLabels() const override;
IViewDescriptor::Pointer m_descriptor;
};
struct CategoryTreeItem : ViewTreeItem
{
CategoryTreeItem(ViewTreeModel* model, IViewCategory::Pointer category, ViewTreeItem* parent = nullptr);
QVariant data(int role) override;
Qt::ItemFlags flags() const override;
protected:
QSet<QString> keywordLabels() const override;
/**
* Removes the temporary intro view from the list so that it cannot be activated except through
* the introduction command.
*/
void RemoveIntroView(QList<IViewDescriptor::Pointer>& list);
private:
void CreateChildren();
IViewCategory::Pointer m_category;
};
// --------------------------- Tree Model Classes ---------------------------
struct ViewTreeModel::Impl
{
Impl(const IWorkbenchWindow* window)
: window(window)
, viewRegistry(*window->GetWorkbench()->GetViewRegistry())
{
}
const IWorkbenchWindow* window;
IViewRegistry& viewRegistry;
QScopedPointer<RootTreeItem> rootItem;
};
ViewTreeModel::ViewTreeModel(const IWorkbenchWindow* window, QObject* parent)
: QAbstractItemModel(parent)
, d(new Impl(window))
{
d->rootItem.reset(new RootTreeItem(this));
QList<CategoryTreeItem*> categoryItems;
QList<IViewCategory::Pointer> categories = d->viewRegistry.GetCategories();
for (const auto &category : qAsConst(categories))
{
if (category->GetViews().isEmpty()) continue;
CategoryTreeItem* categoryItem = new CategoryTreeItem(this, category);
if (categoryItem->childCount() == 0)
{
delete categoryItem;
}
else
{
categoryItems.push_back(categoryItem);
}
}
// if there is only one category, return it's children directly
if (categoryItems.size() == 1)
{
QList<ViewTreeItem*> items = categoryItems.front()->takeChildren();
for (auto item : qAsConst(items))
{
d->rootItem->appendChild(item);
}
qDeleteAll(categoryItems);
}
else
{
for (auto category : qAsConst(categoryItems))
{
d->rootItem->appendChild(category);
}
}
}
ViewTreeModel::~ViewTreeModel()
{
}
QVariant ViewTreeModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid()) return QVariant();
return static_cast<ViewTreeItem*>(index.internalPointer())->data(role);
}
Qt::ItemFlags ViewTreeModel::flags(const QModelIndex& index) const
{
if (!index.isValid()) return nullptr;
return static_cast<ViewTreeItem*>(index.internalPointer())->flags();
}
QVariant ViewTreeModel::headerData(int section, Qt::Orientation /*orientation*/, int role) const
{
if (role == Qt::DisplayRole && section == 0)
{
return "View";
}
return QVariant();
}
QModelIndex ViewTreeModel::index(int row, int column, const QModelIndex& parent) const
{
if (!hasIndex(row, column, parent))
{
return QModelIndex();
}
ViewTreeItem* parentItem = nullptr;
if (!parent.isValid())
{
parentItem = d->rootItem.data();
}
else
{
parentItem = static_cast<ViewTreeItem*>(parent.internalPointer());
}
ViewTreeItem* childItem = parentItem->childItem(row);
if (childItem)
{
return createIndex(row, column, childItem);
}
return QModelIndex();
}
QModelIndex ViewTreeModel::parent(const QModelIndex& child) const
{
if (!child.isValid())
{
return QModelIndex();
}
ViewTreeItem* childItem = static_cast<ViewTreeItem*>(child.internalPointer());
ViewTreeItem* parentItem = childItem->parentItem();
if (parentItem == d->rootItem.data())
{
return QModelIndex();
}
return createIndex(parentItem->row(), 0, parentItem);
}
int ViewTreeModel::rowCount(const QModelIndex& parent) const
{
ViewTreeItem* parentItem = nullptr;
if (parent.column() > 0) return 0;
if (!parent.isValid())
{
parentItem = d->rootItem.data();
}
else
{
parentItem = static_cast<ViewTreeItem*>(parent.internalPointer());
}
return parentItem->childCount();
}
int ViewTreeModel::columnCount(const QModelIndex& /*parent*/) const
{
return 1;
}
const IWorkbenchWindow*ViewTreeModel::GetWorkbenchWindow() const
{
return d->window;
}
// --------------------------- DescriptorTreeItem ---------------------------
DescriptorTreeItem::DescriptorTreeItem(ViewTreeModel* model, IViewDescriptor::Pointer descriptor, ViewTreeItem* parent)
: ViewTreeItem(model)
, m_descriptor(descriptor)
{
if (parent) parent->appendChild(this);
}
QVariant DescriptorTreeItem::data(int role)
{
if (role == Qt::DisplayRole)
{
return m_descriptor->GetLabel();
}
else if (role == Qt::DecorationRole)
{
return m_descriptor->GetImageDescriptor();
}
else if (role == Qt::ForegroundRole)
{
IWorkbenchPage::Pointer page = this->m_model->GetWorkbenchWindow()->GetActivePage();
if (page.IsNotNull())
{
if (page->FindViewReference(m_descriptor->GetId()).IsNotNull())
{
return QBrush(QColor(Qt::gray));
}
}
}
else if (role == ViewTreeModel::Description)
{
return m_descriptor->GetDescription();
}
else if (role == ViewTreeModel::Id)
{
return m_descriptor->GetId();
}
return ViewTreeItem::data(role);
}
QSet<QString> DescriptorTreeItem::keywordLabels() const
{
KeywordRegistry* registry = KeywordRegistry::GetInstance();
QStringList ids = m_descriptor->GetKeywordReferences();
QSet<QString> keywords;
keywords.insert(m_descriptor->GetLabel());
for(const auto &id : qAsConst(ids))
{
QString label = registry->GetKeywordLabel(id);
- for (const auto &keyword : label.split(' ', QString::SkipEmptyParts))
+ for (const auto &keyword : label.split(' ', Qt::SkipEmptyParts))
{
keywords.insert(keyword);
}
}
return keywords;
}
// --------------------------- CategoryTreeItem ---------------------------
CategoryTreeItem::CategoryTreeItem(ViewTreeModel* model, IViewCategory::Pointer category, ViewTreeItem* parent)
: ViewTreeItem(model)
, m_category(category)
{
if (parent) parent->appendChild(this);
this->CreateChildren();
}
QVariant CategoryTreeItem::data(int role)
{
if (role == Qt::DisplayRole)
{
return m_category->GetLabel();
}
else if (role == Qt::DecorationRole)
{
return QIcon::fromTheme("folder");
}
else if (role == ViewTreeModel::Id)
{
return m_category->GetId();
}
return ViewTreeItem::data(role);
}
Qt::ItemFlags CategoryTreeItem::flags() const
{
return Qt::ItemIsEnabled;
}
QSet<QString> CategoryTreeItem::keywordLabels() const
{
QSet<QString> keywords;
for(auto child : this->m_children)
{
for (const auto &keyword : child->data(ViewTreeModel::Keywords).toStringList())
{
keywords.insert(keyword);
}
}
return keywords;
}
void CategoryTreeItem::CreateChildren()
{
auto viewDescriptors = m_category->GetViews();
RemoveIntroView(viewDescriptors);
for(const auto &viewDescriptor : qAsConst(viewDescriptors))
{
new DescriptorTreeItem(this->m_model, viewDescriptor, this);
}
}
void CategoryTreeItem::RemoveIntroView(QList<IViewDescriptor::Pointer>& list)
{
for (auto view = list.begin(); view != list.end();)
{
if ((*view)->GetId() == IntroConstants::INTRO_VIEW_ID)
{
view = list.erase(view);
}
else ++view;
}
}
}
diff --git a/Plugins/org.mitk.gui.qt.dicombrowser/src/internal/QmitkStoreSCPLauncher.cpp b/Plugins/org.mitk.gui.qt.dicombrowser/src/internal/QmitkStoreSCPLauncher.cpp
index 1ef4353f0e..cb8de364af 100644
--- a/Plugins/org.mitk.gui.qt.dicombrowser/src/internal/QmitkStoreSCPLauncher.cpp
+++ b/Plugins/org.mitk.gui.qt.dicombrowser/src/internal/QmitkStoreSCPLauncher.cpp
@@ -1,199 +1,199 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkStoreSCPLauncher.h"
#include <QMessageBox>
#include <QProcessEnvironment>
#include <mitkLog.h>
#include <fstream>
#include <iostream>
#include <QFile>
#include <QTextStream>
#include <QIODevice>
#include <QDir>
#include <QDirIterator>
#include <QCoreApplication>
#include "org_mitk_gui_qt_dicombrowser_config.h"
QmitkStoreSCPLauncher::QmitkStoreSCPLauncher(QmitkStoreSCPLauncherBuilder* builder)
: m_StoreSCP(new QProcess())
{
m_StoreSCP->setProcessChannelMode(QProcess::MergedChannels);
connect( m_StoreSCP, SIGNAL(error(QProcess::ProcessError)),this, SLOT(OnProcessError(QProcess::ProcessError)));
connect( m_StoreSCP, SIGNAL(stateChanged(QProcess::ProcessState)),this, SLOT(OnStateChanged(QProcess::ProcessState)));
connect( m_StoreSCP, SIGNAL(readyReadStandardOutput()),this, SLOT(OnReadyProcessOutput()));
SetArgumentList(builder);
}
QmitkStoreSCPLauncher::~QmitkStoreSCPLauncher()
{
disconnect( m_StoreSCP, SIGNAL(error(QProcess::ProcessError)),this, SLOT(OnProcessError(QProcess::ProcessError)));
disconnect( m_StoreSCP, SIGNAL(stateChanged(QProcess::ProcessState)),this, SLOT(OnStateChanged(QProcess::ProcessState)));
disconnect( m_StoreSCP, SIGNAL(readyReadStandardOutput()),this, SLOT(OnReadyProcessOutput()));
m_StoreSCP->close();
m_StoreSCP->waitForFinished(1000);
delete m_StoreSCP;
}
void QmitkStoreSCPLauncher::StartStoreSCP()
{
FindPathToStoreSCP();
m_StoreSCP->start(m_PathToStoreSCP,m_ArgumentList);
}
void QmitkStoreSCPLauncher::FindPathToStoreSCP()
{
QString appPath= QCoreApplication::applicationDirPath();
if(m_PathToStoreSCP.isEmpty())
{
QString fileName;
#ifdef _WIN32
fileName = "/storescp.exe";
#else
fileName = "/storescp";
#endif
m_PathToStoreSCP = appPath + fileName;
//In development the storescp isn't copied into bin directory
if(!QFile::exists(m_PathToStoreSCP))
{
m_PathToStoreSCP = static_cast<QString>(DCMTK_STORESCP);
}
}
}
void QmitkStoreSCPLauncher::OnReadyProcessOutput()
{
QString out(m_StoreSCP->readAllStandardOutput());
QStringList allDataList,importList;
- allDataList = out.split("\n",QString::SkipEmptyParts);
+ allDataList = out.split("\n",Qt::SkipEmptyParts);
QStringListIterator it(allDataList);
while(it.hasNext())
{
QString output = it.next();
if (output.contains("E: "))
{
output.replace("E: ","");
m_ErrorText = output;
OnProcessError(QProcess::UnknownError);
return;
}
if(output.contains("I: storing DICOM file: "))
{
output.replace("I: storing DICOM file: ","");
output.replace("\\", "/"); // cannot handle backslashes
output.replace("\r", ""); // cannot handle carriage return
importList += output;
}
}
if(!importList.isEmpty())
{
emit SignalStartImport(importList);
}
}
void QmitkStoreSCPLauncher::OnProcessError(QProcess::ProcessError err)
{
switch(err)
{
case QProcess::FailedToStart:
m_ErrorText.prepend("Failed to start storage provider: ");
m_ErrorText.append(m_StoreSCP->errorString());
emit SignalStoreSCPError(m_ErrorText);
m_ErrorText.clear();
break;
case QProcess::Crashed:
m_ErrorText.prepend("Storage provider closed: ");
m_ErrorText.append(m_StoreSCP->errorString());
emit SignalStoreSCPError(m_ErrorText);
m_ErrorText.clear();
break;
case QProcess::Timedout:
m_ErrorText.prepend("Storage provider timeout: ");
m_ErrorText.append(m_StoreSCP->errorString());
emit SignalStoreSCPError(m_ErrorText);
m_ErrorText.clear();
break;
case QProcess::WriteError:
m_ErrorText.prepend("Storage provider write error: ");
m_ErrorText.append(m_StoreSCP->errorString());
emit SignalStoreSCPError(m_ErrorText);
m_ErrorText.clear();
break;
case QProcess::ReadError:
m_ErrorText.prepend("Storage provider read error: ");
m_ErrorText.append(m_StoreSCP->errorString());
emit SignalStoreSCPError(m_ErrorText);
m_ErrorText.clear();
break;
case QProcess::UnknownError:
m_ErrorText.prepend("Storage provider unknown error: ");
m_ErrorText.append(m_StoreSCP->errorString());
emit SignalStoreSCPError(m_ErrorText);
m_ErrorText.clear();
break;
default:
m_ErrorText.prepend("Storage provider unknown error: ");
m_ErrorText.append(m_StoreSCP->errorString());
emit SignalStoreSCPError(m_ErrorText);
m_ErrorText.clear();
break;
}
}
void QmitkStoreSCPLauncher::OnStateChanged(QProcess::ProcessState status)
{
switch(status)
{
case QProcess::NotRunning:
m_StatusText.prepend("Storage provider not running!");
emit SignalStatusOfStoreSCP(m_StatusText);
m_StatusText.clear();
break;
case QProcess::Starting:
m_StatusText.prepend("Starting storage provider!");
emit SignalStatusOfStoreSCP(m_StatusText);
m_StatusText.clear();
break;
case QProcess::Running:
m_StatusText.prepend(m_ArgumentList[0]).prepend(" Port: ").prepend(m_ArgumentList[2]).prepend(" AET: ").prepend("Storage provider running! ");
emit SignalStatusOfStoreSCP(m_StatusText);
m_StatusText.clear();
break;
default:
m_StatusText.prepend("Storage provider unknown error!");
emit SignalStatusOfStoreSCP(m_StatusText);
m_StatusText.clear();
break;
}
}
void QmitkStoreSCPLauncher::SetArgumentList(QmitkStoreSCPLauncherBuilder* builder)
{
m_ArgumentList << *builder->GetPort() << QString("-aet") <<*builder->GetAETitle() << *builder->GetTransferSyntax()
<< *builder->GetOtherNetworkOptions() << *builder->GetMode() << QString("-od") << *builder->GetOutputDirectory();
}
QString QmitkStoreSCPLauncher::ArgumentListToQString()
{
QString argumentString;
QStringListIterator argumentIterator(m_ArgumentList);
while(argumentIterator.hasNext())
{
argumentString.append(" ");
argumentString.append(argumentIterator.next());
}
return argumentString;
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.cpp b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.cpp
index d3c51d5ec9..fa41fbe1cb 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.ultrasoundtrackingnavigation/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.cpp
@@ -1,247 +1,247 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkUSNavigationCombinedSettingsWidget.h"
#include "ui_QmitkUSNavigationCombinedSettingsWidget.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include <ctkDirectoryButton.h>
#include <QSettings>
QmitkUSNavigationCombinedSettingsWidget::QmitkUSNavigationCombinedSettingsWidget(QWidget *parent) :
QmitkUSNavigationAbstractSettingsWidget(parent),
ui(new Ui::QmitkUSNavigationCombinedSettingsWidget)
{
ui->setupUi(this);
ui->experimentResultsPathButton->setOptions(ctkDirectoryButton::ShowDirsOnly);
connect( ui->applicationComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnApplicationChanged(int)) );
}
QmitkUSNavigationCombinedSettingsWidget::~QmitkUSNavigationCombinedSettingsWidget()
{
delete ui;
}
void QmitkUSNavigationCombinedSettingsWidget::OnSetSettingsNode(itk::SmartPointer<mitk::DataNode> settingsNode, bool overwriteValues)
{
if ( overwriteValues )
{
settingsNode->SetStringProperty("settings.application", ui->applicationComboBox->currentText().toStdString().c_str());
settingsNode->SetStringProperty("settings.interaction-concept", this->InteractionNameToFile(ui->interactionConceptComboBox->currentText()).toStdString().c_str());
settingsNode->SetBoolProperty("settings.experiment-mode", ui->experimentModeCheckBox->isChecked());
settingsNode->SetStringProperty("settings.experiment-results-directory", ui->experimentResultsPathButton->directory().toStdString().c_str());
settingsNode->SetFloatProperty("settings.security-distance", ui->securityDistanceSpinBox->value());
settingsNode->SetIntProperty("settings.number-of-targets", ui->numberOfTargetsSpinBox->value());
settingsNode->SetBoolProperty("settings.use-planning-step", ui->planningStepUsageCheckBox->isChecked());
settingsNode->SetStringProperty("settings.needle-name-selected", ui->needleNameComboBox->currentText().toStdString().c_str());
settingsNode->SetStringProperty("settings.reference-name-selected", ui->referenceNameComboBox->currentText().toStdString().c_str());
}
else
{
std::string stringProperty;
float floatProperty;
bool boolProperty;
// load state of application setting combo box
if ( ! settingsNode->GetStringProperty("settings.application", stringProperty) ) { stringProperty = ""; }
int lastIndex = ui->applicationComboBox->findText(QString::fromStdString(stringProperty));
if (lastIndex == -1) { lastIndex = 0; }
ui->applicationComboBox->setCurrentIndex(lastIndex);
this->OnApplicationChanged(lastIndex);
// load state of interaction concept setting combo box
if ( ! settingsNode->GetStringProperty("settings.interaction-concept", stringProperty) ) { stringProperty = ""; }
lastIndex = ui->interactionConceptComboBox->findText(QString::fromStdString(stringProperty));
if (lastIndex == -1) { lastIndex = 0; }
ui->interactionConceptComboBox->setCurrentIndex(lastIndex);
if ( ! settingsNode->GetBoolProperty("settings.experiment-mode", boolProperty) ) { boolProperty = false; }
ui->experimentModeCheckBox->setChecked(boolProperty);
if ( ! settingsNode->GetStringProperty("settings.experiment-results-directory", stringProperty) ) { stringProperty = ""; }
ui->experimentResultsPathButton->setDirectory(QString::fromStdString(stringProperty));
if ( ! settingsNode->GetFloatProperty("settings.security-distance", floatProperty) ) { floatProperty = 2.0; }
ui->securityDistanceSpinBox->setValue(floatProperty);
if ( ! settingsNode->GetFloatProperty("settings.number-of-targets", floatProperty) ) { floatProperty = 3; }
ui->numberOfTargetsSpinBox->setValue(static_cast<int>(floatProperty));
if ( ! settingsNode->GetBoolProperty("settings.use-planning-step", boolProperty) ) { boolProperty = true; }
ui->planningStepUsageCheckBox->setChecked(boolProperty);
if ( ! settingsNode->GetStringProperty("settings.needle-names", stringProperty) ) { stringProperty = ""; }
QString needleNames = QString::fromStdString(stringProperty);
ui->needleNameComboBox->clear();
- ui->needleNameComboBox->addItems(needleNames.split(";", QString::SkipEmptyParts));
+ ui->needleNameComboBox->addItems(needleNames.split(";", Qt::SkipEmptyParts));
if ( ! settingsNode->GetStringProperty("settings.needle-name-selected", stringProperty) ) { stringProperty = ""; }
int index = ui->needleNameComboBox->findText(QString::fromStdString(stringProperty));
if (index == -1)
{
ui->needleNameComboBox->addItem(QString::fromStdString(stringProperty));
ui->needleNameComboBox->setCurrentIndex(ui->needleNameComboBox->count()-1);
}
else
{
ui->needleNameComboBox->setCurrentIndex(index);
}
if ( ! settingsNode->GetStringProperty("settings.reference-names", stringProperty) ) { stringProperty = ""; }
QString referenceNames = QString::fromStdString(stringProperty);
ui->referenceNameComboBox->clear();
- ui->referenceNameComboBox->addItems(referenceNames.split(";", QString::SkipEmptyParts));
+ ui->referenceNameComboBox->addItems(referenceNames.split(";", Qt::SkipEmptyParts));
if ( ! settingsNode->GetStringProperty("settings.reference-name-selected", stringProperty) ) { stringProperty = ""; }
index = ui->referenceNameComboBox->findText(QString::fromStdString(stringProperty));
if (index == -1)
{
ui->referenceNameComboBox->addItem(QString::fromStdString(stringProperty));
ui->referenceNameComboBox->setCurrentIndex(ui->referenceNameComboBox->count()-1);
}
else
{
ui->referenceNameComboBox->setCurrentIndex(index);
}
}
}
void QmitkUSNavigationCombinedSettingsWidget::OnSaveProcessing()
{
mitk::DataNode::Pointer settingsNode = this->GetSettingsNode();
QSettings settings;
settings.beginGroup("ultrasound-navigation");
settings.setValue("application", ui->applicationComboBox->currentText());
settingsNode->SetStringProperty("settings.application", ui->applicationComboBox->currentText().toStdString().c_str());
settings.setValue("interaction-concept", ui->interactionConceptComboBox->currentText());
settingsNode->SetStringProperty("settings.interaction-concept", this->InteractionNameToFile(ui->interactionConceptComboBox->currentText()).toStdString().c_str());
settings.setValue("experiment-mode", ui->experimentModeCheckBox->isChecked());
settingsNode->SetBoolProperty("settings.experiment-mode", ui->experimentModeCheckBox->isChecked());
settings.setValue("experiment-results-directory", ui->experimentResultsPathButton->directory());
settingsNode->SetStringProperty("settings.experiment-results-directory", ui->experimentResultsPathButton->directory().toStdString().c_str());
settings.setValue("security-distance", ui->securityDistanceSpinBox->value());
settingsNode->SetFloatProperty("settings.security-distance", ui->securityDistanceSpinBox->value());
settings.setValue("number-of-targets", ui->numberOfTargetsSpinBox->value());
settingsNode->SetIntProperty("settings.number-of-targets", ui->numberOfTargetsSpinBox->value());
settings.setValue("use-planning-step", ui->planningStepUsageCheckBox->isChecked());
settingsNode->SetBoolProperty("settings.use-planning-step", ui->planningStepUsageCheckBox->isChecked());
settings.setValue("needle-name-selected", ui->needleNameComboBox->currentText());
settingsNode->SetStringProperty("settings.needle-name-selected", ui->needleNameComboBox->currentText().toStdString().c_str());
settings.setValue("reference-name-selected", ui->referenceNameComboBox->currentText());
settingsNode->SetStringProperty("settings.reference-name-selected", ui->referenceNameComboBox->currentText().toStdString().c_str());
settings.endGroup();
}
void QmitkUSNavigationCombinedSettingsWidget::OnLoadSettingsProcessing()
{
QSettings settings;
settings.beginGroup("ultrasound-navigation");
// load state of application setting combo box
int lastIndex = ui->applicationComboBox->findText(settings.value("application").toString());
if (lastIndex == -1) { lastIndex = 0; }
ui->applicationComboBox->setCurrentIndex(lastIndex);
this->OnApplicationChanged(lastIndex);
// load state of interaction concept setting combo box
lastIndex = ui->interactionConceptComboBox->findText(settings.value("interaction-concept").toString());
if (lastIndex == -1) { lastIndex = 0; }
ui->interactionConceptComboBox->setCurrentIndex(lastIndex);
ui->experimentModeCheckBox->setChecked(settings.value("experiment-mode").toBool());
ui->experimentResultsPathButton->setDirectory(settings.value("experiment-results-directory").toString());
ui->securityDistanceSpinBox->setValue(settings.value("security-distance", 2.0).toDouble());
ui->numberOfTargetsSpinBox->setValue(settings.value("number-of-targets", 3).toInt());
ui->planningStepUsageCheckBox->setChecked(settings.value("use-planning-step", true).toBool());
ui->needleNameComboBox->clear();
ui->needleNameComboBox->addItems(settings.value("needle-names").toStringList());
QString selectedName = settings.value("needle-name-selected").toString();
int index = ui->needleNameComboBox->findText(selectedName);
if (index == -1)
{
ui->needleNameComboBox->addItem(selectedName);
ui->needleNameComboBox->setCurrentIndex(ui->needleNameComboBox->count()-1);
}
else
{
ui->needleNameComboBox->setCurrentIndex(index);
}
ui->referenceNameComboBox->clear();
ui->referenceNameComboBox->addItems(settings.value("reference-names").toStringList());
selectedName = settings.value("reference-name-selected").toString();
index = ui->referenceNameComboBox->findText(selectedName);
if (index == -1)
{
ui->referenceNameComboBox->addItem(selectedName);
ui->referenceNameComboBox->setCurrentIndex(ui->referenceNameComboBox->count()-1);
}
else
{
ui->referenceNameComboBox->setCurrentIndex(index);
}
settings.endGroup();
}
void QmitkUSNavigationCombinedSettingsWidget::OnApplicationChanged(int index)
{
if (index == 0)
{
ui->punctuationGroupBox->show();
ui->markerPlacementGroupBox->hide();
}
else if (index == 1)
{
ui->punctuationGroupBox->hide();
ui->markerPlacementGroupBox->show();
}
}
QString QmitkUSNavigationCombinedSettingsWidget::InteractionNameToFile(const QString& name) const
{
if (name == tr("Click, Move and Click"))
{
return QString("USZoneInteractions.xml");
}
else if (name == tr("Hold, Move and Release"))
{
return QString("USZoneInteractionsHold.xml");
}
else
{
return QString();
}
}
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp
index 84b00c4397..f54284c507 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.browser/src/internal/QmitkMatchPointBrowser.cpp
@@ -1,269 +1,269 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "org_mitk_gui_qt_matchpoint_algorithm_browser_Activator.h"
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkMatchPointBrowser.h"
// Qt
#include <QMessageBox>
#include <QErrorMessage>
#include <QDir>
#include <QStringList>
//MITK
#include <mitkStatusBar.h>
#include "MatchPointBrowserConstants.h"
#include "mitkAlgorithmInfoSelectionProvider.h"
#include <mitkCoreServices.h>
#include <mitkIPreferencesService.h>
#include <mitkIPreferences.h>
// MatchPoint
#include "mapRegistrationAlgorithmInterface.h"
#include "mapAlgorithmEvents.h"
#include "mapAlgorithmWrapperEvent.h"
#include "mapExceptionObjectMacros.h"
#include "mapDeploymentDLLDirectoryBrowser.h"
#include "mapDeploymentEvents.h"
const std::string QmitkMatchPointBrowser::VIEW_ID = "org.mitk.views.matchpoint.algorithm.browser";
QmitkMatchPointBrowser::QmitkMatchPointBrowser()
: m_Parent(nullptr), m_LoadedDLLHandle(nullptr), m_LoadedAlgorithm(nullptr)
{
}
QmitkMatchPointBrowser::~QmitkMatchPointBrowser()
{
}
void QmitkMatchPointBrowser::OnPreferencesChanged(const mitk::IPreferences* /*prefs*/)
{
this->OnSearchFolderButtonPushed();
}
void QmitkMatchPointBrowser::CreateConnections()
{
connect(m_Controls.m_pbSearchFolder, SIGNAL(clicked()), this, SLOT(OnSearchFolderButtonPushed()));
connect(m_Controls.m_algoTreeView, SIGNAL(clicked(const QModelIndex&)), this,
SLOT(OnAlgoListSelectionChanged(const QModelIndex&)));
connect(m_Controls.pbClearSearch, SIGNAL(clicked()), m_Controls.lineSearch, SLOT(clear()));
connect(m_Controls.lineSearch, SIGNAL(textChanged(const QString&)), this,
SLOT(OnSearchChanged(const QString&)));
}
void QmitkMatchPointBrowser::OnSearchFolderButtonPushed()
{
RetrieveAndStorePreferenceValues();
// test if some folder list non-empty
int folderCount = m_currentSearchPaths.count();
if (!folderCount)
{
Error(QString("No search folder selected for MatchPoint algorithm browser! Please set search paths in the MatchPoint preference page."));
m_DLLInfoList.clear();
}
else
{
map::deployment::DLLDirectoryBrowser::Pointer browser = map::deployment::DLLDirectoryBrowser::New();
auto validCommand = ::itk::MemberCommand<QmitkMatchPointBrowser>::New();
validCommand->SetCallbackFunction(this, &QmitkMatchPointBrowser::OnValidDeploymentEvent);
browser->AddObserver(::map::events::ValidDLLEvent(), validCommand);
auto invalidCommand = ::itk::MemberCommand<QmitkMatchPointBrowser>::New();
invalidCommand->SetCallbackFunction(this, &QmitkMatchPointBrowser::OnInvalidDeploymentEvent);
browser->AddObserver(::map::events::InvalidDLLEvent(), invalidCommand);
foreach(QString path, m_currentSearchPaths)
{
browser->addDLLSearchLocation(path.toStdString());
}
browser->update();
m_DLLInfoList = browser->getLibraryInfos();
}
m_Controls.groupWarning->setVisible(m_DLLInfoList.empty());
m_Controls.groupList->setVisible(!m_DLLInfoList.empty());
m_algModel->SetAlgorithms(m_DLLInfoList);
m_Controls.lineSearch->clear();
}
void QmitkMatchPointBrowser::OnAlgoListSelectionChanged(const QModelIndex& index)
{
QVariant vIndex = index.data(Qt::UserRole).toInt();
map::deployment::DLLInfo::ConstPointer currentItemInfo = nullptr;
if (vIndex.isValid())
{
std::size_t algListIndex = vIndex.toInt();
if (algListIndex < m_DLLInfoList.size())
{
currentItemInfo = m_DLLInfoList[algListIndex];
}
}
m_Controls.m_teAlgorithmDetails->updateInfo(currentItemInfo);
if (currentItemInfo)
{
//update selection provider
mitk::MAPAlgorithmInfoSelection::Pointer infoSelection = mitk::MAPAlgorithmInfoSelection::Pointer(
new mitk::MAPAlgorithmInfoSelection(currentItemInfo));
this->m_SelectionProvider->SetInfoSelection(infoSelection);
}
}
void QmitkMatchPointBrowser::OnSearchChanged(const QString& text)
{
m_filterProxy->setFilterRegExp(text);
m_filterProxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
};
void QmitkMatchPointBrowser::OnInvalidDeploymentEvent(const ::itk::Object *, const itk::EventObject &event)
{
auto deployEvent = dynamic_cast<const ::map::events::InvalidDLLEvent*>(&event);
this->Error(QString("Error when try to inspect deployed registration algorithm. Details: ")+QString::fromStdString(deployEvent->getComment()));
}
void QmitkMatchPointBrowser::OnValidDeploymentEvent(const ::itk::Object *, const itk::EventObject &event)
{
auto deployEvent = dynamic_cast<const ::map::events::ValidDLLEvent*>(&event);
auto info = static_cast<const ::map::deployment::DLLInfo*>(deployEvent->getData());
MITK_INFO << "Successfully inspected deployed registration algorithm. UID: " << info->getAlgorithmUID().toStr() << ". Path: " << info->getLibraryFilePath();
}
void QmitkMatchPointBrowser::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
m_algModel = new QmitkAlgorithmListModel(parent);
m_filterProxy = new QSortFilterProxyModel(parent);
//! [Qt Selection Provider registration]
// create new qt selection provider
m_SelectionProvider = new mitk::AlgorithmInfoSelectionProvider();
m_filterProxy->setSourceModel(m_algModel);
m_filterProxy->setDynamicSortFilter(true);
m_filterProxy->setFilterKeyColumn(-1);
m_Controls.m_algoTreeView->setModel(m_filterProxy);
m_Controls.m_algoTreeView->setSelectionMode(QAbstractItemView::SingleSelection);
m_Controls.m_algoTreeView->header()->setStretchLastSection(false);
m_Controls.m_algoTreeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
m_Controls.m_algoTreeView->setColumnHidden(3, true);
this->CreateConnections();
}
void QmitkMatchPointBrowser::SetSelectionProvider()
{
this->GetSite()->SetSelectionProvider(m_SelectionProvider);
}
void QmitkMatchPointBrowser::SetFocus()
{
}
void QmitkMatchPointBrowser::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
}
void QmitkMatchPointBrowser::RetrieveAndStorePreferenceValues()
{
auto* prefs = this->RetrievePreferences();
bool loadApplicationDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_APPLICATION_DIR, true);
bool loadHomeDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_HOME_DIR, false);
bool loadCurrentDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_CURRENT_DIR, false);
bool loadAutoLoadDir = prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_AUTO_LOAD_DIR, false);
// Get some default application paths.
QStringList newPaths;
// Here we can use the preferences to set up the builder,
if (loadApplicationDir)
{
newPaths << QCoreApplication::applicationDirPath();
}
if (loadHomeDir)
{
newPaths << QDir::homePath();
}
if (loadCurrentDir)
{
newPaths << QDir::currentPath();
}
if (loadAutoLoadDir)
{
char* deployedAlgorithmLoadPath = getenv("MAP_MDRA_LOAD_PATH");
if (deployedAlgorithmLoadPath != nullptr)
{
// The load path may in fact be a semi-colon or colon separated list of directories, not just one.
QString paths(deployedAlgorithmLoadPath);
#ifdef Q_OS_WIN32
QString pathSeparator(";");
#else
QString pathSeparator(":");
#endif
- QStringList splitPath = paths.split(pathSeparator, QString::SkipEmptyParts);
+ QStringList splitPath = paths.split(pathSeparator, Qt::SkipEmptyParts);
foreach(QString path, splitPath)
{
QDir dir = QDir(path);
newPaths << dir.absolutePath();
}
}
}
// We get additional directory paths from preferences.
const auto pathString = QString::fromStdString(prefs->Get(MatchPointBrowserConstants::MDAR_DIRECTORIES_NODE_NAME, ""));
- QStringList additionalPaths = pathString.split(";", QString::SkipEmptyParts);
+ QStringList additionalPaths = pathString.split(";", Qt::SkipEmptyParts);
newPaths << additionalPaths;
const auto additionalAlgorirthmsString = QString::fromStdString(prefs->Get(MatchPointBrowserConstants::MDAR_FILES_NODE_NAME, ""));
- additionalPaths = additionalAlgorirthmsString.split(";", QString::SkipEmptyParts);
+ additionalPaths = additionalAlgorirthmsString.split(";", Qt::SkipEmptyParts);
newPaths << additionalPaths;
m_currentSearchPaths = newPaths;
}
mitk::IPreferences* QmitkMatchPointBrowser::RetrievePreferences()
{
const auto id = "/" + MatchPointBrowserConstants::VIEW_ID;
return mitk::CoreServices::GetPreferencesService()->GetSystemPreferences()->Node(id);
}
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentAnythingPreferencePage.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentAnythingPreferencePage.cpp
index 66bbb404e1..b580f620ab 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentAnythingPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentAnythingPreferencePage.cpp
@@ -1,356 +1,356 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkSegmentAnythingPreferencePage.h"
#include <mitkCoreServices.h>
#include <mitkIPreferencesService.h>
#include <mitkIPreferences.h>
#include <mitkProcessExecutor.h>
#include <itkCommand.h>
#include <QmitkSegmentAnythingToolGUI.h>
#include <QFileDialog>
#include <QmitkStyleManager.h>
#include <QDir>
#include <QDirIterator>
namespace
{
mitk::IPreferences* GetPreferences()
{
auto* preferencesService = mitk::CoreServices::GetPreferencesService();
return preferencesService->GetSystemPreferences()->Node("org.mitk.views.segmentation");
}
}
QmitkSegmentAnythingPreferencePage::QmitkSegmentAnythingPreferencePage()
: m_Ui(new Ui::QmitkSegmentAnythingPreferencePage),
m_Control(nullptr){}
QmitkSegmentAnythingPreferencePage::~QmitkSegmentAnythingPreferencePage(){}
void QmitkSegmentAnythingPreferencePage::Init(berry::IWorkbench::Pointer){}
void QmitkSegmentAnythingPreferencePage::CreateQtControl(QWidget* parent)
{
m_Control = new QWidget(parent);
m_Ui->setupUi(m_Control);
m_Ui->samModelTipLabel->hide(); // TODO: All models except for vit_b seem to be unsupported by SAM?
#ifndef _WIN32
m_Ui->sysPythonComboBox->addItem("/usr/bin");
#endif
this->AutoParsePythonPaths();
m_Ui->timeoutEdit->setValidator(new QIntValidator(0, 1000, this));
m_Ui->sysPythonComboBox->addItem("Select...");
m_Ui->sysPythonComboBox->setCurrentIndex(0);
connect(m_Ui->installSAMButton, SIGNAL(clicked()), this, SLOT(OnInstallBtnClicked()));
connect(m_Ui->clearSAMButton, SIGNAL(clicked()), this, SLOT(OnClearInstall()));
connect(m_Ui->sysPythonComboBox,
QOverload<int>::of(&QComboBox::activated),
[=](int index) { OnSystemPythonChanged(m_Ui->sysPythonComboBox->itemText(index)); });
QIcon deleteIcon =
QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/edit-delete.svg"));
m_Ui->clearSAMButton->setIcon(deleteIcon);
const QString storageDir = m_Installer.GetVirtualEnvPath();
bool isInstalled = QmitkSegmentAnythingToolGUI::IsSAMInstalled(storageDir);
QString welcomeText;
if (isInstalled)
{
m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(storageDir).first;
m_Installer.SetVirtualEnvPath(m_PythonPath);
welcomeText += " Segment Anything tool is already found installed.";
m_Ui->installSAMButton->setEnabled(false);
}
else
{
welcomeText += " Segment Anything tool not installed. Please click on \"Install SAM\" above. \
The installation will create a new virtual environment using the System Python selected above.";
m_Ui->installSAMButton->setEnabled(true);
}
this->WriteStatusMessage(welcomeText);
m_Ui->samModelTypeComboBox->addItems(VALID_MODELS);
m_Ui->gpuComboBox->addItem(CPU_ID);
this->SetGPUInfo();
this->Update();
}
QWidget* QmitkSegmentAnythingPreferencePage::GetQtControl() const
{
return m_Control;
}
bool QmitkSegmentAnythingPreferencePage::PerformOk()
{
auto* prefs = GetPreferences();
prefs->Put("sam parent path", m_Installer.STORAGE_DIR.toStdString());
prefs->Put("sam python path", m_PythonPath.toStdString());
prefs->Put("sam modeltype", m_Ui->samModelTypeComboBox->currentText().toStdString());
prefs->PutInt("sam gpuid", FetchSelectedGPUFromUI());
prefs->PutInt("sam timeout", std::stoi(m_Ui->timeoutEdit->text().toStdString()));
return true;
}
void QmitkSegmentAnythingPreferencePage::PerformCancel(){}
void QmitkSegmentAnythingPreferencePage::Update()
{
auto* prefs = GetPreferences();
m_Ui->samModelTypeComboBox->setCurrentText(QString::fromStdString(prefs->Get("sam modeltype", "vit_b")));
m_Ui->timeoutEdit->setText(QString::number(prefs->GetInt("sam timeout", 300)));
int gpuId = prefs->GetInt("sam gpuid", -1);
if (gpuId == -1)
{
m_Ui->gpuComboBox->setCurrentText(CPU_ID);
}
else if (m_GpuLoader.GetGPUCount() == 0)
{
m_Ui->gpuComboBox->setCurrentText(QString::number(gpuId));
}
else
{
std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
QmitkGPUSpec gpuSpec = specs[gpuId];
m_Ui->gpuComboBox->setCurrentText(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
}
}
std::pair<QString, QString> QmitkSegmentAnythingPreferencePage::OnSystemPythonChanged(const QString &pyEnv)
{
std::pair<QString, QString> pyPath;
if (pyEnv == QString("Select..."))
{
QString path = QFileDialog::getExistingDirectory(m_Ui->sysPythonComboBox->parentWidget(), "Python Path", "dir");
if (!path.isEmpty())
{
this->OnSystemPythonChanged(path); // recall same function for new path validation
bool oldState = m_Ui->sysPythonComboBox->blockSignals(true); // block signal firing while inserting item
m_Ui->sysPythonComboBox->insertItem(0, path);
m_Ui->sysPythonComboBox->setCurrentIndex(0);
m_Ui->sysPythonComboBox->blockSignals(oldState); // unblock signal firing after inserting item. Remove this after Qt6 migration
}
}
else
{
QString uiPyPath = this->GetPythonPathFromUI(pyEnv);
pyPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(uiPyPath);
}
return pyPath;
}
QString QmitkSegmentAnythingPreferencePage::GetPythonPathFromUI(const QString &pyUI) const
{
QString fullPath = pyUI;
if (-1 != fullPath.indexOf(")"))
{
fullPath = fullPath.mid(fullPath.indexOf(")") + 2);
}
return fullPath.simplified();
}
void QmitkSegmentAnythingPreferencePage::AutoParsePythonPaths()
{
QString homeDir = QDir::homePath();
std::vector<QString> searchDirs;
#ifdef _WIN32
searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
QString("anaconda3"));
#else
// Add search locations for possible standard python paths here
searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
#endif
for (QString searchDir : searchDirs)
{
if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
{
if (QDir(searchDir).exists())
{
m_Ui->sysPythonComboBox->addItem("(base): " + searchDir);
searchDir.append((QDir::separator() + QString("envs")));
}
}
for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
{
subIt.next();
QString envName = subIt.fileName();
if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
{
m_Ui->sysPythonComboBox->addItem("(" + envName + "): " + subIt.filePath());
}
}
}
}
void QmitkSegmentAnythingPreferencePage::SetGPUInfo()
{
std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
for (const QmitkGPUSpec &gpuSpec : specs)
{
m_Ui->gpuComboBox->addItem(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
}
if (specs.empty())
{
m_Ui->gpuComboBox->setCurrentIndex(m_Ui->gpuComboBox->findText("cpu"));
}
else
{
m_Ui->gpuComboBox->setCurrentIndex(m_Ui->gpuComboBox->count()-1);
}
}
int QmitkSegmentAnythingPreferencePage::FetchSelectedGPUFromUI() const
{
QString gpuInfo = m_Ui->gpuComboBox->currentText();
if ("cpu" == gpuInfo)
{
return -1;
}
else if(m_GpuLoader.GetGPUCount() == 0)
{
return static_cast<int>(gpuInfo.toInt());
}
else
{
- QString gpuId = gpuInfo.split(":", QString::SplitBehavior::SkipEmptyParts).first();
+ QString gpuId = gpuInfo.split(":", Qt::SkipEmptyParts).first();
return static_cast<int>(gpuId.toInt());
}
}
void QmitkSegmentAnythingPreferencePage::OnInstallBtnClicked()
{
const auto [path, version] = OnSystemPythonChanged(m_Ui->sysPythonComboBox->currentText());
if (path.isEmpty())
{
this->WriteErrorMessage("<b>ERROR: </b>Couldn't find compatible Python.");
return;
}
//check if python 3.12 and ask for confirmation
if (version.startsWith("3.12") &&
QMessageBox::No == QMessageBox::question(nullptr,
"Installing Segment Anything",
QString("WARNING: This is an unsupported version of Python that may not work. "
"We recommend using a supported Python version between 3.9 and 3.11.\n\n"
"Continue anyway?"),
QMessageBox::Yes | QMessageBox::No,
QMessageBox::No))
{
return;
}
this->WriteStatusMessage("<b>STATUS: </b>Installing SAM...");
m_Ui->installSAMButton->setEnabled(false);
m_Installer.SetSystemPythonPath(path);
bool isInstalled = false;
if (m_Installer.SetupVirtualEnv(m_Installer.VENV_NAME))
{
isInstalled = QmitkSegmentAnythingToolGUI::IsSAMInstalled(m_Installer.GetVirtualEnvPath());
}
if (isInstalled)
{
m_PythonPath = QmitkSetupVirtualEnvUtil::GetExactPythonPath(m_Installer.GetVirtualEnvPath()).first;
this->WriteStatusMessage("<b>STATUS: </b>Successfully installed SAM.");
}
else
{
this->WriteErrorMessage("<b>ERROR: </b>Couldn't install SAM.");
m_Ui->installSAMButton->setEnabled(true);
}
}
void QmitkSegmentAnythingPreferencePage::OnClearInstall()
{
QDir folderPath(m_Installer.GetVirtualEnvPath());
bool isDeleted = folderPath.removeRecursively();
if (isDeleted)
{
this->WriteStatusMessage("Deleted SAM installation.");
m_Ui->installSAMButton->setEnabled(true);
m_PythonPath.clear();
}
else
{
MITK_ERROR << "The virtual environment couldn't be removed. Please check if you have the required access "
"privileges or, some other process is accessing the folders.";
}
}
void QmitkSegmentAnythingPreferencePage::WriteStatusMessage(const QString &message)
{
m_Ui->samInstallStatusLabel->setText(message);
m_Ui->samInstallStatusLabel->setStyleSheet("font-weight: bold; color: white");
qApp->processEvents();
}
void QmitkSegmentAnythingPreferencePage::WriteErrorMessage(const QString &message)
{
m_Ui->samInstallStatusLabel->setText(message);
m_Ui->samInstallStatusLabel->setStyleSheet("font-weight: bold; color: red");
qApp->processEvents();
}
QString QmitkSAMInstaller::GetVirtualEnvPath()
{
return STORAGE_DIR + VENV_NAME;
}
bool QmitkSAMInstaller::SetupVirtualEnv(const QString &venvName)
{
if (GetSystemPythonPath().isEmpty())
{
return false;
}
QDir folderPath(GetBaseDir());
folderPath.mkdir(venvName);
if (!folderPath.cd(venvName))
{
return false; // Check if directory creation was successful.
}
mitk::ProcessExecutor::ArgumentListType args;
auto spExec = mitk::ProcessExecutor::New();
auto spCommand = itk::CStyleCommand::New();
spCommand->SetCallback(&PrintProcessEvent);
spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
args.push_back("-m");
args.push_back("venv");
args.push_back(venvName.toStdString());
#ifdef _WIN32
QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python.exe";
QString pythonExeFolder = "Scripts";
#else
QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python3";
QString pythonExeFolder = "bin";
#endif
spExec->Execute(GetBaseDir().toStdString(), pythonFile.toStdString(), args); // Setup local virtual environment
if (folderPath.cd(pythonExeFolder))
{
this->SetPythonPath(folderPath.absolutePath());
this->SetPipPath(folderPath.absolutePath());
this->InstallPytorch();
for (auto &package : PACKAGES)
{
this->PipInstall(package.toStdString(), &PrintProcessEvent);
}
std::string pythonCode; // python syntax to check if torch is installed with CUDA.
pythonCode.append("import torch;");
pythonCode.append("print('Pytorch was installed with CUDA') if torch.cuda.is_available() else print('PyTorch was "
"installed WITHOUT CUDA');");
this->ExecutePython(pythonCode, &PrintProcessEvent);
return true;
}
return false;
}
diff --git a/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp b/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp
index e330be3d14..d759e669c0 100644
--- a/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp
+++ b/Plugins/org.mitk.matchpoint.core.helper/src/internal/MatchPointBrowserPreferencesPage.cpp
@@ -1,158 +1,158 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "MatchPointBrowserPreferencesPage.h"
#include "MatchPointBrowserConstants.h"
#include <QWidget>
#include <QLabel>
#include <QFormLayout>
#include <QCheckBox>
#include <QComboBox>
#include <QMessageBox>
#include <QSpinBox>
#include <ctkDirectoryButton.h>
#include <mitkCoreServices.h>
#include <mitkIPreferencesService.h>
#include <mitkIPreferences.h>
#include "QmitkDirectoryListWidget.h"
#include "QmitkFileListWidget.h"
namespace
{
mitk::IPreferences* GetPreferences()
{
auto* preferencesService = mitk::CoreServices::GetPreferencesService();
return preferencesService->GetSystemPreferences()->Node(MatchPointBrowserConstants::VIEW_ID);
}
}
//-----------------------------------------------------------------------------
MatchPointBrowserPreferencesPage::MatchPointBrowserPreferencesPage()
: m_MainControl(nullptr)
, m_AlgDirectories(nullptr)
, m_AlgFiles(nullptr)
, m_LoadFromHomeDir(nullptr)
, m_LoadFromCurrentDir(nullptr)
, m_LoadFromApplicationDir(nullptr)
, m_LoadFromAutoLoadPathDir(nullptr)
{
}
//-----------------------------------------------------------------------------
MatchPointBrowserPreferencesPage::~MatchPointBrowserPreferencesPage()
{
}
//-----------------------------------------------------------------------------
void MatchPointBrowserPreferencesPage::Init(berry::IWorkbench::Pointer )
{
}
//-----------------------------------------------------------------------------
void MatchPointBrowserPreferencesPage::CreateQtControl(QWidget* parent)
{
m_MainControl = new QWidget(parent);
m_AlgDirectories = new QmitkDirectoryListWidget(m_MainControl);
m_AlgDirectories->m_Label->setText("Select directories to scan:");
m_AlgFiles = new QmitkFileListWidget(m_MainControl);
m_AlgFiles->m_Label->setText("Select additional executables:");
m_DebugOutput = new QCheckBox(m_MainControl);
m_LoadFromAutoLoadPathDir = new QCheckBox(m_MainControl);
m_LoadFromApplicationDir = new QCheckBox(m_MainControl);
m_LoadFromHomeDir = new QCheckBox(m_MainControl);
m_LoadFromCurrentDir = new QCheckBox(m_MainControl);
QFormLayout *formLayout = new QFormLayout;
formLayout->addRow("show debug output:", m_DebugOutput);
formLayout->addRow("scan home directory:", m_LoadFromHomeDir);
formLayout->addRow("scan current directory:", m_LoadFromCurrentDir);
formLayout->addRow("scan installation directory:", m_LoadFromApplicationDir);
formLayout->addRow("scan MAP_MDRA_LOAD_PATH:", m_LoadFromAutoLoadPathDir);
formLayout->addRow("additional algorithm directories:", m_AlgDirectories);
formLayout->addRow("additional algorithms:", m_AlgFiles);
m_MainControl->setLayout(formLayout);
this->Update();
}
//-----------------------------------------------------------------------------
QWidget* MatchPointBrowserPreferencesPage::GetQtControl() const
{
return m_MainControl;
}
//-----------------------------------------------------------------------------
std::string MatchPointBrowserPreferencesPage::ConvertToString( const QStringList& list )
{
return list.join(';').toStdString();
}
//-----------------------------------------------------------------------------
bool MatchPointBrowserPreferencesPage::PerformOk()
{
auto* prefs = GetPreferences();
prefs->PutBool(MatchPointBrowserConstants::DEBUG_OUTPUT_NODE_NAME, m_DebugOutput->isChecked());
prefs->PutBool(MatchPointBrowserConstants::LOAD_FROM_APPLICATION_DIR, m_LoadFromApplicationDir->isChecked());
prefs->PutBool(MatchPointBrowserConstants::LOAD_FROM_HOME_DIR, m_LoadFromHomeDir->isChecked());
prefs->PutBool(MatchPointBrowserConstants::LOAD_FROM_CURRENT_DIR, m_LoadFromCurrentDir->isChecked());
prefs->PutBool(MatchPointBrowserConstants::LOAD_FROM_AUTO_LOAD_DIR, m_LoadFromAutoLoadPathDir->isChecked());
const auto paths = this->ConvertToString(m_AlgDirectories->directories());
prefs->Put(MatchPointBrowserConstants::MDAR_DIRECTORIES_NODE_NAME, paths);
const auto modules = this->ConvertToString(m_AlgFiles->files());
prefs->Put(MatchPointBrowserConstants::MDAR_FILES_NODE_NAME, modules);
return true;
}
//-----------------------------------------------------------------------------
void MatchPointBrowserPreferencesPage::PerformCancel()
{
}
//-----------------------------------------------------------------------------
void MatchPointBrowserPreferencesPage::Update()
{
auto* prefs = GetPreferences();
m_DebugOutput->setChecked(prefs->GetBool(MatchPointBrowserConstants::DEBUG_OUTPUT_NODE_NAME, false));
m_LoadFromApplicationDir->setChecked(prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_APPLICATION_DIR, true));
m_LoadFromHomeDir->setChecked(prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_HOME_DIR, false));
m_LoadFromCurrentDir->setChecked(prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_CURRENT_DIR, false));
m_LoadFromAutoLoadPathDir->setChecked(prefs->GetBool(MatchPointBrowserConstants::LOAD_FROM_AUTO_LOAD_DIR, false));
QString paths = QString::fromStdString(prefs->Get(MatchPointBrowserConstants::MDAR_DIRECTORIES_NODE_NAME, ""));
- QStringList directoryList = paths.split(";", QString::SkipEmptyParts);
+ QStringList directoryList = paths.split(";", Qt::SkipEmptyParts);
m_AlgDirectories->setDirectories(directoryList);
QString files = QString::fromStdString(prefs->Get(MatchPointBrowserConstants::MDAR_FILES_NODE_NAME, ""));
- QStringList fileList = files.split(";", QString::SkipEmptyParts);
+ QStringList fileList = files.split(";", Qt::SkipEmptyParts);
m_AlgFiles->setFiles(fileList);
}