Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "mitkGlobalInteraction.h"
00020 #include "mitkInteractionConst.h"
00021 #include "mitkStateEvent.h"
00022 #include "mitkPositionEvent.h"
00023
00024 #include <itksys/SystemTools.hxx>
00025
00026 #include <vtkWorldPointPicker.h>
00027
00028
00029
00030 mitk::GlobalInteraction::GlobalInteraction()
00031 : StateMachine(NULL)
00032 , m_StateMachineFactory(NULL)
00033 , m_EventMapper(NULL)
00034 , m_CurrentlyInInformListenersLoop(false)
00035 , m_CurrentlyInInformInteractorsLoop(false)
00036 , m_IsInitialized(false)
00037 {
00038 }
00039
00040 mitk::GlobalInteraction::~GlobalInteraction()
00041 {
00042
00043
00044
00045
00046
00047 if (this->IsInitialized())
00048 {
00049 m_StateMachineFactory->Delete();
00050 m_StateMachineFactory = NULL;
00051 m_EventMapper->Delete();
00052 m_EventMapper = NULL;
00053 }
00054 m_ListenerList.clear();
00055 m_InteractorList.clear();
00056 m_SelectedList.clear();
00057 m_JurisdictionMap.clear();
00058 m_FocusManager = NULL;
00059 }
00060
00061
00062 inline mitk::StateEvent* GenerateEmptyStateEvent(int eventId)
00063 {
00064 mitk::Event *noEvent = new mitk::Event(NULL,
00065 mitk::Type_User,
00066 mitk::BS_NoButton,
00067 mitk::BS_NoButton,
00068 mitk::Key_none);
00069 mitk::StateEvent *stateEvent = new mitk::StateEvent(eventId, noEvent);
00070 return stateEvent;
00071 }
00072
00073
00074 void mitk::GlobalInteraction::AddListener(mitk::StateMachine* listener)
00075 {
00076 if(listener == NULL) return;
00077 if(dynamic_cast<Interactor*>(listener)!=NULL)
00078 {
00079 MITK_WARN << "Trying to add an Interactor ("
00080 << listener->GetNameOfClass() << ") as a listener. "
00081 << "This will probably cause problems";
00082 }
00083
00084 if ( std::find(m_ListenerList.begin(), m_ListenerList.end(),listener) == m_ListenerList.end() )
00085 {
00086 m_ListenerList.push_back(listener);
00087 }
00088 }
00089
00090
00091 bool mitk::GlobalInteraction::RemoveListener(mitk::StateMachine* listener)
00092 {
00093
00094 m_ListenersFlaggedForRemoval.push_back(listener);
00095
00096 StateMachineListIter position = std::find(m_ListenerList.begin(), m_ListenerList.end(),listener);
00097 bool removePossible = (position != m_ListenerList.end());
00098
00099 RemoveFlaggedListeners();
00100
00101 return removePossible;
00102 }
00103
00104 void mitk::GlobalInteraction::RemoveFlaggedListeners()
00105 {
00106 if (m_CurrentlyInInformListenersLoop) return;
00107
00108
00109 if (m_ListenersFlaggedForRemoval.empty()) return;
00110
00111 for (StateMachineCPointerListIter it = m_ListenersFlaggedForRemoval.begin(); it != m_ListenersFlaggedForRemoval.end(); ++it)
00112 {
00113 StateMachineListIter foundPosition = std::find( m_ListenerList.begin(), m_ListenerList.end(), *it );
00114 if (foundPosition != m_ListenerList.end())
00115 {
00116 m_ListenerList.erase( foundPosition );
00117 }
00118 }
00119
00120 m_ListenersFlaggedForRemoval.clear();
00121 }
00122
00123 void mitk::GlobalInteraction::AddInteractor(mitk::Interactor* interactor)
00124 {
00125 if(interactor == NULL) return;
00126 if ( std::find(m_InteractorList.begin(), m_InteractorList.end(),interactor) == m_InteractorList.end() )
00127 {
00128 m_InteractorList.push_back(interactor);
00129
00130
00131 if (interactor->GetMode()==Interactor::SMSELECTED)
00132 this->AddToSelectedInteractors(interactor);
00133 }
00134 }
00135
00136 bool mitk::GlobalInteraction::InteractorRegistered (mitk::Interactor* interactor)
00137 {
00138 if ( std::find(m_InteractorList.begin(), m_InteractorList.end(), interactor) == m_InteractorList.end() )
00139 return false;
00140 else
00141 return true;
00142 }
00143
00144 bool mitk::GlobalInteraction::ListenerRegistered (mitk::Interactor* interactor)
00145 {
00146 if ( std::find(m_ListenerList.begin(), m_ListenerList.end(), interactor) == m_ListenerList.end() )
00147 return false;
00148 else
00149 return true;
00150 }
00151
00152 bool mitk::GlobalInteraction::RemoveInteractor(mitk::Interactor* interactor)
00153 {
00154 InteractorListIter position = std::find(m_InteractorList.begin(), m_InteractorList.end(),interactor);
00155 if (position == m_InteractorList.end())
00156 return false;
00157 position = m_InteractorList.erase(position);
00158
00159
00160 this->RemoveFromSelectedInteractors(interactor);
00161
00162
00163 for (InteractorMapIter it = m_JurisdictionMap.begin(); it != m_JurisdictionMap.end(); it++)
00164 {
00165 if ((*it).second == interactor)
00166 {
00167 if (m_CurrentInteractorIter == it)
00168 m_CurrentInteractorIter = m_JurisdictionMap.end();
00169 m_JurisdictionMap.erase(it);
00170 break;
00171 }
00172 }
00173
00174 return true;
00175 }
00176
00177 void mitk::GlobalInteraction::InformListeners(mitk::StateEvent const* stateEvent)
00178 {
00179 m_CurrentlyInInformListenersLoop = true;
00180
00181 for (StateMachineListIter it = m_ListenerList.begin(); it != m_ListenerList.end(); it++)
00182 {
00183 if((*it).IsNotNull())
00184 (*it)->HandleEvent(stateEvent);
00185 }
00186
00187 m_CurrentlyInInformListenersLoop = false;
00188 RemoveFlaggedListeners();
00189 }
00190
00191 bool mitk::GlobalInteraction::AskSelected(mitk::StateEvent const* stateEvent)
00192 {
00193 if (m_SelectedList.empty())
00194 return false;
00195
00196 bool ok = false, oneOk = false;
00197
00198
00199 InteractorList copyOfSelectedList = m_SelectedList;
00200 InteractorListIter it = copyOfSelectedList.begin();
00201
00202 for (; it != copyOfSelectedList.end(); it++)
00203 {
00204 oneOk = (*it)->HandleEvent(stateEvent);
00205
00206
00207 if (oneOk)
00208 ok = true;
00209 }
00210 return ok;
00211 }
00212
00213
00214 void mitk::GlobalInteraction::FillJurisdictionMap(mitk::StateEvent const* stateEvent, float threshold)
00215 {
00216 m_JurisdictionMap.clear();
00217
00218 for (InteractorListIter it = m_InteractorList.begin(); it != m_InteractorList.end(); it++)
00219 {
00220 if ((*it).IsNotNull())
00221 {
00222
00223 float value = (*it)->CanHandleEvent(stateEvent);
00224 if (value > threshold)
00225 {
00226 m_JurisdictionMap.insert(InteractorMap::value_type(value, (*it)));
00227 }
00228 }
00229 }
00230
00231 if (! m_JurisdictionMap.empty())
00232 m_CurrentInteractorIter = m_JurisdictionMap.begin();
00233 else
00234 m_CurrentInteractorIter = m_JurisdictionMap.end();
00235 }
00236
00237
00238
00239
00240
00241
00242 bool mitk::GlobalInteraction::AskCurrentInteractor(mitk::StateEvent const* stateEvent)
00243 {
00244
00245 if (m_JurisdictionMap.empty())
00246 return false;
00247
00248 bool handled = false;
00249 while ( m_CurrentInteractorIter != m_JurisdictionMap.end()&& !handled)
00250 {
00251 handled = (*m_CurrentInteractorIter).second->HandleEvent(stateEvent);
00252
00253 if (!handled)
00254 m_CurrentInteractorIter++;
00255 }
00256
00257
00258 if (m_CurrentInteractorIter == m_JurisdictionMap.end())
00259 m_CurrentInteractorIter = m_JurisdictionMap.begin();
00260 return handled;
00261 }
00262
00263 bool mitk::GlobalInteraction::AddFocusElement(mitk::FocusManager::FocusElement* element)
00264 {
00265 return m_FocusManager->AddElement(element);
00266 }
00267
00268 bool mitk::GlobalInteraction::RemoveFocusElement(mitk::FocusManager::FocusElement* element)
00269 {
00270 return m_FocusManager->RemoveElement(element);
00271 }
00272
00273 mitk::FocusManager::FocusElement* mitk::GlobalInteraction::GetFocus()
00274 {
00275 return m_FocusManager->GetFocused();
00276 }
00277
00278 bool mitk::GlobalInteraction::SetFocus(mitk::FocusManager::FocusElement* element)
00279 {
00280 return m_FocusManager->SetFocused(element);
00281 }
00282
00283 mitk::FocusManager* mitk::GlobalInteraction::GetFocusManager()
00284 {
00285 return m_FocusManager.GetPointer();
00286 }
00287
00288 mitk::EventMapper* mitk::GlobalInteraction::GetEventMapper()
00289 {
00290 if (!this->IsInitialized())
00291 {
00292 MITK_FATAL <<"Global Interaction needs initialization!\n";
00293 return NULL;
00294 }
00295 return m_EventMapper;
00296 }
00297
00298
00299 bool mitk::GlobalInteraction::ExecuteAction(Action* action, mitk::StateEvent const* stateEvent)
00300 {
00301 bool ok = false;
00302
00303 ok = false;
00304 switch (action->GetActionId())
00305 {
00306 case AcDONOTHING:
00307 ok = true;
00308 break;
00309 case AcINFORMLISTENERS:
00310 InformListeners(stateEvent);
00311 ok = true;
00312 break;
00313 case AcASKINTERACTORS:
00314 if (! AskSelected(stateEvent))
00315 {
00316
00317
00318 FillJurisdictionMap(stateEvent, 0);
00319
00320
00321 AskCurrentInteractor(stateEvent);
00322 }
00323 ok = true;
00324 break;
00325 default:
00326 ok = true;
00327 }
00328 return ok;
00329 }
00330
00331
00332 mitk::GlobalInteraction* mitk::GlobalInteraction::GetInstance()
00333 {
00334 static mitk::GlobalInteraction::Pointer s_GlobalInteraction;
00335
00336 if (s_GlobalInteraction.IsNull())
00337 {
00338 s_GlobalInteraction = mitk::GlobalInteraction::New();
00339 }
00340 return s_GlobalInteraction;
00341 }
00342
00343
00344 mitk::State* mitk::GlobalInteraction::GetStartState(const char* type)
00345 {
00346 if ( this->IsInitialized() )
00347 return m_StateMachineFactory->GetStartState(type);
00348
00349 MITK_FATAL << "Fatal Error in mitkGlobalInteraction.cpp: GlobalInteraction not initialized!\n";
00350 return NULL;
00351 }
00352
00353 bool mitk::GlobalInteraction::AddToSelectedInteractors(mitk::Interactor* interactor)
00354 {
00355 InteractorListIter position = std::find(m_SelectedList.begin(), m_SelectedList.end(),interactor);
00356 if (position != m_SelectedList.end())
00357 {
00358
00359 return true;
00360 }
00361 else
00362 m_SelectedList.push_back(interactor);
00363
00364 return true;
00365 }
00366
00367 bool mitk::GlobalInteraction::RemoveFromSelectedInteractors(mitk::Interactor* interactor)
00368 {
00369 if (interactor == NULL)
00370 return false;
00371
00372 InteractorListIter position = std::find(m_SelectedList.begin(), m_SelectedList.end(),interactor);
00373 if (position != m_SelectedList.end())
00374 {
00375 position = m_SelectedList.erase(position);
00376 return true;
00377 }
00378 else
00379 return false;
00380 }
00381
00382 mitk::StateMachineFactory* mitk::GlobalInteraction::GetStateMachineFactory()
00383 {
00384 return m_StateMachineFactory;
00385 }
00386
00387 bool mitk::GlobalInteraction::Initialize(const char* globalInteractionName, const std::string XMLBehaviorInput)
00388 {
00389 if (this->IsInitialized())
00390 {
00391 MITK_WARN <<"Global Interaction has already been initialized.\n";
00392 return false;
00393 }
00394
00395 m_FocusManager = FocusManager::New();
00396
00397
00398
00399 if (m_StateMachineFactory)
00400 m_StateMachineFactory->Delete();
00401 m_StateMachineFactory = StateMachineFactory::New();
00402
00403
00404
00405 if (m_EventMapper)
00406 m_EventMapper->Delete();
00407 m_EventMapper = EventMapper::New();
00408
00409
00410 bool success = true;
00411
00412 if (XMLBehaviorInput == "")
00413 {
00414
00415 success &= m_StateMachineFactory->LoadStandardBehavior();
00416 success &= m_EventMapper->LoadStandardBehavior();
00417 }
00418 else if (itksys::SystemTools::FileExists(XMLBehaviorInput.c_str()) )
00419 {
00420
00421 success &= m_StateMachineFactory->LoadBehavior(XMLBehaviorInput);
00422 success &= m_EventMapper->LoadBehavior(XMLBehaviorInput);
00423 }
00424 else
00425 {
00426
00427 success &= m_StateMachineFactory->LoadBehaviorString(XMLBehaviorInput);
00428 success &= m_EventMapper->LoadBehaviorString(XMLBehaviorInput);
00429 }
00430
00431 if(!success)
00432 {
00433 MITK_FATAL << "Error initializing global interaction!\n";
00434 return false;
00435 }
00436
00437
00438
00439
00440 m_Type = globalInteractionName;
00441
00442
00443 State::Pointer startState = m_StateMachineFactory->GetStartState(globalInteractionName);
00444
00445 if (startState.IsNull())
00446 {
00447 MITK_FATAL << "Fatal Error in mitkGlobalInteraction.cpp: No StartState recieved from StateMachineFactory!\n";
00448 return false;
00449 }
00450
00451
00452 m_CurrentStateVector.clear();
00453
00454 m_CurrentStateVector.push_back(startState);
00455 m_IsInitialized = true;
00456 return true;
00457 }
00458