GSI Object Oriented Online Offline (Go4)  GO4-6.2.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
TGo4Interface.cxx
Go to the documentation of this file.
1 // $Id: TGo4Interface.cxx 3013 2021-02-18 12:12:44Z linev $
2 //-----------------------------------------------------------------------
3 // The GSI Online Offline Object Oriented (Go4) Project
4 // Experiment Data Processing at EE department, GSI
5 //-----------------------------------------------------------------------
6 // Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
7 // Planckstr. 1, 64291 Darmstadt, Germany
8 // Contact: http://go4.gsi.de
9 //-----------------------------------------------------------------------
10 // This software can be used under the license agreements as stated
11 // in Go4License.txt file which is part of the distribution.
12 //-----------------------------------------------------------------------
13 
14 #include "TGo4Interface.h"
15 
16 #include "TROOT.h"
17 #include "TSystem.h"
18 #include "TCanvas.h"
19 #include "TStopwatch.h"
20 #include "TTimer.h"
21 
22 #include "TGo4AnalysisStatus.h"
23 #include "TGo4AnalysisStepStatus.h"
24 
26 #include "TGo4RevServParameter.h"
27 #include "TGo4FileStoreParameter.h"
28 #include "TGo4BackStoreParameter.h"
29 #include "TGo4UserStoreParameter.h"
31 #include "TGo4MbsFileParameter.h"
32 #include "TGo4MbsStreamParameter.h"
35 #include "TGo4MbsRandomParameter.h"
36 
37 #include "TGo4ObjectManager.h"
38 #include "TGo4BrowserProxy.h"
39 #include "TGo4AnalysisProxy.h"
40 #include "TGo4RootBrowserProxy.h"
41 
44  fRootBrowser(0),
45  fOMDataPath(),
46  fOMBrowserPath(),
47  fOMEditorsPath(),
48  fCmdFinished(kTRUE),
49  fCmdTimer(0),
50  fWaitCounter(0)
51 {
52  // create object manager
53  TGo4ObjectManager* om =
54  new TGo4ObjectManager("GUI_OM","Gui object manager");
55  fOMDataPath = "data";
56  fOMBrowserPath = "gui";
57  fOMEditorsPath = "editors";
58 
59  // create mount point for all data sources
60  om->MakeFolder(fOMDataPath.Data());
61 
62  // create entry for browser
63  TGo4BrowserProxy* br =
64  new TGo4BrowserProxy(fOMDataPath.Data(), fOMEditorsPath.Data(), kTRUE);
65  om->AddProxy("", br, fOMBrowserPath.Data(), "Place for gui slots");
66  br->CreateMemoryFolder();
67 
68  // create entry for gui browser
70  om->AddProxy("", fRootBrowser, fOMEditorsPath.Data(), "Proxy for ROOT browser");
71  om->AddLink(br->BrowserTopSlot(), fOMEditorsPath.Data(), "Go4Browser", "Link to Go4 browser");
72 
73  Initialize(om, br);
74 }
75 
77 {
79  delete fCmdTimer;
80  fCmdTimer = 0;
81 
82  Int_t timecnt = 50;
83  while (timecnt-->0) {
84  if (Analysis()==0) break;
85  gSystem->ProcessEvents();
86  gSystem->Sleep(100);
87  }
88 
89  TGo4ObjectManager* om = OM();
90  delete om;
91 }
92 
93 void TGo4Interface::ProcessEvents(Int_t timeout)
94 {
95  Wait(timeout<=0 ? 0 : timeout*0.001);
96 }
97 
98 void TGo4Interface::Wait(double tm_sec)
99 {
100  TStopwatch watch;
101 
102  Double_t spenttime = 0.;
103  Bool_t first = kTRUE;
104 
105  do {
106  watch.Start();
107  if (first) first = kFALSE;
108  else gSystem->Sleep(50);
109  gSystem->ProcessEvents();
110  watch.Stop();
111  spenttime += watch.RealTime();
112  } while (spenttime <= tm_sec);
113 }
114 
115 void TGo4Interface::Message(const char* msg)
116 {
117  if (fRootBrowser)
118  fRootBrowser->Message("Message","msg",5000);
119 }
120 
122 {
123  // do nothing while no parameters is specified
124  // work in Qt GUI while parameters can be taken from the QSettings
125 }
126 
128 {
129  const char* analisysitem = "Analysis";
130 
131  TGo4Slot* analslot = Browser()->DataSlot(analisysitem);
132 
133  if (analslot==0) {
134  TGo4AnalysisProxy* anal = new TGo4AnalysisProxy(isserver);
135  OM()->AddProxy(fOMDataPath.Data(), anal, analisysitem, "Analysis proxy");
136  analslot = Browser()->DataSlot(analisysitem);
137  anal->SetDefaultReceiver(OM(), TString("gui/") + analisysitem + "/");
138  }
139 
140  TGo4AnalysisProxy* anal = (analslot==0) ? 0 :
141  dynamic_cast<TGo4AnalysisProxy*> (analslot->GetProxy());
142 
143  if (anal!=0)
144  anal->SetAnalysisReady(kFALSE);
145 
146  if ((anal!=0) && (fRootBrowser!=0)) {
147  OM()->AddLink(anal->RatemeterSlot(), fOMEditorsPath.Data(), "AnalRateMeter", "Analysis ratemeter");
148  OM()->AddLink(anal->LoginfoSlot(), fOMEditorsPath.Data(), "AnalLoginfo", "Analysis loginfo");
149  }
150 
151  return anal;
152 }
153 
154 
155 void TGo4Interface::LaunchAnalysis(const char* ClientName,
156  const char* ClientDir,
157  const char* ClientExec,
158  const char* ClientNode,
159  Int_t ShellMode,
160  Int_t TermMode,
161  Int_t ExeMode,
162  const char* UserArgs)
163 {
164  TString launchcmd, killcmd;
165 
166  TGo4AnalysisProxy* anal = AddAnalysisProxy(kFALSE);
167  if (anal==0) return;
168 
169  anal->LaunchAsClient(launchcmd, killcmd,
170  (ShellMode==2),
171  TermMode==2 ? 2 : 3,
172  ClientName,
173  ClientNode,
174  ClientDir,
175  ClientExec,
176  ExeMode,
177  UserArgs);
178 
179  gSystem->ProcessEvents();
180 
181  ProcessEvents(200);
182 }
183 
184 void TGo4Interface::ConnectAnalysis(const char* ServerNode,
185  Int_t ServerPort,
186  Int_t ControllerMode,
187  const char* password)
188 {
189  TGo4AnalysisProxy* anal = Analysis();
190  if (anal==0) anal = AddAnalysisProxy(kTRUE);
191 
192  if (anal==0) return;
193 
194  anal->ConnectToServer(ServerNode,
195  ServerPort,
196  ControllerMode,
197  password);
198 
199  if (ControllerMode>0)
200  anal->RequestAnalysisSettings();
201 
202 // gSystem->ProcessEvents();
203  ProcessEvents(200);
204 }
205 
206 void TGo4Interface::WaitAnalysis(Int_t delay_sec)
207 {
208  if (IsHotStart()) {
209  fWaitCounter = delay_sec*100;
210  return;
211  }
212 
213  TGo4AnalysisProxy* anal = Analysis();
214  if (anal==0) {
215  Error("WaitAnalysis","Analysis not found");
216  return;
217  }
218 
219  delay_sec*=10;
220 
221  while (delay_sec-->0) {
222  gSystem->ProcessEvents();
223  gSystem->Sleep(100);
224  gSystem->ProcessEvents();
225  if (anal->IsAnalysisReady())
226  return;
227  }
228 }
229 
231 {
232  TGo4AnalysisProxy* anal = Analysis();
233  if (anal==0) return;
234 
236 
237  anal->DisconnectAnalysis(5, kFALSE);
238 
239  ProcessEvents(200);
240 }
241 
243 {
244  TGo4AnalysisProxy* anal = Analysis();
245  if (anal==0) return;
246 
248 
249  bool realshutdown = anal->IsAnalysisServer() &&
250  anal->IsConnected() &&
251  anal->IsAdministrator();
252 
253  anal->DisconnectAnalysis(30, realshutdown);
254 }
255 
257 {
258  TGo4ServerProxy* anal = Server();
259  if (anal==0) return;
260 
261  anal->SubmitAnalysisSettings();
262  anal->RefreshNamesList();
263 
264  Int_t delay_sec = tmout > 0 ? tmout : 20;
265  while (delay_sec-->0) {
266  gSystem->ProcessEvents();
267  gSystem->Sleep(1000);
268  gSystem->ProcessEvents();
269  if (anal->IsAnalysisSettingsReady())
270  if (anal->NamesListReceived()) return;
271  }
272 }
273 
275 {
276  TGo4ServerProxy* anal = Server();
277  if (anal==0) return;
278 
279  anal->StartAnalysis();
280  anal->RefreshNamesList();
281  anal->DelayedRefreshNamesList(4);
282 
283  gSystem->ProcessEvents();
284  gSystem->Sleep(500);
285  gSystem->ProcessEvents();
286 }
287 
289 {
290  TGo4ServerProxy* anal = Server();
291  if (anal==0) return;
292 
293  anal->StopAnalysis();
294 
295  gSystem->ProcessEvents();
296  gSystem->Sleep(1000);
297  gSystem->ProcessEvents();
298 }
299 
301 {
302  TGo4ServerProxy* anal = Server();
303  if (anal==0) return;
304 
305  anal->RefreshNamesList();
306 
307  Int_t delay_sec = tmout > 0 ? tmout : 10;
308  while (delay_sec-->0) {
309  gSystem->ProcessEvents();
310  gSystem->Sleep(1000);
311  gSystem->ProcessEvents();
312  if (anal->NamesListReceived()) return;
313  }
314 }
315 
316 
318 {
319  TGo4ServerProxy* anal = Server();
320  if (anal==0) return 0;
321  if (anal->SettingsSlot()==0) return 0;
322 
323  return dynamic_cast<TGo4AnalysisStatus*>
324  (anal->SettingsSlot()->GetAssignedObject());
325 }
326 
327 void TGo4Interface::AnalysisAutoSave(const char* filename,
328  Int_t interval,
329  Int_t compression,
330  Bool_t enabled,
331  Bool_t overwrite)
332 {
333  TGo4AnalysisStatus* status = GetAnalStatus();
334  if (status==0) return;
335 
336  status->SetAutoFileName(filename);
337  status->SetAutoSaveInterval(interval);
338  status->SetAutoSaveCompression(compression);
339  status->SetAutoSaveOn(enabled);
340  status->SetAutoSaveOverwrite(overwrite);
341 }
342 
343 void TGo4Interface::AnalysisConfigName(const char* filename)
344 {
345  TGo4AnalysisStatus* status = GetAnalStatus();
346  if (status!=0)
347  status->SetConfigFileName(filename);
348 }
349 
351 {
352  TGo4AnalysisStatus* status = GetAnalStatus();
353  return status==0 ? 0 : status->GetStepStatus(stepname);
354 }
355 
356 void TGo4Interface::ConfigStep(const char* stepname,
357  Bool_t enableprocess,
358  Bool_t enablesource,
359  Bool_t enablestore)
360 {
361  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
362  if (step==0) return;
363 
364  step->SetSourceEnabled(enablesource);
365  step->SetStoreEnabled(enablestore);
366  step->SetProcessEnabled(enableprocess);
367 }
368 
369 void TGo4Interface::StepFileSource(const char* stepname,
370  const char* sourcename,
371  int timeout)
372 {
373  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
374  if (step==0) return;
375 
376  TGo4FileSourceParameter par(sourcename);
377  par.SetTimeout(timeout);
378  step->SetSourcePar(&par);
379 }
380 
381 void TGo4Interface::StepMbsFileSource(const char* stepname,
382  const char* sourcename,
383  int timeout,
384  const char* TagFile,
385  int start,
386  int stop,
387  int interval)
388 {
389  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
390  if (step==0) return;
391 
392  TGo4MbsFileParameter par(sourcename);
393  par.SetTimeout(timeout);
394 
395  if(TagFile==0) par.SetTagName("GO4-NOLMDTAG");
396  else par.SetTagName(TagFile);
397  par.SetStartEvent(start);
398  par.SetStopEvent(stop);
399  par.SetEventInterval(interval);
400  step->SetSourcePar(&par);
401 }
402 
403 void TGo4Interface::StepMbsStreamSource(const char* stepname,
404  const char* sourcename,
405  int timeout,
406  int start,
407  int stop,
408  int interval)
409 {
410  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
411  if (step==0) return;
412 
413  TGo4MbsStreamParameter par(sourcename);
414  par.SetTimeout(timeout);
415  par.SetStartEvent(start);
416  par.SetStopEvent(stop);
417  par.SetEventInterval(interval);
418  step->SetSourcePar(&par);
419 }
420 
421 void TGo4Interface::StepMbsTransportSource(const char* stepname,
422  const char* sourcename,
423  int timeout,
424  int start,
425  int stop,
426  int interval)
427 {
428  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
429  if (step==0) return;
430 
431  TGo4MbsTransportParameter par(sourcename);
432  par.SetTimeout(timeout);
433  par.SetStartEvent(start);
434  par.SetStopEvent(stop);
435  par.SetEventInterval(interval);
436  step->SetSourcePar(&par);
437 }
438 
439 void TGo4Interface::StepMbsEventServerSource(const char* stepname,
440  const char* sourcename,
441  int timeout,
442  int start,
443  int stop,
444  int interval)
445 {
446  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
447  if (step==0) return;
448 
449  TGo4MbsEventServerParameter par(sourcename);
450  par.SetTimeout(timeout);
451  par.SetStartEvent(start);
452  par.SetStopEvent(stop);
453  par.SetEventInterval(interval);
454  step->SetSourcePar(&par);
455 }
456 
457 void TGo4Interface::StepMbsRevServSource(const char* stepname,
458  const char* sourcename,
459  int timeout,
460  int port,
461  int start,
462  int stop,
463  int interval)
464 {
465  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
466  if (step==0) return;
467 
468  TGo4RevServParameter par(sourcename);
469  par.SetTimeout(timeout);
470  par.SetPort(port);
471  par.SetStartEvent(start);
472  par.SetStopEvent(stop);
473  par.SetEventInterval(interval);
474  step->SetSourcePar(&par);
475 }
476 
477 void TGo4Interface::StepRandomSource(const char* stepname,
478  const char* sourcename,
479  int timeout)
480 {
481  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
482  if (step==0) return;
483 
484  TGo4MbsRandomParameter par(sourcename);
485  par.SetTimeout(timeout);
486  step->SetSourcePar(&par);
487 }
488 
489 void TGo4Interface::StepUserSource(const char* stepname,
490  const char* sourcename,
491  int timeout,
492  int port,
493  const char* expr)
494 {
495  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
496  if (step==0) return;
497 
498  TGo4UserSourceParameter par(sourcename);
499  par.SetTimeout(timeout);
500  par.SetPort(port);
501  par.SetExpression(expr);
502  step->SetSourcePar(&par);
503 }
504 
505 void TGo4Interface::StepFileStore(const char* stepname,
506  const char* storename,
507  bool overwrite,
508  int bufsize,
509  int splitlevel,
510  int compression,
511  int autosaveperiod)
512 {
513  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
514  if (step==0) return;
515 
516  TGo4FileStoreParameter par(storename);
517  par.SetOverwriteMode(overwrite);
518  par.SetBufsize(bufsize);
519  par.SetSplitlevel(splitlevel);
520  par.SetCompression(compression);
521  par.SetAutosaveSize(autosaveperiod);
522  step->SetStorePar(&par);
523 }
524 
525 void TGo4Interface::StepBackStore(const char* stepname,
526  const char* storename,
527  int bufsize,
528  int splitlevel)
529 {
530  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
531  if (step==0) return;
532 
533  TGo4BackStoreParameter par(storename);
534  par.SetBufsize(bufsize);
535  par.SetSplitlevel(splitlevel);
536  step->SetStorePar(&par);
537 }
538 
539 void TGo4Interface::StepUserStore(const char* stepname,
540  const char* storename)
541 {
542  TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
543  if (step==0) return;
544 
545  TGo4UserStoreParameter par(storename);
546  step->SetStorePar(&par);
547 }
548 
550 {
551  return StartViewPanel(10,10, 500, 300, 1, 0);
552 }
553 
554 ViewPanelHandle TGo4Interface::StartViewPanel(int x, int y, int width, int height, int mode, TGo4Picture* pic)
555 {
556  static Int_t cancounter = 0;
557 
558  TString cname = "Panel";
559  cname+=cancounter++;
560 
561  TCanvas* c = new TCanvas(cname.Data(), TString("Drawing of ") + cname, width, height);
562 
563  fRootBrowser->DrawPicture("", pic, c);
564 
565  c->Update();
566 
567  return (ViewPanelHandle) c;
568 }
569 
571 {
572  TCanvas* c = (TCanvas*) handle;
573  return TString(c ? c->GetName() : "");
574 }
575 
577 {
578  return (ViewPanelHandle) gROOT->GetListOfCanvases()->FindObject(name);
579 }
580 
581 Bool_t TGo4Interface::SetViewPanelName(ViewPanelHandle handle, const char* newname)
582 {
583  TCanvas* c = (TCanvas*) handle;
584  if ((c==0) || (newname==0) || (strlen(newname)==0)) return kFALSE;
585 
586  if (gROOT->GetListOfCanvases()->FindObject(newname)) {
587  Message(Form("Canvas with name %s already exists",newname));
588  return kFALSE;
589  }
590 
591  c->SetName(newname);
592 
593  c->Update();
594 
595  return kTRUE;
596 }
597 
599 {
600  if (gPad==0) return 0;
601  return (ViewPanelHandle) gPad->GetCanvas();
602 }
603 
605 {
606  TCanvas* c = (TCanvas*) handle;
607  if (c!=0) {
608  c->Modified();
609  c->Update();
610  }
611 }
612 
613 void TGo4Interface::DivideViewPanel(ViewPanelHandle handle, Int_t numX, Int_t numY)
614 {
615  TCanvas* c = (TCanvas*) handle;
616  if (c!=0) c->Divide(numX, numY);
617 }
618 
619 TPad* TGo4Interface::SelectPad(ViewPanelHandle handle, Int_t number)
620 {
621  TCanvas* c = (TCanvas*) handle;
622  if (c!=0) return (TPad*) c->cd(number);
623  return 0;
624 }
625 
626 Bool_t TGo4Interface::DrawItem(const char* itemname, ViewPanelHandle handle, const char* drawopt)
627 {
628  if (handle==0) handle = StartViewPanel();
629 
630  TObject* obj = GetObject(itemname, 5000);
631 
632  if (obj!=0) obj->Draw(drawopt);
633 
634  return obj!=0;
635 }
636 
637 void TGo4Interface::RedrawItem(const char* itemname)
638 {
640 
641  TIter next(gROOT->GetListOfCanvases());
642  TPad* pad = 0;
643  while ((pad = (TPad*) next()) != 0) {
644  pad->Modified();
645 
646  TVirtualPad* subpad = 0;
647  Int_t number = 0;
648  while ((subpad = pad->GetPad(number++))!=0)
649  subpad->Modified();
650 
651  pad->Update();
652  }
653 }
654 
655 Bool_t TGo4Interface::HandleTimer(TTimer* timer)
656 {
657  // if there is no commands remains, just exit
658  if (!IsHotStart()) return kTRUE;
659 
660  if (timer!=fCmdTimer) return kFALSE;
661 
662  // for the moment, only WaitAnalysis requries that strange waiting
663  // during hotstart. In normal script simple ProcessEvents and Sleep works
664 
665  if (fWaitCounter>0) {
666  fWaitCounter--;
667  TGo4AnalysisProxy* anal = Analysis();
668  if (anal && anal->IsAnalysisReady())
669  fWaitCounter = 0;
670  else
671  if (fWaitCounter<2) FreeHotStartCmds(); // if cannot wait analysis, just break execution
672  } else
673  ProcessHotStart();
674 
675  if (IsHotStart()) fCmdTimer->Start(10, kTRUE);
676  return kTRUE;
677 }
678 
679 
680 void TGo4Interface::HotStart(const char* filename)
681 {
682  if ((filename==0) || (strlen(filename)==0)) return;
683 
685 
686  fCmdFinished = kTRUE;
687 
688  if (!LoadHotStart(filename)) return;
689 
690  if (fCmdTimer==0)
691  fCmdTimer = new TTimer(this, 10, kTRUE);
692 
693  fCmdTimer->Start(10, kTRUE);
694 }
695 
697 {
698  if (!fCmdFinished) {
699  Error("ProcessHotStart","Internal problem");
700  return;
701  }
702 
703  const char* nextcmd = NextHotStartCmd();
704 
705  if ((nextcmd==0) || !IsHotStart()) return;
706 
707  Int_t error = 0;
708  fCmdFinished = kFALSE;
709  gROOT->ProcessLineSync(nextcmd, &error);
710  fCmdFinished = kTRUE;
711 
712  if (error!=0)
713  Error("ProcessHotStart", "ProcessLine(\"%s\") error %d", nextcmd, error);
714 }
Bool_t IsAnalysisSettingsReady() const
void SetAutoFileName(const char *name)
TGo4AnalysisProxy * AddAnalysisProxy(Bool_t isserver)
void SetStartEvent(UInt_t firstindex)
void Message(const char *str1, const char *str2, Int_t blockdelay)
void SetProcessEnabled(Bool_t on=kTRUE)
virtual TObject * GetObject(const char *itemname, Int_t updatelevel=1)
void StepMbsFileSource(const char *stepname, const char *sourcename, int timeout, const char *TagFile, int start=0, int stop=0, int interval=0)
ViewPanelHandle StartViewPanel()
TString fOMBrowserPath
void SetStoreEnabled(Bool_t on=kTRUE)
Bool_t IsAnalysisReady() const
void SetSplitlevel(Int_t split)
Bool_t LoadHotStart(const char *filename)
void SetSplitlevel(Int_t split)
void StepMbsEventServerSource(const char *stepname, const char *sourcename, int timeout, int start=0, int stop=0, int interval=0)
void StepUserStore(const char *stepname, const char *storename)
void SetStopEvent(UInt_t lastindex)
void StepRandomSource(const char *stepname, const char *sourcename, int timeout)
TGo4Slot * LoginfoSlot()
TGo4BrowserProxy * Browser() const
virtual ~TGo4Interface()
void SetAutoSaveOn(Bool_t on=kTRUE)
TGo4Proxy * GetProxy() const
Definition: TGo4Slot.h:93
Bool_t LaunchAsClient(TString &launchcmd, TString &killcmd, Int_t shellkind, Int_t konsole, const char *name, const char *remotehost, const char *remotedir, const char *remoteexe, Int_t exe_kind=0, const char *exeargs=0)
void Initialize(TGo4ObjectManager *om, TGo4BrowserProxy *br)
list of shared libraries when application is started
void DisconnectAnalysis()
void MakeFolder(const char *pathname)
void RefreshNamesList(int tmout=10)
virtual void RedrawItem(const char *itemname)
void HotStart(const char *filename)
void ProcessHotStart()
void ProcessEvents(Int_t timeout=-1)
TGo4RootBrowserProxy * fRootBrowser
void SetSourceEnabled(Bool_t on=kTRUE)
void StepFileSource(const char *stepname, const char *sourcename, int timeout)
void Wait(double tm_sec)
virtual Bool_t RefreshNamesList()
Bool_t DrawItem(const char *itemname, ViewPanelHandle panel=0, const char *drawopt=0)
virtual Bool_t IsAdministrator()
TString fOMDataPath
void StepBackStore(const char *stepname, const char *storename, int bufsize, int splitlevel)
void SetAutosaveSize(Int_t interval)
void StepFileStore(const char *stepname, const char *storename, bool overwrite, int bufsize, int splitlevel, int compression, int autosaveperiod=10000)
TPad * SelectPad(ViewPanelHandle panel, Int_t number=0)
virtual Bool_t IsAnalysisServer() const
void SetTagName(const char *name)
void RedrawPanel(ViewPanelHandle panel)
TGo4AnalysisProxy * Analysis()
void ConfigStep(const char *stepname, Bool_t enableprocess, Bool_t enablesource, Bool_t enablestore)
void SetStorePar(TGo4EventStoreParameter *kind)
virtual void StartAnalysis()
TGo4Slot * DataSlot(const char *item)
Bool_t ConnectToServer(const char *remotehost, Int_t remoteport, Int_t ascontroller, const char *accesspass)
TGo4Slot * RatemeterSlot()
void SetSourcePar(TGo4EventSourceParameter *kind)
TObject * GetAssignedObject()
Definition: TGo4Slot.cxx:370
void SetDefaultReceiver(TGo4ObjectManager *rcv, const char *path)
virtual void RequestAnalysisSettings()
void SetAnalysisReady(Bool_t on=kTRUE)
void SetOverwriteMode(Bool_t over=kTRUE)
TTimer * fCmdTimer
void StepMbsRevServSource(const char *stepname, const char *sourcename, int timeout, int port, int start=0, int stop=0, int interval=0)
virtual Bool_t IsConnected()
Bool_t SetViewPanelName(ViewPanelHandle handle, const char *newname)
ViewPanelHandle GetActiveViewPanel()
void CreateMemoryFolder(const char *foldername=0)
TGo4Slot * SettingsSlot()
void AnalysisAutoSave(const char *filename, Int_t interval, Int_t compression, Bool_t enabled, Bool_t overwrite)
void ShutdownAnalysis()
TGo4AnalysisStepStatus * GetStepStatus(const char *stepname)
virtual Bool_t NamesListReceived()
void SetEventInterval(UInt_t skipinterval)
void SetBufsize(Int_t bufsize)
TGo4AnalysisStepStatus * GetStepStatus(const char *name)
void DivideViewPanel(ViewPanelHandle panel, Int_t numX, Int_t numY)
TString fOMEditorsPath
void AddProxy(const char *pathname, TGo4Proxy *cont, const char *name, const char *title="title")
virtual void SubmitAnalysisSettings()
void StepUserSource(const char *stepname, const char *sourcename, int timeout, int port, const char *expr)
ViewPanelHandle FindViewPanel(const char *name)
void StepMbsStreamSource(const char *stepname, const char *sourcename, int timeout, int start=0, int stop=0, int interval=0)
void SetExpression(const char *name)
Bool_t fCmdFinished
void SubmitAnalysisConfig(int tmout=20)
TGo4Slot * BrowserTopSlot()
void SetAutoSaveOverwrite(Bool_t over=kTRUE)
virtual void StopAnalysis()
void * ViewPanelHandle
virtual Bool_t HandleTimer(TTimer *timer)
void SetConfigFileName(const char *name)
TGo4AnalysisStatus * GetAnalStatus()
void SetBufsize(Int_t bufsize)
virtual Bool_t DelayedRefreshNamesList(Int_t delay_sec)
void SetAutoSaveInterval(Int_t i)
TString GetViewPanelName(ViewPanelHandle handle)
TGo4ObjectManager * OM() const
void AnalysisConfigName(const char *filename)
void DrawPicture(const char *itemname, TGo4Picture *pic, TPad *pad)
void StepMbsTransportSource(const char *stepname, const char *sourcename, int timeout, int start=0, int stop=0, int interval=0)
void SetAutoSaveCompression(Int_t i=5)
void WaitAnalysis(Int_t delay_sec)
void ToggleMonitoring(Int_t period)
TGo4Slot * AddLink(TGo4Slot *source, const char *pathname, const char *linkname, const char *linktitle)
void Message(const char *msg)
virtual void DisconnectAnalysis(Int_t waittime=30, Bool_t servershutdown=kFALSE)
void RedrawItem(const char *itemname)
void ConnectAnalysis(const char *ServerNode, Int_t ServerPort, Int_t ControllerMode, const char *password=0)
string msg
Definition: go4init.py:11