---

/Go4GUIRegistry/TGo4GUIRegistry.cxx

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#include "TGo4GUIRegistry.h"

#include <iostream.h>

#include "TApplication.h"

#include "TGo4SubmittedCommandsEntry.h"
#include "TGo4RecieverInfo.h"
#include "TGo4RegisteredSlotsList.h"
#include "TGo4DependentStatusList.h"
#include "Go4StatusBase/TGo4Status.h"
#include "Go4LockGuard/TGo4LockGuard.h"
#include "Go4AnalysisClient/TGo4AnalysisClientStatus.h"
#include "Go4CommandsTaskHandler/Go4CommandsTaskHandler.h"
#include "Go4GUIBase/TGo4SlotsBaseClass.h"
#include "Go4GUI/TGo4MainWindow.h"
#include "Go4Display/TGo4Display.h"
#include "Go4Queue/TGo4BufferQueue.h"
#include "Go4TaskHandler/TGo4TaskHandler.h"

TGo4GUIRegistry * TGo4GUIRegistry::fxInstance= 0;

TGo4GUIRegistry *TGo4GUIRegistry::Instance()
{
   if (fxInstance == 0)
      fxInstance = new TGo4GUIRegistry();
   return fxInstance;
}

TGo4GUIRegistry::TGo4GUIRegistry()
{
   SlotClassList.SetOwner(kTRUE);

   // TGo4LockGuard globalguard;
   DependenceList.SetOwner(kTRUE);
   
   SubmittedCommandsList.SetOwner(kTRUE);

   fxDisplayStatusMonitor = 0;
   fxTGo4Display = 0;
   fxDisplayAnalysisConfig = 0;
   fxMainWindow = 0;
   fxCentralWindow = 0;
   fxLogInfo = 0;
   fxMemBrowser = 0;
   fbAnalysisReady = kFALSE;
   fbAnaSettingsReady = kFALSE;
   fiClientRole=-1;
}

TGo4GUIRegistry::~TGo4GUIRegistry()
{
    // TGo4LockGuard globalguard;
}

void TGo4GUIRegistry::UnRegisterClass(TGo4SlotsBaseClass * p, TGo4Status* s)
{
      //cout << "TGo4GUIRegistry::UnRegisterClass " << p->GetName() << endl;
   // TGo4LockGuard globalguard;
   
   TObject* item = SlotClassList.FindObject(p->GetName());
   if(item!=0) {
      SlotClassList.Remove(item);
      SlotClassList.Compress();
      delete item;
   }
   
   for(int n=0;n<=DependenceList.GetLast();n++) {
      TGo4DependentStatusList* entry = (TGo4DependentStatusList*) DependenceList.At(n);
      if (entry->SlotClass()==p) {
         DependenceList.Remove(entry);
         delete entry;
      }
   }
   DependenceList.Compress();

   for(int n=0;n<=SubmittedCommandsList.GetLast();n++) {
       TGo4SubmittedCommandsEntry* RObject = 
          (TGo4SubmittedCommandsEntry*) SubmittedCommandsList.At(n);
       RObject->RemoveSlotEntries(p); 
       if (RObject->NoOfRecv()==0) {
          SubmittedCommandsList.Remove(RObject);
          delete RObject;
       }
   } 
   SubmittedCommandsList.Compress();
}

void TGo4GUIRegistry::UpdateDependents(TGo4Status* s)
{
   // TGo4LockGuard globalguard;
   
   for(int n=0;n<=DependenceList.GetLast();n++) {
      TGo4DependentStatusList* entry = (TGo4DependentStatusList*) DependenceList.At(n);
      if (entry->StatusClass() == s) 
        entry->SlotClass()->StatusChanged(s);
   }
}

void TGo4GUIRegistry::UnRegisterDependentClass(TGo4SlotsBaseClass *p, const char* name)
{
   for(int n=0;n<=DependenceList.GetLast();n++) {
      TGo4DependentStatusList* entry = (TGo4DependentStatusList*) DependenceList.At(n);
      if((entry->SlotClass() == p) && (strcmp(entry->GetName(),name)==0)) {
          DependenceList.Remove(entry);
          delete entry;
      }
   }
   DependenceList.Compress();
}

TGo4Status* TGo4GUIRegistry::GetStatus(const char * name)
{
   // TGo4LockGuard globalguard;
   
   if (name==0) return 0;
   
   for(int n=0;n<=SlotClassList.GetLast();n++) {
      TGo4RegisteredSlotsList* entry = 
        (TGo4RegisteredSlotsList*) SlotClassList.At(n);
      if (strcmp(name , entry->GetStatusClass()->GetName())==0) 
        return entry->GetStatusClass();
   }
   
   return 0;
}

