GSI Object Oriented Online Offline (Go4) GO4-6.4.0
Loading...
Searching...
No Matches
TGo4Interface.cxx
Go to the documentation of this file.
1// $Id$
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"
24
36
37#include "TGo4ObjectManager.h"
38#include "TGo4BrowserProxy.h"
39#include "TGo4AnalysisProxy.h"
41
44 fRootBrowser(nullptr),
48 fCmdFinished(kTRUE),
49 fCmdTimer(nullptr),
51{
52 // create object manager
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
64 new TGo4BrowserProxy(fOMDataPath.Data(), fOMEditorsPath.Data(), kTRUE);
65 om->AddProxy("", br, fOMBrowserPath.Data(), "Place for gui slots");
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 = nullptr;
81
82 Int_t timecnt = 50;
83 while (timecnt-->0) {
84 if (!Analysis()) break;
85 gSystem->ProcessEvents();
86 gSystem->Sleep(100);
87 }
88
89 TGo4ObjectManager *om = OM();
90 delete om;
91}
92
94{
95 Wait(timeout <= 0 ? 0 : timeout*0.001);
96}
97
98void 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
115void 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) {
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 ? nullptr :
141 dynamic_cast<TGo4AnalysisProxy *> (analslot->GetProxy());
142
143 if (anal)
144 anal->SetAnalysisReady(kFALSE);
145
146 if (anal && fRootBrowser) {
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
155void 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) 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
184void 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) anal = AddAnalysisProxy(kTRUE);
191
192 if (!anal) return;
193
194 anal->ConnectToServer(ServerNode,
195 ServerPort,
196 ControllerMode,
197 password);
198
199 if (ControllerMode>0)
201
202// gSystem->ProcessEvents();
203 ProcessEvents(200);
204}
205
206void 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) {
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) return;
234
236
237 anal->DisconnectAnalysis(5, kFALSE);
238
239 ProcessEvents(200);
240}
241
243{
244 TGo4AnalysisProxy *anal = Analysis();
245 if (!anal) 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) return;
260
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) return;
278
279 anal->StartAnalysis();
280 anal->RefreshNamesList();
282
283 gSystem->ProcessEvents();
284 gSystem->Sleep(500);
285 gSystem->ProcessEvents();
286}
287
289{
290 TGo4ServerProxy *anal = Server();
291 if (!anal) 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) 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) return nullptr;
321 if (!anal->SettingsSlot()) return nullptr;
322
323 return dynamic_cast<TGo4AnalysisStatus*>
324 (anal->SettingsSlot()->GetAssignedObject());
325}
326
327void TGo4Interface::AnalysisAutoSave(const char *filename,
328 Int_t interval,
329 Int_t compression,
330 Bool_t enabled,
331 Bool_t overwrite)
332{
334 if (!status) return;
335
336 status->SetAutoFileName(filename);
337 status->SetAutoSaveInterval(interval);
338 status->SetAutoSaveCompression(compression);
339 status->SetAutoSaveOn(enabled);
340 status->SetAutoSaveOverwrite(overwrite);
341}
342
343void TGo4Interface::AnalysisConfigName(const char *filename)
344{
346 if (status)
347 status->SetConfigFileName(filename);
348}
349
351{
353 return !status ? nullptr : status->GetStepStatus(stepname);
354}
355
356void 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) return;
363
364 step->SetSourceEnabled(enablesource);
365 step->SetStoreEnabled(enablestore);
366 step->SetProcessEnabled(enableprocess);
367}
368
369void TGo4Interface::StepFileSource(const char *stepname,
370 const char *sourcename,
371 int timeout)
372{
373 TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
374 if (!step) return;
375
376 TGo4FileSourceParameter par(sourcename);
377 par.SetTimeout(timeout);
378 step->SetSourcePar(&par);
379}
380
381void 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) return;
391
392 TGo4MbsFileParameter par(sourcename);
393 par.SetTimeout(timeout);
394
395 if(!TagFile) 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
403void 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) 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
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) 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
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) 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
457void 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) 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
477void TGo4Interface::StepRandomSource(const char *stepname,
478 const char *sourcename,
479 int timeout)
480{
481 TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
482 if (!step) return;
483
484 TGo4MbsRandomParameter par(sourcename);
485 par.SetTimeout(timeout);
486 step->SetSourcePar(&par);
487}
488
489void 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) return;
497
498 TGo4UserSourceParameter par(sourcename);
499 par.SetTimeout(timeout);
500 par.SetPort(port);
501 par.SetExpression(expr);
502 step->SetSourcePar(&par);
503}
504
505void 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) 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
525void TGo4Interface::StepBackStore(const char *stepname,
526 const char *storename,
527 int bufsize,
528 int splitlevel)
529{
530 TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
531 if (!step) return;
532
533 TGo4BackStoreParameter par(storename);
534 par.SetBufsize(bufsize);
535 par.SetSplitlevel(splitlevel);
536 step->SetStorePar(&par);
537}
538
539void TGo4Interface::StepUserStore(const char *stepname,
540 const char *storename)
541{
542 TGo4AnalysisStepStatus* step = GetStepStatus(stepname);
543 if (!step) return;
544
545 TGo4UserStoreParameter par(storename);
546 step->SetStorePar(&par);
547}
548
550{
551 return StartViewPanel(10,10, 500, 300, 1, nullptr);
552}
553
554ViewPanelHandle 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
581Bool_t TGo4Interface::SetViewPanelName(ViewPanelHandle handle, const char *newname)
582{
583 TCanvas *c = (TCanvas *) handle;
584 if (!c || !newname || (strlen(newname) == 0)) return kFALSE;
585
586 if (gROOT->GetListOfCanvases()->FindObject(newname)) {
587 Message(TString::Format("Canvas with name %s already exists",newname).Data());
588 return kFALSE;
589 }
590
591 c->SetName(newname);
592
593 c->Update();
594
595 return kTRUE;
596}
597
599{
600 return (ViewPanelHandle) (gPad ? gPad->GetCanvas() : nullptr);
601}
602
604{
605 TCanvas *c = (TCanvas *) handle;
606 if (c) {
607 c->Modified();
608 c->Update();
609 }
610}
611
612void TGo4Interface::DivideViewPanel(ViewPanelHandle handle, Int_t numX, Int_t numY)
613{
614 TCanvas *c = (TCanvas *) handle;
615 if (c) c->Divide(numX, numY);
616}
617
618TPad *TGo4Interface::SelectPad(ViewPanelHandle handle, Int_t number)
619{
620 TCanvas *c = (TCanvas *) handle;
621 if (c) return (TPad *) c->cd(number);
622 return nullptr;
623}
624
625Bool_t TGo4Interface::DrawItem(const char *itemname, ViewPanelHandle handle, const char *drawopt)
626{
627 if (!handle) handle = StartViewPanel();
628
629 TObject *obj = GetObject(itemname, 5000);
630
631 if (obj) obj->Draw(drawopt);
632
633 return obj != nullptr;
634}
635
636void TGo4Interface::RedrawItem(const char *itemname)
637{
639
640 TIter next(gROOT->GetListOfCanvases());
641 while (auto pad = (TPad *) next()) {
642 pad->Modified();
643
644 Int_t number = 0;
645 while (auto subpad = pad->GetPad(number++))
646 subpad->Modified();
647
648 pad->Update();
649 }
650}
651
652Bool_t TGo4Interface::HandleTimer(TTimer *timer)
653{
654 // if there is no commands remains, just exit
655 if (!IsHotStart()) return kTRUE;
656
657 if (timer!=fCmdTimer) return kFALSE;
658
659 // for the moment, only WaitAnalysis requries that strange waiting
660 // during hotstart. In normal script simple ProcessEvents and Sleep works
661
662 if (fWaitCounter>0) {
663 fWaitCounter--;
664 TGo4AnalysisProxy *anal = Analysis();
665 if (anal && anal->IsAnalysisReady())
666 fWaitCounter = 0;
667 else
668 if (fWaitCounter<2) FreeHotStartCmds(); // if cannot wait analysis, just break execution
669 } else
671
672 if (IsHotStart()) fCmdTimer->Start(10, kTRUE);
673 return kTRUE;
674}
675
676
677void TGo4Interface::HotStart(const char *filename)
678{
679 if (!filename || (strlen(filename) == 0)) return;
680
682
683 fCmdFinished = kTRUE;
684
685 if (!LoadHotStart(filename)) return;
686
687 if (!fCmdTimer)
688 fCmdTimer = new TTimer(this, 10, kTRUE);
689
690 fCmdTimer->Start(10, kTRUE);
691}
692
694{
695 if (!fCmdFinished) {
696 Error("ProcessHotStart","Internal problem");
697 return;
698 }
699
700 const char *nextcmd = NextHotStartCmd();
701
702 if (!nextcmd || !IsHotStart()) return;
703
704 Int_t error = 0;
705 fCmdFinished = kFALSE;
706 gROOT->ProcessLineSync(nextcmd, &error);
707 fCmdFinished = kTRUE;
708
709 if (error != 0)
710 Error("ProcessHotStart", "ProcessLine(\"%s\") error %d", nextcmd, error);
711}
void * ViewPanelHandle
TGo4AnalysisProxy * Analysis()
Returns pointer on analysis proxy.
virtual void RedrawItem(const char *itemname)
Redraw item of given name on all viewpanels/editors.
TGo4BrowserProxy * Browser() const
Returns pointer on browser proxy.
TGo4ObjectManager * OM() const
Returns pointer on object manager.
TGo4ServerProxy * Server()
Returns pointer on more generic server proxy.
void Initialize(TGo4ObjectManager *om, TGo4BrowserProxy *br)
list of shared libraries when application is started
Bool_t LoadHotStart(const char *filename)
virtual TObject * GetObject(const char *itemname, Int_t updatelevel=1)
Returns object, assigned to specified browser item.
Bool_t IsAdministrator() const override
Bool_t IsConnected() const override
void RequestAnalysisSettings() override
Bool_t ConnectToServer(const char *remotehost, Int_t remoteport, Int_t ascontroller, const char *accesspass)
Bool_t IsAnalysisServer() const override
void DisconnectAnalysis(Int_t waittime=30, Bool_t servershutdown=kFALSE) override
Close connection to analysis and destroys proxy with correspondent slot.
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=nullptr)
void SetDefaultReceiver(TGo4ObjectManager *rcv, const char *path)
Set receiver for object envelopes, which coming from analysis without request.
Status of the analysis instance.
void SetAutoSaveInterval(Int_t i)
void SetConfigFileName(const char *name)
void SetAutoSaveCompression(Int_t i=5)
void SetAutoSaveOverwrite(Bool_t over=kTRUE)
TGo4AnalysisStepStatus * GetStepStatus(const char *name)
Access to certain analysis step status by name.
void SetAutoFileName(const char *name)
void SetAutoSaveOn(Bool_t on=kTRUE)
Status object of one analysis step.
void SetSourceEnabled(Bool_t on=kTRUE)
Enables or disables the event source.
void SetStorePar(TGo4EventStoreParameter *kind)
Sets the event store parameter which is used on intitialization of this step.
void SetStoreEnabled(Bool_t on=kTRUE)
Enables or disables the event store.
void SetProcessEnabled(Bool_t on=kTRUE)
Enables or disables the event processing.
void SetSourcePar(TGo4EventSourceParameter *kind)
Sets the event source parameter which is used on intitialization of this step.
void SetBufsize(Int_t bufsize)
TGo4Slot * BrowserTopSlot()
void ToggleMonitoring(Int_t period)
void CreateMemoryFolder(const char *foldername=nullptr)
TGo4Slot * DataSlot(const char *item)
void SetOverwriteMode(Bool_t over=kTRUE)
void SetBufsize(Int_t bufsize)
void SetAutosaveSize(Int_t interval)
void ProcessEvents(Int_t timeout=-1) override
void StepMbsRevServSource(const char *stepname, const char *sourcename, int timeout, int port, int start=0, int stop=0, int interval=0) override
Set MBS remote event server as step data source.
void StopAnalysis() override
Stop (suspend) analysis execution.
Bool_t SetViewPanelName(ViewPanelHandle handle, const char *newname) override
Change name of viewpanel.
void StepMbsTransportSource(const char *stepname, const char *sourcename, int timeout, int start=0, int stop=0, int interval=0) override
Set MBS transport server as step data source.
void StepMbsFileSource(const char *stepname, const char *sourcename, int timeout, const char *TagFile, int start=0, int stop=0, int interval=0) override
Set MBS file source as step data source.
void WaitAnalysis(Int_t delay_sec) override
Waits, until connection to analysis is established.
TString GetViewPanelName(ViewPanelHandle handle) override
Return name of viewpanel.
TGo4AnalysisStepStatus * GetStepStatus(const char *stepname)
void StepUserSource(const char *stepname, const char *sourcename, int timeout, int port, const char *expr) override
Set user data source as step data source.
void AnalysisConfigName(const char *filename) override
Configure name of file, where analysis configuration will be saved.
void RedrawItem(const char *itemname) override
Redraw item of given name on all viewpanels/editors.
ViewPanelHandle StartViewPanel() override
Create new view panel.
void Message(const char *msg) override
Display message in GUI status line.
void StepMbsEventServerSource(const char *stepname, const char *sourcename, int timeout, int start=0, int stop=0, int interval=0) override
Set MBS event server as step data source.
void DisconnectAnalysis() override
Disconnects from running analysis.
void StepRandomSource(const char *stepname, const char *sourcename, int timeout) override
Set random generator as step data source.
void AnalysisAutoSave(const char *filename, Int_t interval, Int_t compression, Bool_t enabled, Bool_t overwrite) override
Configure autosave properties of analysis.
void StepMbsStreamSource(const char *stepname, const char *sourcename, int timeout, int start=0, int stop=0, int interval=0) override
Set MBS stream server as step data source.
ViewPanelHandle GetActiveViewPanel() override
Return handle of last active viewpanel.
void Wait(double tm_sec) override
Wait specified number of seconds.
TString fOMDataPath
void DivideViewPanel(ViewPanelHandle panel, Int_t numX, Int_t numY) override
Divide viewpanel on subpads.
TString fOMBrowserPath
Bool_t HandleTimer(TTimer *timer) override
TGo4AnalysisStatus * GetAnalStatus()
void ConfigStep(const char *stepname, Bool_t enableprocess, Bool_t enablesource, Bool_t enablestore) override
Set basic step properties.
TTimer * fCmdTimer
void StepFileStore(const char *stepname, const char *storename, bool overwrite, int bufsize, int splitlevel, int compression, int autosaveperiod=10000) override
Set file as step data storage.
void HotStart(const char *filename) override
Executes hotstart file, generated in go4 GUI.
TPad * SelectPad(ViewPanelHandle panel, Int_t number=0) override
Set active pad on viewpanel.
void StartAnalysis() override
Starts (resume) analysis execution.
TGo4AnalysisProxy * AddAnalysisProxy(Bool_t isserver)
void ShutdownAnalysis() override
Shutdown running analysis.
virtual ~TGo4Interface()
void StepBackStore(const char *stepname, const char *storename, int bufsize, int splitlevel) override
Set back store as step data storage.
void SubmitAnalysisConfig(int tmout=20) override
Submit configuration to analysis.
void RedrawPanel(ViewPanelHandle panel) override
Forces of panel redraw.
TGo4RootBrowserProxy * fRootBrowser
void StepUserStore(const char *stepname, const char *storename) override
Set user store as step data storage.
void StepFileSource(const char *stepname, const char *sourcename, int timeout) override
Set file source as step data source.
ViewPanelHandle FindViewPanel(const char *name) override
Return handle on viewpanel with specified name.
TString fOMEditorsPath
void ConnectAnalysis(const char *ServerNode, Int_t ServerPort, Int_t ControllerMode, const char *password=nullptr) override
Connect to running analysis server.
void RefreshNamesList(int tmout=10) override
Sends new request to the analysis and waits for new names list.
void LaunchAnalysis() override
Launch analysis in client mode, using default configuration.
Bool_t DrawItem(const char *itemname, ViewPanelHandle panel=nullptr, const char *drawopt=nullptr) override
Draw browser item on specified viewpanel.
MBS file parameter.
void SetTagName(const char *name)
Name of the Tagfile.
void SetStartEvent(UInt_t firstindex)
Define the Start index for the NextEvent.
void SetPort(Int_t port)
Set optional port number, 0 or negative value means that default port number will be used.
void SetStopEvent(UInt_t lastindex)
Define the index of Stop event.
void SetEventInterval(UInt_t skipinterval)
Defines event interval.
void AddProxy(const char *pathname, TGo4Proxy *cont, const char *name, const char *title="title")
TGo4Slot * AddLink(TGo4Slot *source, const char *pathname, const char *linkname, const char *linktitle)
void MakeFolder(const char *pathname)
Picture cconfiguration in Go4.
Definition TGo4Picture.h:40
Rev serv parameter.
special base class for remote data servers like DABC, HTTP, hist server
Bool_t IsAnalysisSettingsReady() const
TGo4Slot * LoginfoSlot()
virtual void StartAnalysis()
virtual void StopAnalysis()
void SetAnalysisReady(Bool_t on=kTRUE)
virtual Bool_t DelayedRefreshNamesList(Int_t delay_sec)
TGo4Slot * RatemeterSlot()
virtual void SubmitAnalysisSettings()
TGo4Slot * SettingsSlot()
Bool_t IsAnalysisReady() const
virtual Bool_t NamesListReceived() const
virtual Bool_t RefreshNamesList()
TGo4Proxy * GetProxy() const
Definition TGo4Slot.h:93
void SetExpression(const char *name)