mitk: QmitkFunctionality.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003  Program:   Medical Imaging & Interaction Toolkit
00004  Language:  C++
00005  Date:      $Date$
00006  Version:   $Revision$
00007 
00008  Copyright (c) German Cancer Research Center, Division of Medical and
00009  Biological Informatics. All rights reserved.
00010  See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012  This software is distributed WITHOUT ANY WARRANTY; without even
00013  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014  PURPOSE.  See the above copyright notices for more information.
00015 
00016  =========================================================================*/
00017 
00018 #include "QmitkFunctionality.h"
00019 
00020 // other includes
00021 #include "mitkLogMacros.h"
00022 
00023 // mitk Includes
00024 #include "mitkMessage.h"
00025 #include "mitkIDataStorageService.h"
00026 #include "mitkDataStorageEditorInput.h"
00027 #include <mitkDataNodeObject.h>
00028 
00029 // berry Includes
00030 #include <berryPlatform.h>
00031 #include <berryIWorkbenchPage.h>
00032 
00033 // Qmitk Includes
00034 #include <QmitkStdMultiWidgetEditor.h>
00035 
00036 // Qt Includes
00037 #include <QMessageBox>
00038 #include <QScrollArea>
00039 #include <QVBoxLayout>
00040 
00041 QmitkFunctionality::QmitkFunctionality()
00042  : m_Parent(0)
00043  , m_Active(false)
00044  , m_Visible(false)
00045  , m_SelectionProvider(0)
00046  , m_HandlesMultipleDataStorages(false)
00047  , m_InDataStorageChanged(false)
00048 {
00049   m_PreferencesService = 
00050     berry::Platform::GetServiceRegistry().GetServiceById<berry::IPreferencesService>(berry::IPreferencesService::ID);
00051 }
00052   
00053 void QmitkFunctionality::SetHandleMultipleDataStorages(bool multiple)
00054 {
00055   m_HandlesMultipleDataStorages = multiple;
00056 }
00057 
00058 bool QmitkFunctionality::HandlesMultipleDataStorages() const
00059 {
00060   return m_HandlesMultipleDataStorages;
00061 }
00062   
00063 mitk::DataStorage::Pointer 
00064 QmitkFunctionality::GetDataStorage() const
00065 {
00066   mitk::IDataStorageService::Pointer service = 
00067     berry::Platform::GetServiceRegistry().GetServiceById<mitk::IDataStorageService>(mitk::IDataStorageService::ID);
00068   
00069   if (service.IsNotNull())
00070   {
00071     if (m_HandlesMultipleDataStorages)
00072       return service->GetActiveDataStorage()->GetDataStorage();
00073     else
00074       return service->GetDefaultDataStorage()->GetDataStorage();
00075   }
00076   
00077   return 0;
00078 }
00079 
00080 
00081 mitk::DataStorage::Pointer QmitkFunctionality::GetDefaultDataStorage() const
00082 {
00083   mitk::IDataStorageService::Pointer service = 
00084     berry::Platform::GetServiceRegistry().GetServiceById<mitk::IDataStorageService>(mitk::IDataStorageService::ID);
00085 
00086   return service->GetDefaultDataStorage()->GetDataStorage();
00087 }
00088 
00089 void QmitkFunctionality::CreatePartControl(void* parent)
00090 {
00091 
00092   // scrollArea
00093   QScrollArea* scrollArea = new QScrollArea;  
00094   //QVBoxLayout* scrollAreaLayout = new QVBoxLayout(scrollArea);
00095   scrollArea->setFrameShadow(QFrame::Plain);
00096   scrollArea->setFrameShape(QFrame::NoFrame);
00097   scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
00098   scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
00099 
00100   // m_Parent
00101   m_Parent = new QWidget;
00102   //m_Parent->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
00103   this->CreateQtPartControl(m_Parent);
00104 
00105   //scrollAreaLayout->addWidget(m_Parent);
00106   //scrollArea->setLayout(scrollAreaLayout);
00107 
00108   // set the widget now
00109   scrollArea->setWidgetResizable(true);
00110   scrollArea->setWidget(m_Parent);
00111 
00112   // add the scroll area to the real parent (the view tabbar)
00113   QWidget* parentQWidget = static_cast<QWidget*>(parent);
00114   QVBoxLayout* parentLayout = new QVBoxLayout(parentQWidget);
00115   parentLayout->setMargin(0);
00116   parentLayout->setSpacing(0);
00117   parentLayout->addWidget(scrollArea);
00118 
00119   // finally set the layout containing the scroll area to the parent widget (= show it)
00120   parentQWidget->setLayout(parentLayout);
00121 
00122   this->AfterCreateQtPartControl();
00123 }
00124 
00125 void QmitkFunctionality::AfterCreateQtPartControl()
00126 {
00127   // REGISTER DATASTORAGE LISTENER
00128   this->GetDefaultDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
00129     ( this, &QmitkFunctionality::NodeAddedProxy ) );
00130   this->GetDefaultDataStorage()->ChangedNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
00131     ( this, &QmitkFunctionality::NodeChangedProxy ) );
00132   this->GetDefaultDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
00133     ( this, &QmitkFunctionality::NodeRemovedProxy ) );
00134 
00135   // REGISTER PREFERENCES LISTENER
00136   berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
00137   if(prefs.IsNotNull())
00138     prefs->OnChanged.AddListener(berry::MessageDelegate1<QmitkFunctionality
00139     , const berry::IBerryPreferences*>(this, &QmitkFunctionality::OnPreferencesChanged));
00140 
00141   // REGISTER FOR WORKBENCH SELECTION EVENTS
00142   m_BlueBerrySelectionListener = berry::ISelectionListener::Pointer(new berry::SelectionChangedAdapter<QmitkFunctionality>(this
00143     , &QmitkFunctionality::BlueBerrySelectionChanged));
00144   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_BlueBerrySelectionListener);
00145 
00146   // REGISTER A SELECTION PROVIDER
00147   QmitkFunctionality::SelectionProvider::Pointer _SelectionProvider
00148     = QmitkFunctionality::SelectionProvider::New(this);
00149   m_SelectionProvider = _SelectionProvider.GetPointer();
00150   this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(m_SelectionProvider));
00151   
00152   // EMULATE INITIAL SELECTION EVENTS
00153 
00154   // by default a a multi widget is always available
00155   this->StdMultiWidgetAvailable(*this->GetActiveStdMultiWidget());
00156 
00157   // send datamanager selection
00158   this->OnSelectionChanged(this->GetDataManagerSelection());
00159 
00160   // send preferences changed event
00161   this->OnPreferencesChanged(this->GetPreferences().Cast<berry::IBerryPreferences>().GetPointer());
00162 }
00163 
00164 void QmitkFunctionality::ClosePart()
00165 {
00166 
00167 }
00168 
00169 void QmitkFunctionality::ClosePartProxy()
00170 {
00171   this->GetDefaultDataStorage()->AddNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
00172     ( this, &QmitkFunctionality::NodeAddedProxy ) );
00173   this->GetDefaultDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
00174     ( this, &QmitkFunctionality::NodeRemovedProxy) );
00175   this->GetDefaultDataStorage()->ChangedNodeEvent.RemoveListener( mitk::MessageDelegate1<QmitkFunctionality, const mitk::DataNode*>
00176     ( this, &QmitkFunctionality::NodeChangedProxy ) );
00177 
00178   berry::IBerryPreferences::Pointer prefs = this->GetPreferences().Cast<berry::IBerryPreferences>();
00179   if(prefs.IsNotNull())
00180   {
00181     prefs->OnChanged.RemoveListener(berry::MessageDelegate1<QmitkFunctionality
00182     , const berry::IBerryPreferences*>(this, &QmitkFunctionality::OnPreferencesChanged));
00183     // flush the preferences here (disabled, everyone should flush them by themselves at the right moment)
00184     // prefs->Flush();
00185   }
00186 
00187   // REMOVE SELECTION PROVIDER
00188   this->GetSite()->SetSelectionProvider(berry::ISelectionProvider::Pointer(NULL));
00189 
00190   berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
00191   if(s)
00192   {
00193     s->RemovePostSelectionListener(m_BlueBerrySelectionListener);
00194   }
00195 
00196     this->ClosePart();
00197 }
00198 
00199 QmitkFunctionality::~QmitkFunctionality()
00200 {
00201   this->Register();
00202   this->ClosePartProxy();
00203 
00204   this->UnRegister(false);
00205 }
00206 
00207 std::vector<mitk::DataNode*> QmitkFunctionality::GetCurrentSelection() const
00208 {
00209   berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection());
00210   // buffer for the data manager selection
00211   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
00212   return this->DataNodeSelectionToVector(currentSelection);
00213 }
00214 
00215 std::vector<mitk::DataNode*> QmitkFunctionality::GetDataManagerSelection() const
00216 {
00217   berry::ISelection::ConstPointer selection( this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
00218     // buffer for the data manager selection
00219   mitk::DataNodeSelection::ConstPointer currentSelection = selection.Cast<const mitk::DataNodeSelection>();
00220   return this->DataNodeSelectionToVector(currentSelection);
00221 }
00222 
00223 void QmitkFunctionality::OnPreferencesChanged( const berry::IBerryPreferences* )
00224 {
00225 }
00226 
00227 void QmitkFunctionality::OnSelectionChanged(std::vector<mitk::DataNode*> /*nodes*/)
00228 {
00229 }
00230 
00231 void QmitkFunctionality::BlueBerrySelectionChanged(berry::IWorkbenchPart::Pointer sourcepart, berry::ISelection::ConstPointer selection)
00232 {
00233   if(sourcepart.IsNull() || sourcepart->GetSite()->GetId() != "org.mitk.views.datamanager")
00234     return;
00235 
00236   mitk::DataNodeSelection::ConstPointer _DataNodeSelection 
00237     = selection.Cast<const mitk::DataNodeSelection>();
00238   this->OnSelectionChanged(this->DataNodeSelectionToVector(_DataNodeSelection));
00239 }
00240 
00241 
00242 std::vector<mitk::DataNode*> QmitkFunctionality::DataNodeSelectionToVector(mitk::DataNodeSelection::ConstPointer currentSelection) const
00243 {
00244 
00245   std::vector<mitk::DataNode*> selectedNodes;
00246   if(currentSelection.IsNull())
00247     return selectedNodes;
00248 
00249   mitk::DataNodeObject* _DataNodeObject = 0;
00250   mitk::DataNode* _DataNode = 0;
00251 
00252   for(mitk::DataNodeSelection::iterator it = currentSelection->Begin();
00253     it != currentSelection->End(); ++it)
00254   {
00255     _DataNodeObject = dynamic_cast<mitk::DataNodeObject*>((*it).GetPointer());
00256     if(_DataNodeObject)
00257     {
00258       _DataNode = _DataNodeObject->GetDataNode();
00259       if(_DataNode)
00260         selectedNodes.push_back(_DataNode);
00261     }
00262   }
00263 
00264   return selectedNodes;
00265 }
00266 
00267 bool QmitkFunctionality::IsVisible() const
00268 {
00269   return m_Visible;
00270 }
00271 
00272 void QmitkFunctionality::SetFocus()
00273 {
00274 }
00275 
00276 void QmitkFunctionality::Activated()
00277 {
00278 }
00279 
00280 void QmitkFunctionality::Deactivated()
00281 {
00282 }
00283 
00284 void QmitkFunctionality::StdMultiWidgetAvailable( QmitkStdMultiWidget&  /*stdMultiWidget*/ )
00285 {
00286 }
00287 void QmitkFunctionality::StdMultiWidgetNotAvailable()
00288 {
00289 }
00290 
00291 void QmitkFunctionality::NodeAddedProxy( const mitk::DataNode* node )
00292 {
00293   // garantuee no recursions when a new node event is thrown in NodeAdded()
00294   if(!m_InDataStorageChanged)
00295   {
00296     m_InDataStorageChanged = true;
00297     this->NodeAdded(node);
00298     this->DataStorageChanged();
00299     m_InDataStorageChanged = false;
00300   }
00301 
00302 }
00303 
00304 void QmitkFunctionality::NodeAdded( const mitk::DataNode*  /*node*/ )
00305 {
00306 
00307 }
00308 
00309 void QmitkFunctionality::NodeRemovedProxy( const mitk::DataNode* node )
00310 {
00311   // garantuee no recursions when a new node event is thrown in NodeAdded()
00312   if(!m_InDataStorageChanged)
00313   {
00314     m_InDataStorageChanged = true;
00315     this->NodeRemoved(node);
00316     this->DataStorageChanged();
00317     m_InDataStorageChanged = false;
00318   }
00319 }
00320 
00321 void QmitkFunctionality::NodeRemoved( const mitk::DataNode*  /*node*/ )
00322 {
00323 
00324 }
00325 
00326 void QmitkFunctionality::DataStorageChanged()
00327 {
00328 
00329 }
00330 
00331 QmitkStdMultiWidget* QmitkFunctionality::GetActiveStdMultiWidget()
00332 {
00333   QmitkStdMultiWidget* activeStdMultiWidget = 0;
00334   berry::IEditorPart::Pointer editor =
00335     this->GetSite()->GetPage()->GetActiveEditor();
00336 
00337   if (editor.Cast<QmitkStdMultiWidgetEditor>().IsNotNull())
00338   {
00339     activeStdMultiWidget = editor.Cast<QmitkStdMultiWidgetEditor>()->GetStdMultiWidget();
00340   }
00341   else
00342   {
00343     mitk::DataStorageEditorInput::Pointer editorInput;
00344     editorInput = new mitk::DataStorageEditorInput();
00345     // open a new multi-widget editor, but do not give it the focus
00346     berry::IEditorPart::Pointer editor = this->GetSite()->GetPage()->OpenEditor(editorInput, QmitkStdMultiWidgetEditor::EDITOR_ID, false);
00347     activeStdMultiWidget = editor.Cast<QmitkStdMultiWidgetEditor>()->GetStdMultiWidget();
00348   }
00349 
00350   return activeStdMultiWidget;
00351 }
00352 
00353 void QmitkFunctionality::HandleException( const char* str, QWidget* parent, bool showDialog ) const
00354 {
00355   //itkGenericOutputMacro( << "Exception caught: " << str );
00356   MITK_ERROR << str;
00357   if ( showDialog )
00358   {
00359     QMessageBox::critical ( parent, "Exception caught!", str );
00360   }
00361 }
00362 
00363 
00364 void QmitkFunctionality::HandleException( std::exception& e, QWidget* parent, bool showDialog ) const
00365 {
00366   HandleException( e.what(), parent, showDialog );
00367 }
00368 
00369 void QmitkFunctionality::StdMultiWidgetClosed( QmitkStdMultiWidget&  /*stdMultiWidget*/ )
00370 {
00371   
00372 }
00373 
00374 void QmitkFunctionality::WaitCursorOn()
00375 {
00376   QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
00377 }
00378 
00379 void QmitkFunctionality::BusyCursorOn()
00380 {
00381   QApplication::setOverrideCursor( QCursor(Qt::BusyCursor) );
00382 }
00383 
00384 void QmitkFunctionality::WaitCursorOff()
00385 {
00386   this->RestoreOverrideCursor();
00387 }
00388 
00389 void QmitkFunctionality::BusyCursorOff()
00390 {
00391   this->RestoreOverrideCursor();
00392 }
00393 
00394 void QmitkFunctionality::RestoreOverrideCursor()
00395 {
00396   QApplication::restoreOverrideCursor();
00397 }
00398 
00399 berry::IPreferences::Pointer QmitkFunctionality::GetPreferences() const
00400 {
00401   berry::IPreferencesService::Pointer prefService = m_PreferencesService.Lock();
00402   // const_cast workaround for bad programming: const uncorrectness this->GetViewSite() should be const
00403   std::string id = "/" + (const_cast<QmitkFunctionality*>(this))->GetViewSite()->GetId();
00404   return prefService.IsNotNull() ? prefService->GetSystemPreferences()->Node(id): berry::IPreferences::Pointer(0);
00405 }
00406 
00407 void QmitkFunctionality::Visible()
00408 {
00409 
00410 }
00411 
00412 void QmitkFunctionality::Hidden()
00413 {
00414 
00415 }
00416 
00417 void QmitkFunctionality::NodeChanged( const mitk::DataNode* /*node*/ )
00418 {
00419 
00420 }
00421 
00422 void QmitkFunctionality::NodeChangedProxy( const mitk::DataNode* node )
00423 {
00424   // garantuee no recursions when a new node event is thrown in NodeAdded()
00425   if(!m_InDataStorageChanged)
00426   {
00427     m_InDataStorageChanged = true;
00428     this->NodeChanged(node);
00429     this->DataStorageChanged();
00430     m_InDataStorageChanged = false;
00431   }
00432 }
00433 
00434 bool QmitkFunctionality::IsExclusiveFunctionality() const
00435 {
00436   return true;
00437 }
00438 
00439 void QmitkFunctionality::SetVisible( bool visible )
00440 {
00441   m_Visible = visible;
00442 }
00443 
00444 void QmitkFunctionality::SetActivated( bool activated )
00445 {
00446   m_Active = activated;
00447 }
00448 
00449 bool QmitkFunctionality::IsActivated() const
00450 {
00451   return m_Active;
00452 }
00453 
00454 QmitkFunctionality::SelectionProvider::SelectionProvider( QmitkFunctionality* _Functionality )
00455 : m_Functionality(_Functionality)
00456 {
00457 
00458 }
00459 
00460 QmitkFunctionality::SelectionProvider::~SelectionProvider()
00461 {
00462   m_Functionality = 0;
00463 }
00464 
00465 void QmitkFunctionality::SelectionProvider::AddSelectionChangedListener( berry::ISelectionChangedListener::Pointer listener )
00466 {
00467   m_SelectionEvents.AddListener(listener);
00468 }
00469 
00470 
00471 berry::ISelection::ConstPointer QmitkFunctionality::SelectionProvider::GetSelection() const
00472 {
00473   return m_CurrentSelection;
00474 }
00475 
00476 void QmitkFunctionality::SelectionProvider::RemoveSelectionChangedListener( berry::ISelectionChangedListener::Pointer listener )
00477 {
00478   m_SelectionEvents.RemoveListener(listener);
00479 }
00480 
00481 void QmitkFunctionality::SelectionProvider::SetSelection( berry::ISelection::Pointer selection )
00482 {
00483   m_CurrentSelection = selection.Cast<mitk::DataNodeSelection>();
00484 }
00485 
00486 void QmitkFunctionality::SelectionProvider::FireNodesSelected( std::vector<mitk::DataNode::Pointer> nodes )
00487 {
00488   mitk::DataNodeSelection::Pointer sel(new mitk::DataNodeSelection(nodes));
00489   m_CurrentSelection = sel;
00490   berry::SelectionChangedEvent::Pointer event(new berry::SelectionChangedEvent(berry::ISelectionProvider::Pointer(this)
00491     , m_CurrentSelection));
00492   m_SelectionEvents.selectionChanged(event);
00493 
00494 }
00495 
00496 void QmitkFunctionality::FireNodeSelected( mitk::DataNode* node )
00497 {
00498   std::vector<mitk::DataNode*> nodes;
00499   nodes.push_back(node);
00500   this->FireNodesSelected(nodes);
00501 }
00502 
00503 void QmitkFunctionality::FireNodesSelected( std::vector<mitk::DataNode*> nodes )
00504 {
00505   if( !m_SelectionProvider )
00506     return;
00507 
00508   std::vector<mitk::DataNode::Pointer> nodesSmartPointers;
00509   for (std::vector<mitk::DataNode*>::iterator it = nodes.begin()
00510     ; it != nodes.end(); it++)
00511   {
00512     nodesSmartPointers.push_back( *it );
00513   }
00514   m_SelectionProvider->FireNodesSelected(nodesSmartPointers);
00515 
00516 }