TGo4SlotsBaseClass* TGo4GUIRegistry::GetSlotClass(const char * name)
{
   // TGo4LockGuard globalguard;

   if (name==0) return 0;
   
   TGo4RegisteredSlotsList* entry = (TGo4RegisteredSlotsList*) SlotClassList.FindObject(name);
   
   return entry==0 ? 0 : entry->GetSlotClass();
}

TGo4SlotsBaseClass* TGo4GUIRegistry::GetSlotClass(TGo4SlotsBaseClass *SlotClass)
{
    // TGo4LockGuard globalguard;
   return  GetSlotClass(SlotClass->GetName());
}

QWidget *TGo4GUIRegistry::GetGUIClass(TGo4SlotsBaseClass *SlotClass)
{
   // TGo4LockGuard globalguard;
   TGo4RegisteredSlotsList* entry = 
     dynamic_cast <TGo4RegisteredSlotsList *> 
       (SlotClassList.FindObject(SlotClass->GetName()));
   return entry==0 ? 0 : entry->GetGUI();
}

QWidget *TGo4GUIRegistry::GetMainWindow()
{
    // TGo4LockGuard globalguard;
   return fxMainWindow;
}

void TGo4GUIRegistry::SetMainWindow(QWidget * widget)
{
    // TGo4LockGuard globalguard;
   fxMainWindow = widget;
}

QWidget *TGo4GUIRegistry::GetCentralWindow()
{
    // TGo4LockGuard globalguard;
   return fxCentralWindow;
}

void TGo4GUIRegistry::SetCentralWindow(QWidget * widget)
{
    // TGo4LockGuard globalguard;
   fxCentralWindow = widget;
}

void  TGo4GUIRegistry::GuiIsChanged(TGo4SlotsBaseClass * SlotClass, QWidget * GUI)
{
   // TGo4LockGuard globalguard;
   TGo4RegisteredSlotsList* entry = 
      dynamic_cast <TGo4RegisteredSlotsList*> 
        (SlotClassList.FindObject(SlotClass->GetName()));
   if (entry!=0)
     entry->SetGUI(GUI);
}

void TGo4GUIRegistry::RegisterSlotClass(TGo4SlotsBaseClass * p, TGo4Status* s, QWidget *GUI)
{
    // TGo4LockGuard globalguard;

    SlotClassList.Add(new TGo4RegisteredSlotsList(p->GetName(),p, s, GUI));
    
    if (s!=0)
       for(int n=0;n<=DependenceList.GetLast();n++) {
          TGo4DependentStatusList* entry = (TGo4DependentStatusList*) DependenceList.At(n);
          if (strcmp(s->GetName(), entry->GetName())==0) 
            entry->SetStatusClass(s);
       }
}

void TGo4GUIRegistry::RegisterDependentClass(TGo4SlotsBaseClass *p, const Char_t* name)
{
   if (name==0) return; 
    
// TGo4LockGuard globalguard;
   DependenceList.Add(new TGo4DependentStatusList(name, p, GetStatus(name)));
}

TGo4SubmittedCommandsEntry* TGo4GUIRegistry::FindCmdEntry(const char* name, Bool_t force)
{
    if (name==0) return 0;
    
    TGo4SubmittedCommandsEntry *entry = 
      (TGo4SubmittedCommandsEntry*) SubmittedCommandsList.FindObject(name);
    if ((entry==0) && force) {
      entry = new TGo4SubmittedCommandsEntry(name);
      SubmittedCommandsList.Add(entry);
    } 
    return entry;
}

