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