void QtWorkbenchAdvisor::Initialize(IWorkbenchConfigurer::Pointer configurer)
{
WorkbenchAdvisor::Initialize(configurer);
IPreferencesService* prefService = WorkbenchPlugin::GetDefault()->GetPreferencesService();
IPreferences::Pointer prefs = prefService->GetSystemPreferences()->Node(QtPreferences::QT_STYLES_NODE);
QString styleName = prefs->Get(QtPreferences::QT_STYLE_NAME, "");
ctkServiceReference serviceRef = WorkbenchPlugin::GetDefault()->GetPluginContext()->getServiceReference<IQtStyleManager>();
if (serviceRef)
{
IQtStyleManager* styleManager = WorkbenchPlugin::GetDefault()->GetPluginContext()->getService<IQtStyleManager>(serviceRef);
styleManager->SetStyle(styleName);
}
QObject* eventFilter = new QtGlobalEventFilter(qApp);
qApp->installEventFilter(eventFilter);
}
void QtStyleManager::ReadPreferences()
{
IPreferencesService* prefService = WorkbenchPlugin::GetDefault()->GetPreferencesService();
IPreferences::Pointer stylePref = prefService->GetSystemPreferences()->Node(QtPreferences::QT_STYLES_NODE);
QString paths = stylePref->Get(QtPreferences::QT_STYLE_SEARCHPATHS, "");
QStringList pathList = paths.split(";", QString::SkipEmptyParts);
QStringListIterator it(pathList);
while (it.hasNext())
{
AddStyles(it.next());
}
QString styleName = 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))
// do not update the style in the QApplication instance,
// since it might not be created yet
SetStyle(styleName, false);
else
SetDefaultStyle(false);
}
void PreferencesTest::TestAll()
{
IPreferencesService::Pointer prefService = Platform::GetServiceRegistry().GetServiceById<IPreferencesService>(IPreferencesService::ID);
assert(prefService.IsNotNull());
/// Test for: IPreferences::GetSystemPreferences()
IPreferences::Pointer root = prefService->GetSystemPreferences();
assert(root.IsNotNull());
{
BERRY_INFO << "testing Preferences::Node(), Preferences::NodeExists(), Preferences::Parent(), "
"Preferences::ChildrenNames(), Preferences::RemoveNode()";
berry::IPreferences::Pointer editorsNode(0);
editorsNode = root->Node("/editors");
assert(editorsNode.IsNotNull());
assert(editorsNode->NodeExists("/editors"));
assert(editorsNode->Parent() == root);
berry::IPreferences::Pointer editorsGeneralNode = root->Node("/editors/general");
assert(editorsNode->NodeExists("/editors/general"));
berry::IPreferences::Pointer editorsSyntaxNode = root->Node("/editors/syntax");
assert(editorsGeneralNode->NodeExists("/editors/syntax"));
berry::IPreferences::Pointer editorsFontNode = root->Node("/editors/font");
assert(editorsSyntaxNode->NodeExists("/editors/font"));
vector<string> childrenNames;
childrenNames.push_back("general");
childrenNames.push_back("syntax");
childrenNames.push_back("font");
assert(editorsNode->ChildrenNames() == childrenNames);
editorsFontNode->RemoveNode();
try {
editorsFontNode->Parent();
failmsg("this should throw a Poco::IllegalStateException");
}
catch (Poco::IllegalStateException)
{
// expected
}
}
// testing methods
// Preferences::put*()
// Preferences::get*()
{
BERRY_INFO << "testing Preferences::put*(), Preferences::get*(), OnChanged";
assert(root->NodeExists("/editors/general"));
berry::IPreferences::Pointer editorsGeneralNode = root->Node("/editors/general");
IBerryPreferences::Pointer berryEditorsGeneralNode = editorsGeneralNode.Cast< IBerryPreferences >();
assert(berryEditorsGeneralNode.IsNotNull());
TestPreferencesChangedListener listener(berryEditorsGeneralNode.GetPointer());
std::string strKey = "Bad words";std::string strValue = "badword1 badword2";
editorsGeneralNode->Put(strKey, strValue);
assert(listener.numCalled == 1);
assert(editorsGeneralNode->Get(strKey, "") == strValue);
assert(editorsGeneralNode->Get("wrong key", "default value") == "default value");
strKey = "Show Line Numbers";bool bValue = true;
editorsGeneralNode->PutBool(strKey, bValue);
assert(listener.numCalled == 2);
assert(editorsGeneralNode->GetBool(strKey, !bValue) == bValue);
strKey = "backgroundcolor"; strValue = "#00FF00";
editorsGeneralNode->PutByteArray(strKey, strValue);
assert(listener.numCalled == 3);
assert(editorsGeneralNode->GetByteArray(strKey, "") == strValue);
strKey = "update time"; double dValue = 1.23;
editorsGeneralNode->PutDouble(strKey, dValue);
assert(editorsGeneralNode->GetDouble(strKey, 0.0) == dValue);
strKey = "update time float"; float fValue = 1.23f;
editorsGeneralNode->PutFloat(strKey, fValue);
assert(editorsGeneralNode->GetFloat(strKey, 0.0f) == fValue);
strKey = "Break on column"; int iValue = 80;
editorsGeneralNode->PutInt(strKey, iValue);
assert(editorsGeneralNode->GetInt(strKey, 0) == iValue);
strKey = "Maximum number of words"; long lValue = 11000000;
editorsGeneralNode->PutLong(strKey, lValue);
assert(editorsGeneralNode->GetLong(strKey, 0) == lValue);
}
}
void QmitkCreatePolygonModelAction::Run(const QList<DataNode::Pointer> &selectedNodes)
{
DataNode::Pointer selectedNode = selectedNodes[0];
Image::Pointer image = dynamic_cast<mitk::Image *>(selectedNode->GetData());
if (image.IsNull())
{
return;
}
try
{
// Get preference properties for smoothing and decimation
IPreferencesService::Pointer prefService = Platform::GetServiceRegistry().GetServiceById<IPreferencesService>(IPreferencesService::ID);
IPreferences::Pointer segPref = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation");
bool smoothingHint = segPref->GetBool("smoothing hint", true);
ScalarType smoothing = segPref->GetDouble("smoothing value", 1.0);
ScalarType decimation = segPref->GetDouble("decimation rate", 0.5);
if (smoothingHint)
{
smoothing = 0.0;
Vector3D spacing = image->GetGeometry()->GetSpacing();
for (Vector3D::Iterator iter = spacing.Begin(); iter != spacing.End(); ++iter)
smoothing = max(smoothing, *iter);
}
ShowSegmentationAsSurface::Pointer surfaceFilter = ShowSegmentationAsSurface::New();
// Activate callback functions
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer successCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer errorCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ProcessingError(), errorCommand);
// set filter parameter
surfaceFilter->SetDataStorage(*m_DataStorage);
surfaceFilter->SetPointerParameter("Input", image);
surfaceFilter->SetPointerParameter("Group node", selectedNode);
surfaceFilter->SetParameter("Show result", true);
surfaceFilter->SetParameter("Sync visibility", false);
surfaceFilter->SetParameter("Median kernel size", 3u);
surfaceFilter->SetParameter("Decimate mesh", m_IsDecimated);
surfaceFilter->SetParameter("Decimation rate", (float) decimation);
if (m_IsSmoothed)
{
surfaceFilter->SetParameter("Apply median", true);
surfaceFilter->SetParameter("Smooth", true);
surfaceFilter->SetParameter("Gaussian SD", sqrtf(smoothing)); // use sqrt to account for setting of variance in preferences
StatusBar::GetInstance()->DisplayText("Smoothed surface creation started in background...");
}
else
{
surfaceFilter->SetParameter("Apply median", false);
surfaceFilter->SetParameter("Smooth", false);
StatusBar::GetInstance()->DisplayText("Surface creation started in background...");
}
surfaceFilter->StartAlgorithm();
}
catch(...)
{
MITK_ERROR << "Surface creation failed!";
}
}
void PreferencesServiceTest::TestAll()
{
try
{
IPreferencesService::Pointer prefService = Platform::GetServiceRegistry().GetServiceById<IPreferencesService>(IPreferencesService::ID);
assert(prefService.IsNotNull());
/// Test for: IPreferences::GetSystemPreferences()
IPreferences::Pointer sysPrefs = prefService->GetSystemPreferences();
assert(sysPrefs.IsNotNull());
/// Test for: IPreferences::GetUserPreferences(std::string name)
IPreferences::Pointer testUserPrefs = prefService->GetUserPreferences("testUser");
assert(testUserPrefs.IsNotNull());
/// Test for: IPreferences::GetUsers()
std::vector<std::string> userList = prefService->GetUsers();
// userList should now contain "testUser"
bool userListContainsTestUser = false;
for (std::vector<std::string>::iterator it = userList.begin()
; it != userList.end(); it++)
{
if(*it == "testUser")
{
userListContainsTestUser = true;
break;
}
}
assert(userListContainsTestUser);
IBerryPreferencesService::Pointer berryPrefService = prefService.Cast<IBerryPreferencesService>();
// optional test for IBerryPreferencesService
if(berryPrefService.IsNotNull())
{
/// Test for: IBerryPreferencesService::ExportPreferences(Poco::File f, std::string name="")
// write general prefs
std::string sysPrefsExportFilePath = Poco::Path::temp() + Poco::Path::separator() + "systemBerryPreferences";
Poco::File sysPrefsExportFile(sysPrefsExportFilePath);
sysPrefs->PutInt("testNumber", 1);
berryPrefService->ExportPreferences(sysPrefsExportFile);
// assert somethings was written
assert(sysPrefsExportFile.getSize() > 0);
// write testUser prefs
std::string testUserPrefsExportFilePath = Poco::Path::temp() + Poco::Path::separator() + "testUserBerryPreferences";
Poco::File testUserPrefsExportFile(testUserPrefsExportFilePath);
testUserPrefs->PutInt("testNumber", 2);
berryPrefService->ExportPreferences(testUserPrefsExportFile, "testUser");
assert(testUserPrefsExportFile.getSize() > 0);
/// Test for: IBerryPreferencesService::ImportPreferences(Poco::File f, std::string name="")
// import general prefs
// change testNumber value
sysPrefs->PutInt("testNumber", 3);
berryPrefService->ImportPreferences(sysPrefsExportFile);
// "testNumber" preference should now again be overwritten with its old value 1
assert(sysPrefs->GetInt("testNumber", 3) == 1);
// import testUser prefs
// change testNumber value
testUserPrefs->PutInt("testNumber", 4);
berryPrefService->ImportPreferences(testUserPrefsExportFile, "testUser");
// "testNumber" preference should now again be overwritten with its old value 2
assert(testUserPrefs->GetInt("testNumber", 4) == 2);
// delete files again
sysPrefsExportFile.remove();
testUserPrefsExportFile.remove();
}
}
catch (Poco::CreateFileException& e)
{
std::string msg = "Failed to create preferences file: ";
msg.append(e.what());
this->fail( msg );
}
catch (std::exception& e)
{
this->fail( e.what() );
}
catch (...)
{
this->fail( "unknown exception occured" );
}
}
void QmitkCreatePolygonModelAction::Run(const QList<DataNode::Pointer> &selectedNodes)
{
DataNode::Pointer selectedNode = selectedNodes[0];
Image::Pointer image = dynamic_cast<mitk::Image *>(selectedNode->GetData());
if (image.IsNull())
return;
try
{
if (!m_IsSmoothed)
{
ShowSegmentationAsSurface::Pointer surfaceFilter = ShowSegmentationAsSurface::New();
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer successCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer errorCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(ProcessingError(), errorCommand);
surfaceFilter->SetDataStorage(*m_DataStorage);
surfaceFilter->SetPointerParameter("Input", image);
surfaceFilter->SetPointerParameter("Group node", selectedNode);
surfaceFilter->SetParameter("Show result", true);
surfaceFilter->SetParameter("Sync visibility", false);
surfaceFilter->SetParameter("Smooth", false);
surfaceFilter->SetParameter("Apply median", false);
surfaceFilter->SetParameter("Median kernel size", 3u);
surfaceFilter->SetParameter("Gaussian SD", 1.5f);
surfaceFilter->SetParameter("Decimate mesh", m_IsDecimated);
surfaceFilter->SetParameter("Decimation rate", 0.8f);
StatusBar::GetInstance()->DisplayText("Surface creation started in background...");
surfaceFilter->StartAlgorithm();
}
else
{
ShowSegmentationAsSmoothedSurface::Pointer surfaceFilter = ShowSegmentationAsSmoothedSurface::New();
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer successCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
successCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::Pointer errorCommand = itk::SimpleMemberCommand<QmitkCreatePolygonModelAction>::New();
errorCommand->SetCallbackFunction(this, &QmitkCreatePolygonModelAction::OnSurfaceCalculationDone);
surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
surfaceFilter->SetDataStorage(*m_DataStorage);
surfaceFilter->SetPointerParameter("Input", image);
surfaceFilter->SetPointerParameter("Group node", selectedNode);
berry::IWorkbenchPart::Pointer activePart =
berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetActivePage()->GetActivePart();
mitk::IRenderWindowPart* renderPart = dynamic_cast<mitk::IRenderWindowPart*>(activePart.GetPointer());
mitk::SliceNavigationController* timeNavController = 0;
if (renderPart != 0)
{
timeNavController = renderPart->GetRenderingManager()->GetTimeNavigationController();
}
int timeNr = timeNavController != 0 ? timeNavController->GetTime()->GetPos() : 0;
surfaceFilter->SetParameter("TimeNr", timeNr);
IPreferencesService::Pointer prefService = Platform::GetServiceRegistry().GetServiceById<IPreferencesService>(IPreferencesService::ID);
IPreferences::Pointer segPref = prefService->GetSystemPreferences()->Node("/org.mitk.views.segmentation");
bool smoothingHint = segPref->GetBool("smoothing hint", true);
float smoothing = (float)segPref->GetDouble("smoothing value", 1.0);
float decimation = (float)segPref->GetDouble("decimation rate", 0.5);
float closing = (float)segPref->GetDouble("closing ratio", 0.0);
if (smoothingHint)
{
smoothing = 0.0;
Vector3D spacing = image->GetGeometry()->GetSpacing();
for (Vector3D::Iterator iter = spacing.Begin(); iter != spacing.End(); ++iter)
smoothing = max(smoothing, *iter);
}
surfaceFilter->SetParameter("Smoothing", smoothing);
surfaceFilter->SetParameter("Decimation", decimation);
surfaceFilter->SetParameter("Closing", closing);
ProgressBar::GetInstance()->AddStepsToDo(8);
StatusBar::GetInstance()->DisplayText("Smoothed surface creation started in background...");
try {
surfaceFilter->StartAlgorithm();
} catch (...)
{
MITK_ERROR<<"Error creating smoothed polygon model: Not enough memory!";
}
}
}
catch(...)
{
MITK_ERROR << "Surface creation failed!";
}
}