void TGo4GUIRegistry::DisplayData(TNamed * data)
{
   if (data==0) return; 
    
   // TGo4LockGuard globalguard;
   TGo4SubmittedCommandsEntry *RObject = FindCmdEntry(data->GetName());
   
   if (RObject!=0) {
     
     TObjArray cleanup;
     
     Bool_t issubmited = kFALSE;
     
     // first process all entries
     for (int n=0;n<RObject->NoOfRecv();n++) {
         TGo4RecieverInfo* entry = RObject->GetRecv(n);
         
         if (issubmited && entry->IsSubmited()) continue;
         if (entry->IsSubmited()) issubmited = kTRUE;
         
         TGo4SlotsBaseClass* sl = entry->GetRecvSlot();
         if (sl==0) sl = fxMemBrowser;
         
         if(entry->GetCanvas()!=0)
            sl->AddObject(data, entry->GetCanvas(), entry->GetPad());
         else
            sl->AddObject(data);
            
         cleanup.Add(entry);   
     }
     
     // now remove all correspondent entries
     for (int n=0;n<=cleanup.GetLast();n++) {
        TGo4RecieverInfo* entry = (TGo4RecieverInfo*) cleanup.At(n); 
         if (!entry->IsMonitored()) 
           RObject->RemoveRecvEntry(entry);
     }
     
     if(RObject->NoOfRecv()==0) RemoveFromSubmittedList(RObject);
     
   } else
     fxMemBrowser->AddObject(data);
  
   delete data;
}

void TGo4GUIRegistry::SubmitEmergencyCommand(Int_t val)
{
    // TGo4LockGuard globalguard;
    if(fxTGo4Display!=0) fxTGo4Display->SubmitEmergencyCommand((Go4EmergencyCommand_t)val);
}

void TGo4GUIRegistry::SubmitCommand(const char* name)
{
   // TGo4LockGuard globalguard;
   if(fxTGo4Display!=0) fxTGo4Display->SubmitCommand(name);
}

void TGo4GUIRegistry::SubmitCommand(const char* name, TGo4SlotsBaseClass *p)
{
   // TGo4LockGuard globalguard;
   if(fxTGo4Display==0) return;
   TGo4SubmittedCommandsEntry* entry = FindCmdEntry(name, kTRUE);
   entry->SetNewReciever(p, kFALSE, 0, 0, kTRUE);
   fxTGo4Display->SubmitCommand(name);
}

void TGo4GUIRegistry::SubmitCommand(TGo4Command* com, 
                                    const char* ObjectName,
                                    TGo4SlotsBaseClass *p, 
                                    Bool_t Monitor, 
                                    TQRootCanvas *c, 
                                    TPad *pad)
{
  // TGo4LockGuard globalguard;
   if(fxTGo4Display==0) return;
   if ((ObjectName==0) || (p==0 && c==0)) {
      fxTGo4Display->SubmitCommand(com);
   } else {
      TGo4SubmittedCommandsEntry* entry = FindCmdEntry(ObjectName, kTRUE);
      entry->SetNewReciever(p, Monitor, c, pad, kTRUE);
      fxTGo4Display->SubmitCommand(com);
   }
}

void TGo4GUIRegistry::ReDirectObject(const char* ObjectName, TGo4SlotsBaseClass *p, bool Monitor, TQRootCanvas *c, TPad *pad)
{
   // TGo4LockGuard globalguard;
   if(fxTGo4Display==0) return;

   if ((ObjectName==0) || ((p==0) && (c==0))) return;

   TGo4SubmittedCommandsEntry* entry = FindCmdEntry(ObjectName, kTRUE);
   entry->SetNewReciever(p, Monitor, c, pad, kFALSE);
}

TGo4Command* TGo4GUIRegistry::MakeCommand(const char* name)
{
   TGo4Command* com = 0;
   if(fxTGo4Display!=0)    
      {
         com = fxTGo4Display->GetTask()->MakeCommand(name);
      }
   return com;
}

void TGo4GUIRegistry::SetDisplay(TGo4Display *DisplayClass)
{
     // TGo4LockGuard globalguard;
    fxTGo4Display=DisplayClass;
}

void TGo4GUIRegistry::SetDisplayAnalysisConfig(TGo4SlotsBaseClass * p)
{
   // TGo4LockGuard globalguard;
   if(p!=0) 
      fxDisplayAnalysisConfig=p;
}

void TGo4GUIRegistry::DisplayLog(TGo4Status * status)
{
   if(status==0) return;

   if (status->InheritsFrom("TGo4AnalysisClientStatus")) {
      if(fxDisplayStatusMonitor!=0)
         fxDisplayStatusMonitor->StatusChanged(status);
      else
         delete status;
   } else 
   if(status->InheritsFrom("TGo4AnalysisStatus")) {
      SetAnalysisReady(kTRUE); // incoming status object indicates analysis is up
      if(fxDisplayAnalysisConfig!=0)
         fxDisplayAnalysisConfig->StatusChanged(status);
      delete status;
   } else {
      // check for initialization ready, or kind of connection:
      TString message=status->GetName();
      if(message.Contains("event classes were initialized"))
         {
            SetAnaSettingsReady(kTRUE);
         }
      
      else if (message.Contains("is logged in at")) 
         {
            // for gui as client at analysis server
            for(int j=0; j<4;++j)
               {
                  if(message.Contains(TGo4Command::GetModeDescription((Go4CommandMode_t) j )))
                     {
                        SetMasterMode(j);   
                        break;
                     }
               }
         } 
      else if (message.Contains("is shutting down now!")) 
         {
            StopMonitoring();
         }     
      else if (message.Contains("connected successfully")) 
         {
            // gui is server with one analysis client:
            SetMasterMode(2); // always controller mode
         }      
      else {}
         
      if (fxLogInfo!=0) 
        fxLogInfo->StatusChanged(status);
      else
        // if we do not have an active monitor just delete the log data
        // (we are responsible for status object, avoid memory leak!)
        delete status; 
   }
}

void TGo4GUIRegistry::RemoveFromSubmittedList(const char *Name)
{
   RemoveFromSubmittedList(FindCmdEntry(Name));
}

void TGo4GUIRegistry::RemoveFromSubmittedList(TGo4SubmittedCommandsEntry *Entry)
{
    // TGo4LockGuard globalguard;
   if(Entry==0) return;
   
   SubmittedCommandsList.Remove(Entry);
   SubmittedCommandsList.Compress();
   delete Entry;
}

void TGo4GUIRegistry::RemoveFromSubmittedList(const char *Name, TGo4SlotsBaseClass *p)
{
   // TGo4LockGuard globalguard;
   TGo4SubmittedCommandsEntry* Entry = FindCmdEntry(Name);
   if (Entry==0) return;

   Entry->RemoveSlotEntries(p);
   
   if(Entry->NoOfRecv()==0) 
     RemoveFromSubmittedList(Entry);
}

void TGo4GUIRegistry::RemoveFromSubmittedList(const char *Name, TQRootCanvas *c)
{
   // TGo4LockGuard globalguard;
   TGo4SubmittedCommandsEntry* Entry = FindCmdEntry(Name);
   if (Entry==0) return;

   Entry->RemoveCanvasEntries(c);
   
   RemoveFromSubmittedList(Entry);
}

void TGo4GUIRegistry::RemoveRedirectEntry(const char *Name)
{
   RemoveFromSubmittedList(Name);
}

void TGo4GUIRegistry::RemoveRedirectEntry(const char *Name, TGo4SlotsBaseClass *p)
{
   RemoveFromSubmittedList(Name,p);
}

void TGo4GUIRegistry::RemoveRedirectEntry(const char *Name, TQRootCanvas *c)
{
   RemoveFromSubmittedList(Name,c);
}

void TGo4GUIRegistry::SetLogInfo(TGo4SlotsBaseClass * p)
{
    // TGo4LockGuard globalguard;
   if(p==0) delete fxLogInfo; 
   
   fxLogInfo = p;
}

void TGo4GUIRegistry::SetDisplayStatusMonitor(TGo4SlotsBaseClass * p)
{
    // TGo4LockGuard globalguard;
   if(p==0) delete fxDisplayStatusMonitor;

   fxDisplayStatusMonitor=p;
}

void TGo4GUIRegistry::StartAnalysisWindow(const char* text)
{
   TGo4MainWindow* mw = dynamic_cast<TGo4MainWindow*> (fxMainWindow);
   if(mw!=0) {
       mw->ShowAnylsisOutput(text);
   } else {
       cerr <<"GUIRegistry without mainwindow! NEVER COME HERE!!" << endl;
       gApplication->Terminate();
   }
}

void TGo4GUIRegistry::SetMasterMode(Int_t role)
{
TGo4MainWindow* mw = dynamic_cast<TGo4MainWindow*> (fxMainWindow);
if(mw) mw->SetMasterMode(role);      
}

void TGo4GUIRegistry::StopMonitoring()
{
TGo4MainWindow* mw = dynamic_cast<TGo4MainWindow*> (fxMainWindow);
if(mw) mw->StopMonitoring();
TGo4Task* task=fxTGo4Display->GetTask();
TGo4BufferQueue* qu=task->GetCommandQueue();
if(qu) qu->Clear();    

   
}


void TGo4GUIRegistry::SetMemoryBrowser(TGo4SlotsBaseClass * browser)
{
   // TGo4LockGuard globalguard;
   fxMemBrowser = browser;
}

//----------------------------END OF GO4 SOURCE FILE ---------------------

---