Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TWebCanvas.cxx
Go to the documentation of this file.
1// Author: Sergey Linev, GSI 7/12/2016
2
3/*************************************************************************
4 * Copyright (C) 1995-2023, Rene Brun and Fons Rademakers. *
5 * All rights reserved. *
6 * *
7 * For the licensing terms see $ROOTSYS/LICENSE. *
8 * For the list of contributors see $ROOTSYS/README/CREDITS. *
9 *************************************************************************/
10
11#include "TWebCanvas.h"
12
13#include "TWebSnapshot.h"
14#include "TWebPadPainter.h"
15#include "TWebPS.h"
16#include "TWebMenuItem.h"
17
18#include "TSystem.h"
19#include "TStyle.h"
20#include "TCanvas.h"
21#include "TButton.h"
22#include "TFrame.h"
23#include "TPaveText.h"
24#include "TPaveStats.h"
25#include "TText.h"
26#include "TROOT.h"
27#include "TClass.h"
28#include "TColor.h"
29#include "TObjArray.h"
30#include "TArrayI.h"
31#include "TList.h"
32#include "TF1.h"
33#include "TF2.h"
34#include "TH1.h"
35#include "TH2.h"
36#include "TH1K.h"
37#include "THStack.h"
38#include "TMultiGraph.h"
39#include "TEnv.h"
40#include "TError.h"
41#include "TGraph.h"
42#include "TGraph2D.h"
43#include "TGaxis.h"
44#include "TScatter.h"
45#include "TCutG.h"
46#include "TBufferJSON.h"
47#include "TBase64.h"
48#include "TAtt3D.h"
49#include "TView.h"
50#include "TExec.h"
51#include "TVirtualX.h"
52#include "TMath.h"
53#include "TTimer.h"
54
55#include <cstdio>
56#include <cstring>
57#include <fstream>
58#include <iostream>
59#include <memory>
60#include <sstream>
61#include <vector>
62
63
64class TWebCanvasTimer : public TTimer {
69public:
71
72 Bool_t IsSlow() const { return fSlow; }
73 void SetSlow(Bool_t slow = kTRUE)
74 {
75 fSlow = slow;
76 fSlowCnt = 0;
77 SetTime(slow ? 1000 : 10);
78 }
79
80 /// used to send control messages to clients
81 void Timeout() override
82 {
83 if (fProcessing || fCanv.fProcessingData) return;
87 if (res) {
88 fSlowCnt = 0;
89 } else if (++fSlowCnt > 10 && !IsSlow()) {
91 }
92 }
93};
94
95
96/** \class TWebCanvas
97\ingroup webgui6
98
99Basic TCanvasImp ABI implementation for Web-based Graphics
100Provides painting of main ROOT classes in web browsers using [JSROOT](https://root.cern/js/)
101
102Following settings parameters can be useful for TWebCanvas:
103
104 WebGui.FullCanvas: 1 read-only mode (0), full-functional canvas (1) (default - 1)
105 WebGui.StyleDelivery: 1 provide gStyle object to JSROOT client (default - 1)
106 WebGui.PaletteDelivery: 1 provide color palette to JSROOT client (default - 1)
107 WebGui.TF1UseSave: 0 used saved values for function drawing (1) or calculate function on the client side (0) (default - 0)
108
109TWebCanvas is used by default in interactive ROOT session. To use web-based canvas in batch mode for image
110generation, one should explicitly specify `--web` option when starting ROOT:
111
112 [shell] root -b --web tutorials/hsimple.root -e 'hpxpy->Draw("colz"); c1->SaveAs("image.png");'
113
114If for any reasons TWebCanvas does not provide required functionality, one always can disable it.
115Either by specifying `root --web=off` when starting ROOT or by setting `Canvas.Name: TRootCanvas` in rootrc file.
116
117*/
118
119using namespace std::string_literals;
120
121static const std::string sid_pad_histogram = "__pad_histogram__";
122
123
124struct WebFont_t {
129 WebFont_t() = default;
130 WebFont_t(Int_t indx, const TString &name, const TString &fmt, const TString &data) : fIndx(indx), fName(name), fFormat(fmt), fData(data) {}
131};
132
133static std::vector<WebFont_t> gWebFonts;
134
135////////////////////////////////////////////////////////////////////////////////
136/// Constructor
137
139 : TCanvasImp(c, name, x, y, width, height)
140{
141 fTimer = new TWebCanvasTimer(*this);
142
143 fReadOnly = readonly;
144 fStyleDelivery = gEnv->GetValue("WebGui.StyleDelivery", 1);
145 fPaletteDelivery = gEnv->GetValue("WebGui.PaletteDelivery", 1);
146 fPrimitivesMerge = gEnv->GetValue("WebGui.PrimitivesMerge", 100);
147 fTF1UseSave = gEnv->GetValue("WebGui.TF1UseSave", (Int_t) 1) > 0;
149
150 fWebConn.emplace_back(0); // add special connection which only used to perform updates
151
152 fTimer->TurnOn();
153
154 // fAsyncMode = kTRUE;
155}
156
157
158////////////////////////////////////////////////////////////////////////////////
159/// Destructor
160
162{
163 delete fTimer;
164}
165
166
167//////////////////////////////////////////////////////////////////////////////////////////////////
168/// Add font to static list of fonts upported by the canvas
169/// Name specifies name of the font, second is font file with .ttf or .woff2 extension
170/// Only True Type Fonts (ttf) are supported by PDF
171/// Returns font index which can be used in
172/// auto font_indx = TWebCanvas::AddFont("test", "test.ttf", 2);
173/// gStyle->SetStatFont(font_indx);
174
175Font_t TWebCanvas::AddFont(const char *name, const char *fontfile, Int_t precision)
176{
177 Font_t maxindx = 22;
178 for (auto &entry : gWebFonts) {
179 if (entry.fName == name)
180 return precision > 0 ? entry.fIndx*10 + precision : entry.fIndx;
181 if (entry.fIndx > maxindx)
182 maxindx = entry.fIndx;
183 }
184
185 TString fullname = fontfile, fmt = "ttf";
186 auto pos = fullname.Last('.');
187 if (pos != kNPOS) {
188 fmt = fullname(pos+1, fullname.Length() - pos);
189 fmt.ToLower();
190 if ((fmt != "ttf") && (fmt != "woff2")) {
191 ::Error("TWebCanvas::AddFont", "Unsupported font file extension %s", fmt.Data());
192 return (Font_t) -1;
193 }
194 }
195
196 gSystem->ExpandPathName(fullname);
197
198 if (gSystem->AccessPathName(fullname.Data(), kReadPermission)) {
199 ::Error("TWebCanvas::AddFont", "Not possible to read font file %s", fullname.Data());
200 return (Font_t) -1;
201 }
202
203 std::ifstream is(fullname.Data(), std::ios::in | std::ios::binary);
204 std::string res;
205 if (is) {
206 is.seekg(0, std::ios::end);
207 res.resize(is.tellg());
208 is.seekg(0, std::ios::beg);
209 is.read((char *)res.data(), res.length());
210 if (!is)
211 res.clear();
212 }
213
214 if (res.empty()) {
215 ::Error("TWebCanvas::AddFont", "Fail to read font file %s", fullname.Data());
216 return (Font_t) -1;
217 }
218
219 TString base64 = TBase64::Encode(res.c_str(), res.length());
220
221 maxindx++;
222
223 gWebFonts.emplace_back(maxindx, name, fmt, base64);
224
225 return precision > 0 ? maxindx*10 + precision : maxindx;
226}
227
228////////////////////////////////////////////////////////////////////////////////
229/// Initialize window for the web canvas
230/// At this place canvas is not yet register to the list of canvases - one cannot call RWebWindow::Show()
231
233{
234 return 111222333; // should not be used at all
235}
236
237////////////////////////////////////////////////////////////////////////////////
238/// Creates web-based pad painter
239
241{
242 return new TWebPadPainter();
243}
244
245////////////////////////////////////////////////////////////////////////////////
246/// Returns kTRUE when object is fully supported on JSROOT side
247/// In ROOT7 Paint function will just return appropriate flag that object can be displayed on JSROOT side
248
250{
251 if (!obj)
252 return kTRUE;
253
254 static const struct {
255 const char *name{nullptr};
256 bool with_derived{false};
257 bool reduse_by_many{false};
258 } supported_classes[] = {{"TH1", true},
259 {"TF1", true},
260 {"TGraph", true},
261 {"TScatter"},
262 {"TFrame"},
263 {"THStack"},
264 {"TMultiGraph"},
265 {"TGraphPolargram", true},
266 {"TPave", true},
267 {"TGaxis"},
268 {"TPave", true},
269 {"TArrow"},
270 {"TBox", false, true}, // can be handled via TWebPainter, disable for large number of primitives (like in greyscale.C)
271 {"TWbox"}, // some extra calls which cannot be handled via TWebPainter
272 {"TLine", false, true}, // can be handler via TWebPainter, disable for large number of primitives (like in greyscale.C)
273 {"TEllipse", true, true}, // can be handled via TWebPainter, disable for large number of primitives (like in greyscale.C)
274 {"TText"},
275 {"TLatex"},
276 {"TAnnotation"},
277 {"TMathText"},
278 {"TMarker"},
279 {"TPolyMarker"},
280 {"TPolyLine", true, true}, // can be handled via TWebPainter, simplify colors handling
281 {"TPolyMarker3D"},
282 {"TPolyLine3D"},
283 {"TGraphTime"},
284 {"TGraph2D"},
285 {"TGraph2DErrors"},
286 {"TGraphTime"},
287 {"TASImage"},
288 {"TRatioPlot"},
289 {"TSpline"},
290 {"TSpline3"},
291 {"TSpline5"},
292 {"TGeoManager"},
293 {"TGeoVolume"},
294 {}};
295
296 // fast check of class name
297 for (int i = 0; supported_classes[i].name != nullptr; ++i)
298 if ((!many_primitives || !supported_classes[i].reduse_by_many) && (strcmp(supported_classes[i].name, obj->ClassName()) == 0))
299 return kTRUE;
300
301 // now check inheritance only for configured classes
302 for (int i = 0; supported_classes[i].name != nullptr; ++i)
303 if (supported_classes[i].with_derived && (!many_primitives || !supported_classes[i].reduse_by_many))
304 if (obj->InheritsFrom(supported_classes[i].name))
305 return kTRUE;
306
307 return IsCustomClass(obj->IsA());
308}
309
310//////////////////////////////////////////////////////////////////////////////////////////////////
311/// Configures custom script for canvas.
312/// If started from "load:" or "assert:" prefix will be loaded with JSROOT.AssertPrerequisites function
313/// Script should implement custom user classes, which transferred as is to client
314/// In the script draw handler for appropriate classes would be assigned
315
316void TWebCanvas::SetCustomScripts(const std::string &src)
317{
319}
320
321//////////////////////////////////////////////////////////////////////////////////////////////////
322/// Assign custom class
323
324void TWebCanvas::AddCustomClass(const std::string &clname, bool with_derived)
325{
326 if (with_derived)
327 fCustomClasses.emplace_back("+"s + clname);
328 else
329 fCustomClasses.emplace_back(clname);
330}
331
332//////////////////////////////////////////////////////////////////////////////////////////////////
333/// Checks if class belongs to custom
334
336{
337 for (auto &name : fCustomClasses) {
338 if (name[0] == '+') {
339 if (cl->InheritsFrom(name.substr(1).c_str()))
340 return true;
341 } else if (name.compare(cl->GetName()) == 0) {
342 return true;
343 }
344 }
345 return false;
346}
347
348//////////////////////////////////////////////////////////////////////////////////////////////////
349/// Creates representation of the object for painting in web browser
350
351void TWebCanvas::CreateObjectSnapshot(TPadWebSnapshot &master, TPad *pad, TObject *obj, const char *opt, TWebPS *masterps)
352{
353 if (IsJSSupportedClass(obj, masterps != nullptr)) {
354 master.NewPrimitive(obj, opt).SetSnapshot(TWebSnapshot::kObject, obj);
355 return;
356 }
357
358 // painter is not necessary for batch canvas, but keep configuring it for a while
359 auto *painter = dynamic_cast<TWebPadPainter *>(Canvas()->GetCanvasPainter());
360
361 TView *view = nullptr;
362
364
365 gPad = pad;
366
367 if (obj->InheritsFrom(TAtt3D::Class()) && !pad->GetView()) {
368 pad->GetViewer3D("pad");
369 view = TView::CreateView(1, 0, 0); // Cartesian view by default
370 pad->SetView(view);
371
372 // Set view to perform first auto-range (scaling) pass
373 view->SetAutoRange(kTRUE);
374 }
375
376 TVirtualPS *saveps = gVirtualPS;
377
378 TWebPS ps;
379 gVirtualPS = masterps ? masterps : &ps;
380 if (painter)
381 painter->SetPainting(ps.GetPainting());
382
383 // calling Paint function for the object
384 obj->Paint(opt);
385
386 if (view) {
387 view->SetAutoRange(kFALSE);
388 // call 3D paint once again to make real drawing
389 obj->Paint(opt);
390 pad->SetView(nullptr);
391 }
392
393 if (painter)
394 painter->SetPainting(nullptr);
395
396 gVirtualPS = saveps;
397
398 fPadsStatus[pad]._has_specials = true;
399
400 // if there are master PS, do not create separate entries
401 if (!masterps && !ps.IsEmptyPainting())
403}
404
405//////////////////////////////////////////////////////////////////////////////////////////////////
406/// Calculate hash function for all colors and palette
407
409{
410 UInt_t hash = 0;
411
412 TObjArray *colors = (TObjArray *)gROOT->GetListOfColors();
413
414 if (colors) {
415 for (Int_t n = 0; n <= colors->GetLast(); ++n)
416 if (colors->At(n))
417 hash += TString::Hash(colors->At(n), TColor::Class()->Size());
418 }
419
421
422 hash += TString::Hash(pal.GetArray(), pal.GetSize() * sizeof(Int_t));
423
424 return hash;
425}
426
427
428//////////////////////////////////////////////////////////////////////////////////////////////////
429/// Add special canvas objects with list of colors and color palette
430
432{
433 TObjArray *colors = (TObjArray *)gROOT->GetListOfColors();
434
435 if (!colors)
436 return;
437
438 //Int_t cnt = 0;
439 //for (Int_t n = 0; n <= colors->GetLast(); ++n)
440 // if (colors->At(n))
441 // cnt++;
442 //if (cnt <= 598)
443 // return; // normally there are 598 colors defined
444
446
447 auto listofcols = new TWebPainting;
448 for (Int_t n = 0; n <= colors->GetLast(); ++n)
449 listofcols->AddColor(n, (TColor *)colors->At(n));
450
451 // store palette in the buffer
452 auto *tgt = listofcols->Reserve(pal.GetSize());
453 for (Int_t i = 0; i < pal.GetSize(); i++)
454 tgt[i] = pal[i];
455 listofcols->FixSize();
456
457 master.NewSpecials().SetSnapshot(TWebSnapshot::kColors, listofcols, kTRUE);
458}
459
460//////////////////////////////////////////////////////////////////////////////////////////////////
461/// Add special canvas objects with custom fonts
462
464{
465 for (auto &entry : gWebFonts) {
466 TString code = TString::Format("%d:%s:%s:%s", entry.fIndx, entry.fName.Data(), entry.fFormat.Data(), entry.fData.Data());
467 auto custom_font = new TWebPainting;
468 custom_font->AddOper(code.Data());
469 master.NewSpecials().SetSnapshot(TWebSnapshot::kFont, custom_font, kTRUE);
470 }
471}
472
473//////////////////////////////////////////////////////////////////////////////////////////////////
474/// Create snapshot for pad and all primitives
475/// Callback function is used to create JSON in the middle of data processing -
476/// when all misc objects removed from canvas list of primitives or histogram list of functions
477/// After that objects are moved back to their places
478
480{
481 auto &pad_status = fPadsStatus[pad];
482
483 // send primitives if version 0 or actual pad version grater than already send version
484 bool process_primitives = (version == 0) || (pad_status.fVersion > version);
485
486 if (paddata.IsSetObjectIds()) {
487 paddata.SetActive(pad == gPad);
488 paddata.SetObjectIDAsPtr(pad);
489 }
490 paddata.SetSnapshot(TWebSnapshot::kSubPad, pad); // add ref to the pad
491 paddata.SetWithoutPrimitives(!process_primitives);
492 paddata.SetHasExecs(pad->GetListOfExecs()); // if pad execs are there provide more events from client
493
494 // check style changes every time when creating canvas snapshot
495 if (resfunc && (GetStyleDelivery() > 0)) {
496
498 auto hash = TString::Hash(gStyle, TStyle::Class()->Size());
499 if ((hash != fStyleHash) || (fStyleVersion == 0)) {
500 fStyleHash = hash;
502 }
503 }
504
505 if (fStyleVersion > version)
507 }
508
509 // for the first time add custom fonts to the canvas snapshot
510 if (resfunc && (version == 0))
511 AddCustomFonts(paddata);
512
513 fAllPads.emplace_back(pad);
514
515 TList *primitives = pad->GetListOfPrimitives();
516
517 TWebPS masterps;
518 bool usemaster = primitives ? (primitives->GetSize() > fPrimitivesMerge) : false;
519
520 TIter iter(primitives);
521 TObject *obj = nullptr;
522 TFrame *frame = nullptr;
523 TPaveText *title = nullptr;
524 bool need_frame = false, has_histo = false, need_palette = false;
525 std::string need_title;
526
527 auto checkNeedPalette = [](TH1* hist, const TString &opt) {
528 auto check = [&opt](const TString &arg) {
529 return opt.Contains(arg + "Z") || opt.Contains(arg + "HZ");
530 };
531
532 return ((hist->GetDimension() == 2) && (check("COL") || check("LEGO") || check("LEGO4") || check("SURF2"))) ||
533 ((hist->GetDimension() == 3) && (check("BOX2") || check("BOX3")));
534 };
535
536 while (process_primitives && ((obj = iter()) != nullptr)) {
537 TString opt = iter.GetOption();
538 opt.ToUpper();
539
540 if (obj->InheritsFrom(THStack::Class())) {
541 // workaround for THStack, create extra components before sending to client
542 auto hs = static_cast<THStack *>(obj);
543 if (strlen(obj->GetTitle()) > 0)
544 need_title = obj->GetTitle();
545 TVirtualPad::TContext ctxt(pad, kFALSE);
546 hs->BuildPrimitives(iter.GetOption());
547 has_histo = true;
548 } else if (obj->InheritsFrom(TMultiGraph::Class())) {
549 // workaround for TMultiGraph
550 if (opt.Contains("A")) {
551 auto mg = static_cast<TMultiGraph *>(obj);
553 mg->GetHistogram(); // force creation of histogram without any drawings
554 has_histo = true;
555 if (strlen(obj->GetTitle()) > 0)
556 need_title = obj->GetTitle();
557 }
558 } else if (obj->InheritsFrom(TFrame::Class())) {
559 if (!frame)
560 frame = static_cast<TFrame *>(obj);
561 } else if (obj->InheritsFrom(TH1::Class())) {
562 need_frame = true;
563 has_histo = true;
564 if (!obj->TestBit(TH1::kNoTitle) && !opt.Contains("SAME") && !opt.Contains("AXIS") && !opt.Contains("AXIG") && (strlen(obj->GetTitle()) > 0))
565 need_title = obj->GetTitle();
566 if (checkNeedPalette(static_cast<TH1*>(obj), opt))
567 need_palette = true;
568 } else if (obj->InheritsFrom(TGraph::Class())) {
569 if (opt.Contains("A")) {
570 need_frame = true;
571 if (!has_histo && (strlen(obj->GetTitle()) > 0))
572 need_title = obj->GetTitle();
573 }
574 } else if (obj->InheritsFrom(TGraph2D::Class())) {
575 if (!has_histo && (strlen(obj->GetTitle()) > 0))
576 need_title = obj->GetTitle();
577 } else if (obj->InheritsFrom(TScatter::Class())) {
578 need_frame = need_palette = true;
579 if (strlen(obj->GetTitle()) > 0)
580 need_title = obj->GetTitle();
581 } else if (obj->InheritsFrom(TF1::Class())) {
582 need_frame = !obj->InheritsFrom(TF2::Class());
583 if (!has_histo && (strlen(obj->GetTitle()) > 0))
584 need_title = obj->GetTitle();
585 } else if (obj->InheritsFrom(TPaveText::Class())) {
586 if (strcmp(obj->GetName(), "title") == 0)
587 title = static_cast<TPaveText *>(obj);
588 }
589 }
590
591 if (need_frame && !frame && primitives && CanCreateObject("TFrame")) {
592 if (!IsReadOnly() && need_palette && (pad->GetRightMargin() < 0.12) && (pad->GetRightMargin() == gStyle->GetPadRightMargin()))
593 pad->SetRightMargin(0.12);
594
595 frame = pad->GetFrame();
596 if(frame)
597 primitives->AddFirst(frame);
598 }
599
600 if (!need_title.empty() && gStyle->GetOptTitle()) {
601 if (title) {
602 auto line0 = title->GetLine(0);
603 if (line0 && !IsReadOnly()) line0->SetTitle(need_title.c_str());
604 } else if (primitives && CanCreateObject("TPaveText")) {
605 title = new TPaveText(0, 0, 0, 0, "blNDC");
608 title->SetName("title");
611 title->SetTextFont(gStyle->GetTitleFont(""));
612 if (gStyle->GetTitleFont("") % 10 > 2)
614 title->AddText(need_title.c_str());
615 title->SetBit(kCanDelete);
616 primitives->Add(title);
617 }
618 }
619
620 auto flush_master = [&]() {
621 if (!usemaster || masterps.IsEmptyPainting()) return;
622
624 masterps.CreatePainting(); // create for next operations
625 };
626
627 auto check_cutg_in_options = [&](const TString &opt) {
628 auto p1 = opt.Index("["), p2 = opt.Index("]");
629 if ((p1 != kNPOS) && (p2 != kNPOS) && p2 > p1 + 1) {
630 TString cutname = opt(p1 + 1, p2 - p1 - 1);
631 TObject *cutg = primitives->FindObject(cutname.Data());
632 if (!cutg || (cutg->IsA() != TCutG::Class())) {
633 cutg = gROOT->GetListOfSpecials()->FindObject(cutname.Data());
634 if (cutg && cutg->IsA() == TCutG::Class())
635 paddata.NewPrimitive(cutg, "__ignore_drawing__").SetSnapshot(TWebSnapshot::kObject, cutg);
636 }
637 }
638 };
639
640 auto check_save_tf1 = [&](TObject *fobj, bool ignore_nodraw = false) {
641 if (!paddata.IsBatchMode() && !fTF1UseSave)
642 return;
643 if (!ignore_nodraw && fobj->TestBit(TF1::kNotDraw))
644 return;
645
646 auto f1 = static_cast<TF1 *>(fobj);
647 f1->Save(0, 0, 0, 0, 0, 0);
648 };
649
650 auto create_stats = [&]() {
651 TPaveStats *stats = nullptr;
652 if ((gStyle->GetOptStat() > 0) && CanCreateObject("TPaveStats")) {
653 stats = new TPaveStats(
656 gStyle->GetStatX(),
657 gStyle->GetStatY(), "brNDC");
658
659 // do not set optfit and optstat, they calling pad->Update,
660 // values correctly set already in TPaveStats constructor
661 // stats->SetOptFit(gStyle->GetOptFit());
662 // stats->SetOptStat(gStyle->GetOptStat());
666 stats->SetTextFont(gStyle->GetStatFont());
667 if (gStyle->GetStatFont()%10 > 2)
671 stats->SetName("stats");
672
674 stats->SetTextAlign(12);
675 stats->SetBit(kCanDelete);
676 stats->SetBit(kMustCleanup);
677 }
678
679 return stats;
680 };
681
682 auto check_graph_funcs = [&](TGraph *gr, TList *funcs = nullptr) {
683 if (!funcs && gr)
685 if (!funcs)
686 return;
687
688 TIter fiter(funcs);
689 TPaveStats *stats = nullptr;
690 bool has_tf1 = false;
691
692 while (auto fobj = fiter()) {
693 if (fobj->InheritsFrom(TPaveStats::Class()))
694 stats = dynamic_cast<TPaveStats *> (fobj);
695 else if (fobj->InheritsFrom(TF1::Class())) {
696 check_save_tf1(fobj);
697 has_tf1 = true;
698 }
699 }
700
701 if (!stats && has_tf1 && gr && !gr->TestBit(TGraph::kNoStats)) {
702 stats = create_stats();
703 if (stats) {
704 stats->SetParent(funcs);
705 funcs->Add(stats);
706 }
707 }
708 };
709
710 iter.Reset();
711
712 bool first_obj = true;
713
714 if (process_primitives)
715 pad_status._has_specials = false;
716
717 while ((obj = iter()) != nullptr) {
718 if (obj->InheritsFrom(TPad::Class())) {
719 flush_master();
720 CreatePadSnapshot(paddata.NewSubPad(), (TPad *)obj, version, nullptr);
721 } else if (!process_primitives) {
722 continue;
723 } else if (obj->InheritsFrom(TH1K::Class())) {
724 flush_master();
725 TH1K *hist = static_cast<TH1K *>(obj);
726
727 Int_t nbins = hist->GetXaxis()->GetNbins();
728
729 TH1D *h1 = new TH1D("__dummy_name__", hist->GetTitle(), nbins, hist->GetXaxis()->GetXmin(), hist->GetXaxis()->GetXmax());
730 h1->SetDirectory(nullptr);
731 h1->SetName(hist->GetName());
732 hist->TAttLine::Copy(*h1);
733 hist->TAttFill::Copy(*h1);
734 hist->TAttMarker::Copy(*h1);
735 for (Int_t n = 1; n <= nbins; ++n)
736 h1->SetBinContent(n, hist->GetBinContent(n));
737
738 TIter fiter(hist->GetListOfFunctions());
739 while (auto fobj = fiter())
740 h1->GetListOfFunctions()->Add(fobj->Clone());
741
743
744 } else if (obj->InheritsFrom(TH1::Class())) {
745 flush_master();
746
747 TH1 *hist = static_cast<TH1 *>(obj);
748 hist->BufferEmpty();
749
750 TPaveStats *stats = nullptr;
751 TObject *palette = nullptr;
752
753 TIter fiter(hist->GetListOfFunctions());
754 while (auto fobj = fiter()) {
755 if (fobj->InheritsFrom(TPaveStats::Class()))
756 stats = dynamic_cast<TPaveStats *> (fobj);
757 else if (fobj->InheritsFrom("TPaletteAxis"))
758 palette = fobj;
759 else if (fobj->InheritsFrom(TF1::Class()))
760 check_save_tf1(fobj);
761 }
762
763 TString hopt = iter.GetOption();
764 TString o = hopt;
765 o.ToUpper();
766
767 if (!stats && (first_obj || o.Contains("SAMES"))) {
768 stats = create_stats();
769 if (stats) {
770 stats->SetParent(hist);
771 hist->GetListOfFunctions()->Add(stats);
772 }
773 }
774
775 if (!palette && CanCreateObject("TPaletteAxis") && checkNeedPalette(hist, o)) {
776 std::stringstream exec;
777 exec << "new TPaletteAxis(0,0,0,0, (TH1*)" << std::hex << std::showbase << (size_t)hist << ");";
778 palette = (TObject *)gROOT->ProcessLine(exec.str().c_str());
779 if (palette)
780 hist->GetListOfFunctions()->AddFirst(palette);
781 }
782
783 paddata.NewPrimitive(obj, hopt.Data()).SetSnapshot(TWebSnapshot::kObject, obj);
784
785 if (hist->GetDimension() == 2)
786 check_cutg_in_options(iter.GetOption());
787
788 first_obj = false;
789 } else if (obj->InheritsFrom(TGraph::Class())) {
790 flush_master();
791
792 TGraph *gr = static_cast<TGraph *>(obj);
793
794 check_graph_funcs(gr);
795
796 TString gropt = iter.GetOption();
797
798 // ensure histogram exists on server to draw it properly on clients side
799 if (!IsReadOnly() && (first_obj || gropt.Index("A", 0, TString::kIgnoreCase) != kNPOS ||
800 (gropt.Index("X+", 0, TString::kIgnoreCase) != kNPOS) || (gropt.Index("X+", 0, TString::kIgnoreCase) != kNPOS)))
801 gr->GetHistogram();
802
803 paddata.NewPrimitive(obj, gropt.Data()).SetSnapshot(TWebSnapshot::kObject, obj);
804
805 first_obj = false;
806 } else if (obj->InheritsFrom(TGraph2D::Class())) {
807 flush_master();
808
809 TGraph2D *gr2d = static_cast<TGraph2D *>(obj);
810
811 check_graph_funcs(nullptr, gr2d->GetListOfFunctions());
812
813 // ensure correct range of histogram
814 if (!IsReadOnly() && first_obj) {
815 TString gropt = iter.GetOption();
816 gropt.ToUpper();
817 Bool_t zscale = gropt.Contains("TRI1") || gropt.Contains("TRI2") || gropt.Contains("COL");
818 Bool_t real_draw = gropt.Contains("TRI") || gropt.Contains("LINE") || gropt.Contains("ERR") || gropt.Contains("P0");
819
820 TString hopt = !real_draw ? iter.GetOption() : (zscale ? "lego2z" : "lego2");
821 if (title) hopt.Append(";;use_pad_title");
822
823 // if gr2d not draw - let create histogram with correspondent content
824 auto hist = gr2d->GetHistogram(real_draw ? "empty" : "");
825
826 paddata.NewPrimitive(gr2d, hopt.Data(), "#hist").SetSnapshot(TWebSnapshot::kObject, hist);
827 }
828
829 paddata.NewPrimitive(obj, iter.GetOption()).SetSnapshot(TWebSnapshot::kObject, obj);
830 first_obj = false;
831 } else if (obj->InheritsFrom(TMultiGraph::Class())) {
832 flush_master();
833
834 TMultiGraph *mgr = static_cast<TMultiGraph *>(obj);
835 TIter fiter(mgr->GetListOfFunctions());
836 while (auto fobj = fiter()) {
837 if (fobj->InheritsFrom(TF1::Class()))
838 check_save_tf1(fobj);
839 }
840
841 TIter giter(mgr->GetListOfGraphs());
842 while (auto gobj = giter())
843 check_graph_funcs(static_cast<TGraph *>(gobj));
844
845 paddata.NewPrimitive(obj, iter.GetOption()).SetSnapshot(TWebSnapshot::kObject, obj);
846
847 first_obj = false;
848 } else if (obj->InheritsFrom(TScatter::Class())) {
849 flush_master();
850
851 TScatter *scatter = static_cast<TScatter *>(obj);
852
853 TObject *palette = nullptr;
854
855 TIter fiter(scatter->GetGraph()->GetListOfFunctions());
856 while (auto fobj = fiter()) {
857 if (fobj->InheritsFrom("TPaletteAxis"))
858 palette = fobj;
859 }
860
861 // ensure histogram exists on server to draw it properly on clients side
862 if (!IsReadOnly() && first_obj)
863 scatter->GetHistogram();
864
865 if (!palette && CanCreateObject("TPaletteAxis")) {
866 std::stringstream exec;
867 exec << "new TPaletteAxis(0,0,0,0,0,0);";
868 palette = (TObject *)gROOT->ProcessLine(exec.str().c_str());
869 if (palette)
870 scatter->GetGraph()->GetListOfFunctions()->AddFirst(palette);
871 }
872
873 paddata.NewPrimitive(obj, iter.GetOption()).SetSnapshot(TWebSnapshot::kObject, obj);
874
875 first_obj = false;
876 } else if (obj->InheritsFrom(TF1::Class())) {
877 flush_master();
878 auto f1 = static_cast<TF1 *> (obj);
879
880 TString f1opt = iter.GetOption();
881
882 check_save_tf1(obj, true);
883 // if (fTF1UseSave)
884 // f1opt.Append(";force_saved");
885
886 if (first_obj) {
887 auto hist = f1->GetHistogram();
888 paddata.NewPrimitive(hist, "__ignore_drawing__").SetSnapshot(TWebSnapshot::kObject, hist);
889 f1opt.Append(";webcanv_hist");
890 }
891
892 if (f1->IsA() == TF2::Class())
893 check_cutg_in_options(iter.GetOption());
894
896
897 first_obj = false;
898
899 } else if (obj->InheritsFrom(TGaxis::Class())) {
900 flush_master();
901 auto gaxis = static_cast<TGaxis *> (obj);
902 auto func = gaxis->GetFunction();
903 if (func)
904 paddata.NewPrimitive(func, "__ignore_drawing__").SetSnapshot(TWebSnapshot::kObject, func);
905
906 paddata.NewPrimitive(obj, iter.GetOption()).SetSnapshot(TWebSnapshot::kObject, obj);
907 } else if (obj->InheritsFrom(TFrame::Class())) {
908 flush_master();
909 if (frame && (obj == frame)) {
910 paddata.NewPrimitive(obj, iter.GetOption()).SetSnapshot(TWebSnapshot::kObject, obj);
911 frame = nullptr; // add frame only once
912 }
913 } else if (IsJSSupportedClass(obj, usemaster)) {
914 flush_master();
915 paddata.NewPrimitive(obj, iter.GetOption()).SetSnapshot(TWebSnapshot::kObject, obj);
916 } else {
917 CreateObjectSnapshot(paddata, pad, obj, iter.GetOption(), usemaster ? &masterps : nullptr);
918 }
919 }
920
921 flush_master();
922
923 bool provide_colors = false;
924
925 if ((GetPaletteDelivery() > 2) || ((GetPaletteDelivery() == 2) && resfunc)) {
926 // provide colors: either for each subpad (> 2) or only for canvas (== 2)
927 provide_colors = process_primitives;
928 } else if ((GetPaletteDelivery() == 1) && resfunc) {
929 // check that colors really changing, using hash
930
932 auto hash = CalculateColorsHash();
933 if ((hash != fColorsHash) || (fColorsVersion == 0)) {
934 fColorsHash = hash;
936 }
937 }
938
939 provide_colors = fColorsVersion > version;
940 }
941
942 // add colors after painting is performed - new colors may be generated only during painting
943 if (provide_colors)
944 AddColorsPalette(paddata);
945
946 if (!resfunc)
947 return;
948
949 // now hide all primitives to perform I/O
950 std::vector<TList *> all_primitives(fAllPads.size());
951 for (unsigned n = 0; n < fAllPads.size(); ++n) {
952 all_primitives[n] = fAllPads[n]->fPrimitives;
953 fAllPads[n]->fPrimitives = nullptr;
954 }
955
956 // execute function to prevent storing of colors with custom TCanvas streamer
958
959 // invoke callback for streaming
960 resfunc(&paddata);
961
962 // and restore back primitives - delete any temporary if necessary
963 for (unsigned n = 0; n < fAllPads.size(); ++n) {
964 if (fAllPads[n]->fPrimitives)
965 delete fAllPads[n]->fPrimitives;
966 fAllPads[n]->fPrimitives = all_primitives[n];
967 }
968 fAllPads.clear();
969}
970
971//////////////////////////////////////////////////////////////////////////////////////////////////
972/// Add control message for specified connection
973/// Same control message can be overwritten many time before it really sends to the client
974/// If connid == 0, message will be add to all connections
975/// After ctrl message is add to the output, short timer is activated and message send afterwards
976
977void TWebCanvas::AddCtrlMsg(unsigned connid, const std::string &key, const std::string &value)
978{
979 Bool_t new_ctrl = kFALSE;
980
981 for (auto &conn : fWebConn) {
982 if (conn.match(connid)) {
983 conn.fCtrl[key] = value;
984 new_ctrl = kTRUE;
985 }
986 }
987
988 if (new_ctrl && fTimer->IsSlow())
990}
991
992
993//////////////////////////////////////////////////////////////////////////////////////////////////
994/// Add message to send queue for specified connection
995/// If connid == 0, message will be add to all connections
996
997void TWebCanvas::AddSendQueue(unsigned connid, const std::string &msg)
998{
999 for (auto &conn : fWebConn) {
1000 if (conn.match(connid))
1001 conn.fSend.emplace(msg);
1002 }
1003}
1004
1005
1006//////////////////////////////////////////////////////////////////////////////////////////////////
1007/// Check if any data should be send to client
1008/// If connid != 0, only selected connection will be checked
1009
1011{
1012 if (!Canvas())
1013 return kFALSE;
1014
1015 bool isMoreData = false, isAnySend = false;
1016
1017 for (auto &conn : fWebConn) {
1018
1019 bool isConnData = !conn.fCtrl.empty() || !conn.fSend.empty() ||
1020 ((conn.fCheckedVersion < fCanvVersion) && (conn.fSendVersion == conn.fDrawVersion));
1021
1022 while ((conn.is_batch() && !connid) || (conn.match(connid) && fWindow && fWindow->CanSend(conn.fConnId, true))) {
1023 // check if any control messages still there to keep timer running
1024
1025 std::string buf;
1026
1027 if (!conn.fCtrl.empty()) {
1029 conn.fCtrl.clear();
1030 } else if (!conn.fSend.empty()) {
1031 std::swap(buf, conn.fSend.front());
1032 conn.fSend.pop();
1033 } else if ((conn.fCheckedVersion < fCanvVersion) && (conn.fSendVersion == conn.fDrawVersion)) {
1034
1035 buf = "SNAP6:"s + std::to_string(fCanvVersion) + ":"s;
1036
1037 TCanvasWebSnapshot holder(IsReadOnly(), true, false); // readonly, set ids, batchmode
1038
1039 holder.SetFixedSize(fFixedSize); // set fixed size flag
1040
1041 // scripts send only when canvas drawn for the first time
1042 if (!conn.fSendVersion)
1043 holder.SetScripts(fCustomScripts);
1044
1045 holder.SetHighlightConnect(Canvas()->HasConnection("Highlighted(TVirtualPad*,TObject*,Int_t,Int_t)"));
1046
1047 CreatePadSnapshot(holder, Canvas(), conn.fSendVersion, [&buf, &conn, this](TPadWebSnapshot *snap) {
1048 if (conn.is_batch()) {
1049 // for batch connection only calling of CreatePadSnapshot is important
1050 buf.clear();
1051 return;
1052 }
1053
1054 auto json = TBufferJSON::ToJSON(snap, fJsonComp);
1055 auto hash = json.Hash();
1056 if (conn.fLastSendHash && (conn.fLastSendHash == hash) && conn.fSendVersion) {
1057 // prevent looping when same data send many times
1058 buf.clear();
1059 } else {
1060 buf.append(json.Data());
1061 conn.fLastSendHash = hash;
1062 }
1063 });
1064
1065 conn.fCheckedVersion = fCanvVersion;
1066
1067 conn.fSendVersion = fCanvVersion;
1068
1069 if (buf.empty())
1070 conn.fDrawVersion = fCanvVersion;
1071 } else {
1072 isConnData = false;
1073 break;
1074 }
1075
1076 if (!buf.empty() && !conn.is_batch()) {
1077 fWindow->Send(conn.fConnId, buf);
1078 isAnySend = true;
1079 }
1080 }
1081
1082 if (isConnData)
1083 isMoreData = true;
1084 }
1085
1086 if (fTimer->IsSlow() && isMoreData)
1087 fTimer->SetSlow(kFALSE);
1088
1089 return isAnySend;
1090}
1091
1092//////////////////////////////////////////////////////////////////////////////////////////
1093/// Close web canvas - not implemented
1094
1096{
1097}
1098
1099//////////////////////////////////////////////////////////////////////////////////////////
1100/// Show canvas in specified place.
1101/// If parameter args not specified, default ROOT web display will be used
1102
1104{
1105 if (!fWindow) {
1107
1108 fWindow->SetConnLimit(0); // configure connections limit
1109
1110 fWindow->SetDefaultPage("file:rootui5sys/canv/canvas6.html");
1111
1112 fWindow->SetCallBacks(
1113 // connection
1114 [this](unsigned connid) {
1115 fWebConn.emplace_back(connid);
1116 CheckDataToSend(connid);
1117 },
1118 // data
1119 [this](unsigned connid, const std::string &arg) {
1120 ProcessData(connid, arg);
1122 },
1123 // disconnect
1124 [this](unsigned connid) {
1125 unsigned indx = 0;
1126 for (auto &c : fWebConn) {
1127 if (c.fConnId == connid) {
1128 fWebConn.erase(fWebConn.begin() + indx);
1129 break;
1130 }
1131 indx++;
1132 }
1133 });
1134 }
1135
1136 auto w = Canvas()->GetWindowWidth(), h = Canvas()->GetWindowHeight();
1137 if ((w > 0) && (w < 50000) && (h > 0) && (h < 30000))
1138 fWindow->SetGeometry(w, h);
1139
1144
1145 fWindow->Show(args);
1146}
1147
1148//////////////////////////////////////////////////////////////////////////////////////////
1149/// Show canvas in browser window
1150
1152{
1153 if (gROOT->IsWebDisplayBatch())
1154 return;
1155
1157 args.SetWidgetKind("TCanvas");
1158 args.SetSize(Canvas()->GetWindowWidth(), Canvas()->GetWindowHeight());
1159 args.SetPos(Canvas()->GetWindowTopX(), Canvas()->GetWindowTopY());
1160
1161 ShowWebWindow(args);
1162}
1163
1164//////////////////////////////////////////////////////////////////////////////////////////
1165/// Function used to send command to browser to toggle menu, toolbar, editors, ...
1166
1167void TWebCanvas::ShowCmd(const std::string &arg, Bool_t show)
1168{
1169 AddCtrlMsg(0, arg, show ? "1"s : "0"s);
1170}
1171
1172//////////////////////////////////////////////////////////////////////////////////////////
1173/// Activate object in editor in web browser
1174
1176{
1177 if (!pad || !obj) return;
1178
1179 UInt_t hash = TString::Hash(&obj, sizeof(obj));
1180
1181 AddCtrlMsg(0, "edit"s, std::to_string(hash));
1182}
1183
1184//////////////////////////////////////////////////////////////////////////////////////////
1185/// Returns kTRUE if web canvas has graphical editor
1186
1188{
1189 return (fClientBits & TCanvas::kShowEditor) != 0;
1190}
1191
1192//////////////////////////////////////////////////////////////////////////////////////////
1193/// Returns kTRUE if web canvas has menu bar
1194
1196{
1197 return (fClientBits & TCanvas::kMenuBar) != 0;
1198}
1199
1200//////////////////////////////////////////////////////////////////////////////////////////
1201/// Returns kTRUE if web canvas has status bar
1202
1204{
1205 return (fClientBits & TCanvas::kShowEventStatus) != 0;
1206}
1207
1208//////////////////////////////////////////////////////////////////////////////////////////
1209/// Returns kTRUE if tooltips are activated in web canvas
1210
1212{
1213 return (fClientBits & TCanvas::kShowToolTips) != 0;
1214}
1215
1216//////////////////////////////////////////////////////////////////////////////////////////
1217/// Set window position of web canvas
1218
1220{
1221 AddCtrlMsg(0, "x"s, std::to_string(x));
1222 AddCtrlMsg(0, "y"s, std::to_string(y));
1223}
1224
1225//////////////////////////////////////////////////////////////////////////////////////////
1226/// Set window size of web canvas
1227
1229{
1230 AddCtrlMsg(0, "w"s, std::to_string(w));
1231 AddCtrlMsg(0, "h"s, std::to_string(h));
1232}
1233
1234//////////////////////////////////////////////////////////////////////////////////////////
1235/// Set window title of web canvas
1236
1237void TWebCanvas::SetWindowTitle(const char *newTitle)
1238{
1239 AddCtrlMsg(0, "title"s, newTitle);
1240}
1241
1242//////////////////////////////////////////////////////////////////////////////////////////
1243/// Set canvas size of web canvas
1244
1246{
1247 fFixedSize = kTRUE;
1248 AddCtrlMsg(0, "cw"s, std::to_string(cw));
1249 AddCtrlMsg(0, "ch"s, std::to_string(ch));
1250 if ((cw > 0) && (ch > 0)) {
1251 Canvas()->fCw = cw;
1252 Canvas()->fCh = ch;
1253 } else {
1254 // temporary value, will be reported back from client
1255 Canvas()->fCw = Canvas()->fWindowWidth;
1257 }
1258}
1259
1260//////////////////////////////////////////////////////////////////////////////////////////
1261/// Iconify browser window
1262
1264{
1265 AddCtrlMsg(0, "winstate"s, "iconify"s);
1266}
1267
1268//////////////////////////////////////////////////////////////////////////////////////////
1269/// Raise browser window
1270
1272{
1273 AddCtrlMsg(0, "winstate"s, "raise"s);
1274}
1275
1276//////////////////////////////////////////////////////////////////////////////////////////
1277/// Assign clients bits
1278
1280{
1281 fClientBits = bits;
1286}
1287
1288//////////////////////////////////////////////////////////////////////////////////////////////////
1289/// Decode all pad options, which includes ranges plus objects options
1290
1291Bool_t TWebCanvas::DecodePadOptions(const std::string &msg, bool process_execs)
1292{
1293 if (IsReadOnly() || msg.empty())
1294 return kFALSE;
1295
1296 auto arr = TBufferJSON::FromJSON<std::vector<TWebPadOptions>>(msg);
1297
1298 if (!arr)
1299 return kFALSE;
1300
1301 Bool_t need_update = kFALSE;
1302
1303 TPad *pad_with_execs = nullptr;
1304 TExec *hist_exec = nullptr;
1305
1306 for (unsigned n = 0; n < arr->size(); ++n) {
1307 auto &r = arr->at(n);
1308
1309 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(r.snapid));
1310
1311 if (!pad)
1312 continue;
1313
1314 if (pad == Canvas()) {
1315 AssignStatusBits(r.bits);
1316 Canvas()->fCw = r.cw;
1317 Canvas()->fCh = r.ch;
1318 if (r.w.size() == 4) {
1319 fWindowGeometry = r.w;
1324 }
1325 }
1326
1327 // only if get OPTIONS message from client allow to change gPad
1328 if (r.active && (pad != gPad) && process_execs)
1329 gPad = pad;
1330
1331 if ((pad->GetTickx() != r.tickx) || (pad->GetTicky() != r.ticky))
1332 pad->SetTicks(r.tickx, r.ticky);
1333 if ((pad->GetGridx() != (r.gridx > 0)) || (pad->GetGridy() != (r.gridy > 0)))
1334 pad->SetGrid(r.gridx, r.gridy);
1335 pad->fLogx = r.logx;
1336 pad->fLogy = r.logy;
1337 pad->fLogz = r.logz;
1338
1339 pad->SetLeftMargin(r.mleft);
1340 pad->SetRightMargin(r.mright);
1341 pad->SetTopMargin(r.mtop);
1342 pad->SetBottomMargin(r.mbottom);
1343
1344 if (r.ranges) {
1345 // avoid call of original methods, set members directly
1346 // pad->Range(r.px1, r.py1, r.px2, r.py2);
1347 // pad->RangeAxis(r.ux1, r.uy1, r.ux2, r.uy2);
1348
1349 pad->fX1 = r.px1;
1350 pad->fX2 = r.px2;
1351 pad->fY1 = r.py1;
1352 pad->fY2 = r.py2;
1353
1354 pad->fUxmin = r.ux1;
1355 pad->fUxmax = r.ux2;
1356 pad->fUymin = r.uy1;
1357 pad->fUymax = r.uy2;
1358 }
1359
1360 // pad->SetPad(r.mleft, r.mbottom, 1-r.mright, 1-r.mtop);
1361
1362 pad->fAbsXlowNDC = r.xlow;
1363 pad->fAbsYlowNDC = r.ylow;
1364 pad->fAbsWNDC = r.xup - r.xlow;
1365 pad->fAbsHNDC = r.yup - r.ylow;
1366
1367 if (pad == Canvas()) {
1368 pad->fXlowNDC = r.xlow;
1369 pad->fYlowNDC = r.ylow;
1370 pad->fXUpNDC = r.xup;
1371 pad->fYUpNDC = r.yup;
1372 pad->fWNDC = r.xup - r.xlow;
1373 pad->fHNDC = r.yup - r.ylow;
1374 } else {
1375 auto mother = pad->GetMother();
1376 if (mother->GetAbsWNDC() > 0. && mother->GetAbsHNDC() > 0.) {
1377 pad->fXlowNDC = (r.xlow - mother->GetAbsXlowNDC()) / mother->GetAbsWNDC();
1378 pad->fYlowNDC = (r.ylow - mother->GetAbsYlowNDC()) / mother->GetAbsHNDC();
1379 pad->fXUpNDC = (r.xup - mother->GetAbsXlowNDC()) / mother->GetAbsWNDC();
1380 pad->fYUpNDC = (r.yup - mother->GetAbsYlowNDC()) / mother->GetAbsHNDC();
1381 pad->fWNDC = (r.xup - r.xlow) / mother->GetAbsWNDC();
1382 pad->fHNDC = (r.yup - r.ylow) / mother->GetAbsHNDC();
1383 }
1384 }
1385
1386 // copy of code from TPad::ResizePad()
1387
1388 Double_t pxlow = r.xlow * r.cw;
1389 Double_t pylow = (1-r.ylow) * r.ch;
1390 Double_t pxrange = (r.xup - r.xlow) * r.cw;
1391 Double_t pyrange = -1*(r.yup - r.ylow) * r.ch;
1392
1393 Double_t rounding = 0.00005;
1394 Double_t xrange = r.px2 - r.px1;
1395 Double_t yrange = r.py2 - r.py1;
1396
1397 if ((xrange != 0.) && (pxrange != 0)) {
1398 // Linear X axis
1399 pad->fXtoAbsPixelk = rounding + pxlow - pxrange*r.px1/xrange; //origin at left
1400 pad->fXtoPixelk = rounding + -pxrange*r.px1/xrange;
1401 pad->fXtoPixel = pxrange/xrange;
1402 pad->fAbsPixeltoXk = r.px1 - pxlow*xrange/pxrange;
1403 pad->fPixeltoXk = r.px1;
1404 pad->fPixeltoX = xrange/pxrange;
1405 }
1406
1407 if ((yrange != 0.) && (pyrange != 0.)) {
1408 // Linear Y axis
1409 pad->fYtoAbsPixelk = rounding + pylow - pyrange*r.py1/yrange; //origin at top
1410 pad->fYtoPixelk = rounding + -pyrange - pyrange*r.py1/yrange;
1411 pad->fYtoPixel = pyrange/yrange;
1412 pad->fAbsPixeltoYk = r.py1 - pylow*yrange/pyrange;
1413 pad->fPixeltoYk = r.py1;
1414 pad->fPixeltoY = yrange/pyrange;
1415 }
1416
1418
1419 TObjLink *objlnk = nullptr;
1420
1421 TH1 *hist = static_cast<TH1 *>(FindPrimitive(sid_pad_histogram, 1, pad, &objlnk));
1422
1423 if (hist) {
1424
1425 TObject *hist_holder = objlnk ? objlnk->GetObject() : nullptr;
1426 if (hist_holder == hist)
1427 hist_holder = nullptr;
1428
1429 Bool_t no_entries = hist->GetEntries();
1430
1431 Double_t hmin = 0., hmax = 0.;
1432
1433 if (r.zx1 == r.zx2)
1434 hist->GetXaxis()->SetRange(0,0);
1435 else
1436 hist->GetXaxis()->SetRangeUser(r.zx1, r.zx2);
1437
1438 if (hist->GetDimension() == 1) {
1439 hmin = r.zy1;
1440 hmax = r.zy2;
1441 if ((hmin == hmax) && !no_entries) {
1442 // if there are no zooming on Y and histogram has no entries, hmin/hmax should be set to full range
1443 hmin = pad->fLogy ? TMath::Power(pad->fLogy < 2 ? 10 : pad->fLogy, r.uy1) : r.uy1;
1444 hmax = pad->fLogy ? TMath::Power(pad->fLogy < 2 ? 10 : pad->fLogy, r.uy2) : r.uy2;
1445 }
1446 } else if (r.zy1 == r.zy2) {
1447 hist->GetYaxis()->SetRange(0., 0.);
1448 } else {
1449 hist->GetYaxis()->SetRangeUser(r.zy1, r.zy2);
1450 }
1451
1452 if (hist->GetDimension() == 2) {
1453 hmin = r.zz1;
1454 hmax = r.zz2;
1455 if ((hmin == hmax) && !no_entries) {
1456 // z scale is not transformed
1457 hmin = r.uz1;
1458 hmax = r.uz2;
1459 }
1460 } else if (hist->GetDimension() == 3) {
1461 if (r.zz1 == r.zz2) {
1462 hist->GetZaxis()->SetRange(0., 0.);
1463 } else {
1464 hist->GetZaxis()->SetRangeUser(r.zz1, r.zz2);
1465 }
1466 }
1467
1468 if (hmin == hmax)
1469 hmin = hmax = -1111;
1470
1471 if (!hist_holder || (hist_holder->IsA() == TScatter::Class())) {
1472 hist->SetMinimum(hmin);
1473 hist->SetMaximum(hmax);
1474 } else {
1475 auto SetMember = [hist_holder](const char *name, Double_t value) {
1476 auto offset = hist_holder->IsA()->GetDataMemberOffset(name);
1477 if (offset > 0)
1478 *((Double_t *)((char*) hist_holder + offset)) = value;
1479 else
1480 ::Error("SetMember", "Cannot find %s data member in %s", name, hist_holder->ClassName());
1481 };
1482
1483 // directly set min/max in classes like THStack, TGraph, TMultiGraph
1484 SetMember("fMinimum", hmin);
1485 SetMember("fMaximum", hmax);
1486 }
1487
1488 TIter next(hist->GetListOfFunctions());
1489 while (auto fobj = next())
1490 if (!hist_exec && fobj->InheritsFrom(TExec::Class())) {
1491 hist_exec = (TExec *) fobj;
1492 need_update = kTRUE;
1493 }
1494 }
1495
1496 std::map<std::string, int> idmap;
1497
1498 for (auto &item : r.primitives) {
1499 auto iter = idmap.find(item.snapid);
1500 int idcnt = 1;
1501 if (iter == idmap.end())
1502 idmap[item.snapid] = 1;
1503 else
1504 idcnt = ++iter->second;
1505
1506 ProcessObjectOptions(item, pad, idcnt);
1507 }
1508
1509 // without special objects no need for explicit update of the pad
1510 if (fPadsStatus[pad]._has_specials) {
1511 pad->Modified(kTRUE);
1512 need_update = kTRUE;
1513 }
1514
1515 if (process_execs && (gPad == pad))
1516 pad_with_execs = pad;
1517 }
1518
1519 ProcessExecs(pad_with_execs, hist_exec);
1520
1521 if (fUpdatedSignal) fUpdatedSignal(); // invoke signal
1522
1523 return need_update;
1524}
1525
1526//////////////////////////////////////////////////////////////////////////////////////////////////
1527/// Process TExec objects in the pad
1528
1530{
1531 auto execs = pad ? pad->GetListOfExecs() : nullptr;
1532
1533 if ((!execs || !execs->GetSize()) && !extra)
1534 return;
1535
1536 auto saveps = gVirtualPS;
1537 TWebPS ps;
1538 gVirtualPS = &ps;
1539
1540 auto savex = gVirtualX;
1541 TVirtualX x;
1542 gVirtualX = &x;
1543
1544 TIter next(execs);
1545 while (auto obj = next()) {
1546 auto exec = dynamic_cast<TExec *>(obj);
1547 if (exec)
1548 exec->Exec();
1549 }
1550
1551 if (extra)
1552 extra->Exec();
1553
1554 gVirtualPS = saveps;
1555 gVirtualX = savex;
1556}
1557
1558//////////////////////////////////////////////////////////////////////////////////////////
1559/// Execute one or several methods for selected object
1560/// String can be separated by ";;" to let execute several methods at once
1561void TWebCanvas::ProcessLinesForObject(TObject *obj, const std::string &lines)
1562{
1563 std::string buf = lines;
1564
1565 Int_t indx = 0;
1566
1567 while (obj && !buf.empty()) {
1568 std::string sub = buf;
1569 auto pos = buf.find(";;");
1570 if (pos == std::string::npos) {
1571 sub = buf;
1572 buf.clear();
1573 } else {
1574 sub = buf.substr(0,pos);
1575 buf = buf.substr(pos+2);
1576 }
1577 if (sub.empty()) continue;
1578
1579 std::stringstream exec;
1580 exec << "((" << obj->ClassName() << " *) " << std::hex << std::showbase << (size_t)obj << ")->" << sub << ";";
1581 if (indx < 3 || gDebug > 0)
1582 Info("ProcessLinesForObject", "Obj %s Execute %s", obj->GetName(), exec.str().c_str());
1583 gROOT->ProcessLine(exec.str().c_str());
1584 indx++;
1585 }
1586}
1587
1588//////////////////////////////////////////////////////////////////////////////////////////
1589/// Handle data from web browser
1590/// Returns kFALSE if message was not processed
1591
1592Bool_t TWebCanvas::ProcessData(unsigned connid, const std::string &arg)
1593{
1594 if (arg.empty())
1595 return kTRUE;
1596
1597 // try to identify connection for given WS request
1598 unsigned indx = 0; // first connection is batch and excluded
1599 while(++indx < fWebConn.size()) {
1600 if (fWebConn[indx].fConnId == connid)
1601 break;
1602 }
1603 if (indx >= fWebConn.size())
1604 return kTRUE;
1605
1606 Bool_t is_main_connection = indx == 1; // first connection allow to make changes
1607
1608 struct FlagGuard {
1609 Bool_t &flag;
1610 FlagGuard(Bool_t &_flag) : flag(_flag) { flag = true; }
1611 ~FlagGuard() { flag = false; }
1612 };
1613
1614 FlagGuard guard(fProcessingData);
1615
1616 const char *cdata = arg.c_str();
1617
1618 if (arg == "KEEPALIVE") {
1619 // do nothing
1620
1621 } else if (arg == "QUIT") {
1622
1623 // use window manager to correctly terminate http server
1624 fWindow->TerminateROOT();
1625
1626 } else if (arg.compare(0, 7, "READY6:") == 0) {
1627
1628 // this is reply on drawing of ROOT6 snapshot
1629 // it confirms when drawing of specific canvas version is completed
1630
1631 cdata += 7;
1632
1633 const char *separ = strchr(cdata, ':');
1634 if (!separ) {
1635 fWebConn[indx].fDrawVersion = std::stoll(cdata);
1636 } else {
1637 fWebConn[indx].fDrawVersion = std::stoll(std::string(cdata, separ - cdata));
1638 if (is_main_connection && !IsReadOnly())
1639 if (DecodePadOptions(separ+1, false))
1641 }
1642
1643 } else if (arg == "RELOAD") {
1644
1645 // trigger reload of canvas data
1646 fWebConn[indx].reset();
1647
1648 } else if (arg.compare(0, 5, "SAVE:") == 0) {
1649
1650 // save image produced by the client side - like png or svg
1651 const char *img = cdata + 5;
1652
1653 const char *separ = strchr(img, ':');
1654 if (separ) {
1655 TString filename(img, separ - img);
1656 img = separ + 1;
1657
1658 std::ofstream ofs(filename.Data());
1659
1660 if (filename.Index(".svg") != kNPOS) {
1661 // ofs << "<?xml version=\"1.0\" standalone=\"no\"?>";
1662 ofs << img;
1663 } else {
1664 TString binary = TBase64::Decode(img);
1665 ofs.write(binary.Data(), binary.Length());
1666 }
1667 ofs.close();
1668
1669 Info("ProcessData", "File %s has been created", filename.Data());
1670 }
1671
1672 } else if (arg.compare(0, 8, "PRODUCE:") == 0) {
1673
1674 // create ROOT, PDF, ... files using native ROOT functionality
1675 Canvas()->Print(arg.c_str() + 8);
1676
1677 } else if (arg.compare(0, 9, "OPTIONS6:") == 0) {
1678
1679 if (is_main_connection && !IsReadOnly())
1680 if (DecodePadOptions(arg.substr(9), true))
1682
1683 } else if (arg.compare(0, 11, "STATUSBITS:") == 0) {
1684
1685 if (is_main_connection) {
1686 AssignStatusBits(std::stoul(arg.substr(11)));
1687 if (fUpdatedSignal) fUpdatedSignal(); // invoke signal
1688 }
1689 } else if (arg.compare(0, 10, "HIGHLIGHT:") == 0) {
1690 if (is_main_connection) {
1691 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(10));
1692 if (!arr || (arr->size() != 4)) {
1693 Error("ProcessData", "Wrong arguments count %d in highlight message", (int)(arr ? arr->size() : -1));
1694 } else {
1695 auto pad = dynamic_cast<TVirtualPad *>(FindPrimitive(arr->at(0)));
1696 auto obj = FindPrimitive(arr->at(1));
1697 int argx = std::stoi(arr->at(2));
1698 int argy = std::stoi(arr->at(3));
1699 if (pad && obj) {
1700 Canvas()->Highlighted(pad, obj, argx, argy);
1702 }
1703 }
1704 }
1705 } else if (ROOT::RWebWindow::IsFileDialogMessage(arg)) {
1706
1708
1709 } else if (arg == "FITPANEL"s) {
1710
1711 TH1 *hist = nullptr;
1712 TIter iter(Canvas()->GetListOfPrimitives());
1713 while (auto obj = iter()) {
1714 hist = dynamic_cast<TH1 *>(obj);
1715 if (hist) break;
1716 }
1717
1718 TString cmd = TString::Format("auto panel = std::make_shared<ROOT::Experimental::RFitPanel>(\"FitPanel\");"
1719 "panel->AssignCanvas(\"%s\");"
1720 "panel->AssignHistogram((TH1 *)0x%zx);"
1721 "panel->Show();"
1722 "panel->ClearOnClose(panel);", Canvas()->GetName(), (size_t) hist);
1723
1724 gROOT->ProcessLine(cmd.Data());
1725
1726 } else if (arg == "START_BROWSER"s) {
1727
1728 gROOT->ProcessLine("new TBrowser;");
1729
1730 } else if (IsReadOnly()) {
1731
1732 // all following messages are not allowed in readonly mode
1733 return kFALSE;
1734
1735 } else if (arg.compare(0, 6, "EVENT:") == 0) {
1736 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(6));
1737 if (!arr || (arr->size() != 5)) {
1738 Error("ProcessData", "Wrong arguments count %d in event message", (int)(arr ? arr->size() : -1));
1739 } else {
1740 auto pad = dynamic_cast<TPad *>(FindPrimitive(arr->at(0)));
1741 std::string kind = arr->at(1);
1742 int event = -1;
1743 if (kind == "move"s) event = kMouseMotion;
1744 int argx = std::stoi(arr->at(2));
1745 int argy = std::stoi(arr->at(3));
1746 auto selobj = FindPrimitive(arr->at(4));
1747
1748 if ((event >= 0) && pad && (pad == gPad)) {
1749 Canvas()->fEvent = event;
1750 Canvas()->fEventX = argx;
1751 Canvas()->fEventY = argy;
1752
1753 Canvas()->fSelected = selobj;
1754
1755 ProcessExecs(pad);
1756 }
1757 }
1758
1759 } else if (arg.compare(0, 8, "GETMENU:") == 0) {
1760
1761 TObject *obj = FindPrimitive(arg.substr(8));
1762 if (!obj)
1763 obj = Canvas();
1764
1765 TWebMenuItems items(arg.c_str() + 8);
1766 items.PopulateObjectMenu(obj, obj->IsA());
1767 std::string buf = "MENU:";
1768 buf.append(TBufferJSON::ToJSON(&items, 103).Data());
1769
1770 AddSendQueue(connid, buf);
1771
1772 } else if (arg.compare(0, 8, "PRIMIT6:") == 0) {
1773
1774 if (IsFirstConn(connid) && !IsReadOnly()) { // only first connection can modify object
1775
1776 auto opt = TBufferJSON::FromJSON<TWebObjectOptions>(arg.c_str() + 8);
1777
1778 if (opt) {
1779 TPad *modpad = ProcessObjectOptions(*opt, nullptr);
1780
1781 // indicate that pad was modified
1782 if (modpad)
1783 modpad->Modified();
1784 }
1785 }
1786
1787 } else if (arg.compare(0, 11, "PADCLICKED:") == 0) {
1788
1789 auto click = TBufferJSON::FromJSON<TWebPadClick>(arg.c_str() + 11);
1790
1791 if (click && IsFirstConn(connid) && !IsReadOnly()) {
1792
1793 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(click->padid));
1794
1795 if (pad && pad->InheritsFrom(TButton::Class())) {
1796 auto btn = (TButton *) pad;
1797 const char *mthd = btn->GetMethod();
1798 if (mthd && *mthd) {
1799 TVirtualPad::TContext ctxt(gROOT->GetSelectedPad(), kTRUE, kTRUE);
1800 gROOT->ProcessLine(mthd);
1801 }
1802 return kTRUE;
1803 }
1804
1805 if (pad && (pad != gPad)) {
1806 gPad = pad;
1810 }
1811
1812 if (!click->objid.empty()) {
1813 auto selobj = FindPrimitive(click->objid);
1814 Canvas()->SetClickSelected(selobj);
1815 Canvas()->fSelected = selobj;
1816 if (pad && selobj && fObjSelectSignal)
1817 fObjSelectSignal(pad, selobj);
1818 }
1819
1820 if ((click->x >= 0) && (click->y >= 0)) {
1821 Canvas()->fEvent = click->dbl ? kButton1Double : kButton1Up;
1822 Canvas()->fEventX = click->x;
1823 Canvas()->fEventY = click->y;
1824 if (click->dbl && fPadDblClickedSignal)
1825 fPadDblClickedSignal(pad, click->x, click->y);
1826 else if (!click->dbl && fPadClickedSignal)
1827 fPadClickedSignal(pad, click->x, click->y);
1828 }
1829
1830 ProcessExecs(pad);
1831 }
1832
1833 } else if (arg.compare(0, 8, "OBJEXEC:") == 0) {
1834
1835 auto buf = arg.substr(8);
1836 auto pos = buf.find(":");
1837
1838 if ((pos > 0) && IsFirstConn(connid) && !IsReadOnly()) { // only first client can execute commands
1839 auto sid = buf.substr(0, pos);
1840 buf.erase(0, pos + 1);
1841
1842 TObjLink *lnk = nullptr;
1843 TPad *objpad = nullptr;
1844
1845 TObject *obj = FindPrimitive(sid, 1, nullptr, &lnk, &objpad);
1846
1847 if (obj && !buf.empty()) {
1848
1849 ProcessLinesForObject(obj, buf);
1850
1851 if (objpad)
1852 objpad->Modified();
1853 else
1854 Canvas()->Modified();
1855
1857 }
1858 }
1859
1860 } else if (arg.compare(0, 12, "EXECANDSEND:") == 0) {
1861
1862 // execute method and send data, used by drawing projections
1863
1864 std::string buf = arg.substr(12);
1865 std::string reply;
1866 TObject *obj = nullptr;
1867
1868 auto pos = buf.find(":");
1869
1870 if ((pos > 0) && IsFirstConn(connid) && !IsReadOnly()) {
1871 // only first client can execute commands
1872 reply = buf.substr(0, pos);
1873 buf.erase(0, pos + 1);
1874 pos = buf.find(":");
1875 if (pos > 0) {
1876 auto sid = buf.substr(0, pos);
1877 buf.erase(0, pos + 1);
1878 obj = FindPrimitive(sid);
1879 }
1880 }
1881
1882 if (obj && !buf.empty() && !reply.empty()) {
1883 std::stringstream exec;
1884 exec << "((" << obj->ClassName() << " *) " << std::hex << std::showbase << (size_t)obj
1885 << ")->" << buf << ";";
1886 if (gDebug > 1)
1887 Info("ProcessData", "Obj %s Exec %s", obj->GetName(), exec.str().c_str());
1888
1889 auto res = gROOT->ProcessLine(exec.str().c_str());
1890 TObject *resobj = (TObject *)(res);
1891 if (resobj) {
1892 std::string send = reply;
1893 send.append(":");
1894 send.append(TBufferJSON::ToJSON(resobj, 23).Data());
1895 AddSendQueue(connid, send);
1896 if (reply[0] == 'D')
1897 delete resobj; // delete object if first symbol in reply is D
1898 }
1899 }
1900
1901 } else if (arg.compare(0, 6, "CLEAR:") == 0) {
1902 std::string snapid = arg.substr(6);
1903
1904 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(snapid));
1905
1906 if (pad) {
1907 pad->Clear();
1908 pad->Modified();
1910 } else {
1911 Error("ProcessData", "Not found pad with id %s to clear\n", snapid.c_str());
1912 }
1913 } else if (arg.compare(0, 7, "DIVIDE:") == 0) {
1914 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(7));
1915 if (arr && arr->size() == 2) {
1916 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(arr->at(0)));
1917 int nn = 0, n1 = 0, n2 = 0;
1918
1919 std::string divide = arr->at(1);
1920 auto p = divide.find('x');
1921 if (p == std::string::npos)
1922 p = divide.find('X');
1923
1924 if (p != std::string::npos) {
1925 n1 = std::stoi(divide.substr(0,p));
1926 n2 = std::stoi(divide.substr(p+1));
1927 } else {
1928 nn = std::stoi(divide);
1929 }
1930
1931 if (pad && ((nn > 1) || (n1*n2 > 1))) {
1932 pad->Clear();
1933 pad->Modified();
1934 if (nn > 1)
1935 pad->DivideSquare(nn);
1936 else
1937 pad->Divide(n1, n2);
1938 pad->cd(1);
1940 }
1941 }
1942
1943 } else if (arg.compare(0, 8, "DRAWOPT:") == 0) {
1944 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(8));
1945 if (arr && arr->size() == 2) {
1946 TObjLink *objlnk = nullptr;
1947 FindPrimitive(arr->at(0), 1, nullptr, &objlnk);
1948 if (objlnk)
1949 objlnk->SetOption(arr->at(1).c_str());
1950 }
1951 } else if (arg.compare(0, 8, "RESIZED:") == 0) {
1952 auto arr = TBufferJSON::FromJSON<std::vector<int>>(arg.substr(8));
1953 if (arr && arr->size() == 7) {
1954 // set members directly to avoid redrawing of the client again
1955 Canvas()->fCw = arr->at(4);
1956 Canvas()->fCh = arr->at(5);
1957 fFixedSize = arr->at(6) > 0;
1958 arr->resize(4);
1959 fWindowGeometry = *arr;
1964 }
1965 } else if (arg.compare(0, 7, "POPOBJ:") == 0) {
1966 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(7));
1967 if (arr && arr->size() == 2) {
1968 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(arr->at(0)));
1969 TObject *obj = FindPrimitive(arr->at(1), 0, pad);
1970 if (pad && obj && (obj != pad->GetListOfPrimitives()->Last())) {
1971 TIter next(pad->GetListOfPrimitives());
1972 while (auto o = next())
1973 if (obj == o) {
1974 TString opt = next.GetOption();
1975 pad->GetListOfPrimitives()->Remove(obj);
1976 pad->GetListOfPrimitives()->AddLast(obj, opt.Data());
1977 pad->Modified();
1978 break;
1979 }
1980 }
1981 }
1982 } else if (arg == "INTERRUPT"s) {
1983 gROOT->SetInterrupt();
1984 } else {
1985 // unknown message, probably should be processed by other implementation
1986 return kFALSE;
1987 }
1988
1989 return kTRUE;
1990}
1991
1992//////////////////////////////////////////////////////////////////////////////////////////
1993/// Returns true if any pad in the canvas were modified
1994/// Reset modified flags, increment canvas version (if inc_version is true)
1995
1997{
1998 if (fPadsStatus.find(pad) == fPadsStatus.end())
1999 fPadsStatus[pad] = PadStatus{0, true, true};
2000
2001 auto &entry = fPadsStatus[pad];
2002 entry._detected = true;
2003 if (pad->IsModified()) {
2004 pad->Modified(kFALSE);
2005 entry._modified = true;
2006 }
2007
2008 TIter iter(pad->GetListOfPrimitives());
2009 while (auto obj = iter()) {
2010 if (obj->InheritsFrom(TPad::Class()))
2011 CheckPadModified(static_cast<TPad *>(obj));
2012 }
2013}
2014
2015//////////////////////////////////////////////////////////////////////////////////////////
2016/// Check if any pad on the canvas was modified
2017/// If yes, increment version of correspondent pad
2018/// Returns true when canvas really modified
2019
2021{
2022 // clear temporary flags
2023 for (auto &entry : fPadsStatus) {
2024 entry.second._detected = false;
2025 entry.second._modified = force_modified;
2026 }
2027
2028 // scan sub-pads
2030
2031 // remove no-longer existing pads
2032 bool is_any_modified = false;
2033 for(auto iter = fPadsStatus.begin(); iter != fPadsStatus.end(); ) {
2034 if (iter->second._modified)
2035 is_any_modified = true;
2036 if (!iter->second._detected)
2037 fPadsStatus.erase(iter++);
2038 else
2039 iter++;
2040 }
2041
2042 // if any pad modified, increment canvas version and set version of modified pads
2043 if (is_any_modified) {
2044 fCanvVersion++;
2045 for(auto &entry : fPadsStatus)
2046 if (entry.second._modified)
2047 entry.second.fVersion = fCanvVersion;
2048 }
2049
2050 return is_any_modified;
2051}
2052
2053
2054//////////////////////////////////////////////////////////////////////////////////////////
2055/// Returns window geometry including borders and menus
2056
2058{
2059 if (fWindowGeometry.size() == 4) {
2060 x = fWindowGeometry[0];
2061 y = fWindowGeometry[1];
2062 w = fWindowGeometry[2];
2063 h = fWindowGeometry[3];
2064 } else {
2065 x = Canvas()->fWindowTopX;
2066 y = Canvas()->fWindowTopY;
2067 w = Canvas()->fWindowWidth;
2068 h = Canvas()->fWindowHeight;
2069 }
2070 return 0;
2071}
2072
2073
2074//////////////////////////////////////////////////////////////////////////////////////////
2075/// if canvas or any subpad was modified,
2076/// scan all primitives in the TCanvas and subpads and convert them into
2077/// the structure which will be delivered to JSROOT client
2078
2080{
2081 if (CheckCanvasModified()) {
2082 // configure selected pad that method like TPad::WaitPrimitive() can correctly work
2083 // can be removed again once WaitPrimitive implemented differently
2084 if (gPad && (gPad->GetCanvas() == Canvas()))
2085 gROOT->SetSelectedPad(gPad);
2086 }
2087
2089
2090 if (!fProcessingData && !IsAsyncMode() && !async)
2092
2093 return kTRUE;
2094}
2095
2096//////////////////////////////////////////////////////////////////////////////////////////
2097/// Increment canvas version and force sending data to client - do not wait for reply
2098
2100{
2101 CheckCanvasModified(true);
2102
2103 if (!fWindow) {
2104 TCanvasWebSnapshot holder(IsReadOnly(), false, true); // readonly, set ids, batchmode
2105 CreatePadSnapshot(holder, Canvas(), 0, nullptr);
2106 } else {
2108 }
2109}
2110
2111//////////////////////////////////////////////////////////////////////////////////////////
2112/// Wait when specified version of canvas was painted and confirmed by browser
2113
2115{
2116 if (!fWindow)
2117 return kTRUE;
2118
2119 // simple polling loop until specified version delivered to the clients
2120 // first 500 loops done without sleep, then with 1ms sleep and last 500 with 100 ms sleep
2121
2122 long cnt = 0, cnt_limit = GetLongerPolling() ? 5500 : 1500;
2123
2124 if (gDebug > 2)
2125 Info("WaitWhenCanvasPainted", "version %ld", (long)ver);
2126
2127 while (cnt++ < cnt_limit) {
2128
2129 if (!fWindow->HasConnection(0, false)) {
2130 if (gDebug > 2)
2131 Info("WaitWhenCanvasPainted", "no connections - abort");
2132 return kFALSE; // wait ~1 min if no new connection established
2133 }
2134
2135 if ((fWebConn.size() > 1) && (fWebConn[1].fDrawVersion >= ver)) {
2136 if (gDebug > 2)
2137 Info("WaitWhenCanvasPainted", "ver %ld got painted", (long)ver);
2138 return kTRUE;
2139 }
2140
2142 if (cnt > 500)
2143 gSystem->Sleep((cnt < cnt_limit - 500) ? 1 : 100); // increase sleep interval when do very often
2144 }
2145
2146 if (gDebug > 2)
2147 Info("WaitWhenCanvasPainted", "timeout");
2148
2149 return kFALSE;
2150}
2151
2152//////////////////////////////////////////////////////////////////////////////////////////
2153/// Create JSON painting output for given pad
2154/// Produce JSON can be used for offline drawing with JSROOT
2155
2156TString TWebCanvas::CreatePadJSON(TPad *pad, Int_t json_compression, Bool_t batchmode)
2157{
2158 TString res;
2159 if (!pad)
2160 return res;
2161
2162 TCanvas *c = dynamic_cast<TCanvas *>(pad);
2163 if (c) {
2164 res = CreateCanvasJSON(c, json_compression, batchmode);
2165 } else {
2166 auto imp = std::make_unique<TWebCanvas>(pad->GetCanvas(), pad->GetName(), 0, 0, pad->GetWw(), pad->GetWh(), kTRUE);
2167
2168 TPadWebSnapshot holder(true, false, batchmode); // readonly, no ids, batchmode
2169
2170 imp->CreatePadSnapshot(holder, pad, 0, [&res, json_compression](TPadWebSnapshot *snap) {
2171 res = TBufferJSON::ToJSON(snap, json_compression);
2172 });
2173 }
2174
2175 return res;
2176}
2177
2178//////////////////////////////////////////////////////////////////////////////////////////
2179/// Create JSON painting output for given canvas
2180/// Produce JSON can be used for offline drawing with JSROOT
2181
2183{
2184 TString res;
2185
2186 if (!c)
2187 return res;
2188
2189 {
2190 auto imp = std::make_unique<TWebCanvas>(c, c->GetName(), 0, 0, c->GetWw(), c->GetWh(), kTRUE);
2191
2192 TCanvasWebSnapshot holder(true, false, batchmode); // readonly, no ids, batchmode
2193
2194 imp->CreatePadSnapshot(holder, c, 0, [&res, json_compression](TPadWebSnapshot *snap) {
2195 res = TBufferJSON::ToJSON(snap, json_compression);
2196 });
2197 }
2198
2199 return res;
2200}
2201
2202//////////////////////////////////////////////////////////////////////////////////////////
2203/// Create JSON painting output for given canvas and store into the file
2204/// See TBufferJSON::ExportToFile() method for more details about option
2205/// If option string starts with symbol 'b', JSON for batch mode will be generated
2206
2208{
2209 Int_t res = 0;
2210 Bool_t batchmode = kFALSE;
2211 if (option && *option == 'b') {
2212 batchmode = kTRUE;
2213 ++option;
2214 }
2215
2216 if (!c)
2217 return res;
2218
2219 {
2220 auto imp = std::make_unique<TWebCanvas>(c, c->GetName(), 0, 0, c->GetWw(), c->GetWh(), kTRUE);
2221
2222 TCanvasWebSnapshot holder(true, false, batchmode); // readonly, no ids, batchmode
2223
2224 imp->CreatePadSnapshot(holder, c, 0, [&res, filename, option](TPadWebSnapshot *snap) {
2226 });
2227 }
2228
2229 return res;
2230}
2231
2232//////////////////////////////////////////////////////////////////////////////////////////
2233/// Create image using batch (headless) capability of Chrome or Firefox browsers
2234/// Supported png, jpeg, svg, pdf formats
2235
2236bool TWebCanvas::ProduceImage(TPad *pad, const char *fileName, Int_t width, Int_t height)
2237{
2238 if (!pad)
2239 return false;
2240
2242 if (!json.Length())
2243 return false;
2244
2245 if (!width && !height) {
2246 if ((pad->GetCanvas() == pad) || (pad->IsA() == TCanvas::Class())) {
2247 width = pad->GetWw();
2248 height = pad->GetWh();
2249 } else {
2250 width = (Int_t) (pad->GetAbsWNDC() * pad->GetCanvas()->GetWw());
2251 height = (Int_t) (pad->GetAbsHNDC() * pad->GetCanvas()->GetWh());
2252 }
2253 }
2254
2255 return ROOT::RWebDisplayHandle::ProduceImage(fileName, json.Data(), width, height);
2256}
2257
2258//////////////////////////////////////////////////////////////////////////////////////////
2259/// Create images for several pads using batch (headless) capability of Chrome or Firefox browsers
2260/// Supported png, jpeg, svg, pdf, webp formats
2261/// One can include %d qualifier which will be replaced by image index using printf functionality.
2262/// If for pdf format %d qualifier not specified, all images will be stored in single PDF file.
2263/// For all other formats %d qualifier will be add before extension automatically
2264
2265bool TWebCanvas::ProduceImages(std::vector<TPad *> pads, const char *filename, Int_t width, Int_t height)
2266{
2267 if (pads.empty())
2268 return false;
2269
2270 std::vector<std::string> jsons;
2271 std::vector<Int_t> widths, heights;
2272
2273 bool isMultiPdf = (strstr(filename, ".pdf") || strstr(filename, ".PDF")) && strstr(filename, "%");
2274 bool is_multipdf_ok = true;
2275
2276 for (unsigned n = 0; n < pads.size(); ++n) {
2277 auto pad = pads[n];
2278
2280 if (!json.Length())
2281 continue;
2282
2283 Int_t w = width, h = height;
2284
2285 if (!w && !h) {
2286 if ((pad->GetCanvas() == pad) || (pad->IsA() == TCanvas::Class())) {
2287 w = pad->GetWw();
2288 h = pad->GetWh();
2289 } else {
2290 w = (Int_t) (pad->GetAbsWNDC() * pad->GetCanvas()->GetWw());
2291 h = (Int_t) (pad->GetAbsHNDC() * pad->GetCanvas()->GetWh());
2292 }
2293 }
2294
2295 if (isMultiPdf) {
2296 TString pdfname = TString::Format(filename, (int)n);
2297 if (!ROOT::RWebDisplayHandle::ProduceImage(pdfname.Data(), json.Data(), w, h))
2298 is_multipdf_ok = false;
2299 } else {
2300 jsons.emplace_back(json.Data());
2301 widths.emplace_back(w);
2302 heights.emplace_back(h);
2303 }
2304 }
2305
2306 if (isMultiPdf)
2307 return is_multipdf_ok;
2308
2309 return ROOT::RWebDisplayHandle::ProduceImages(filename, jsons, widths, heights);
2310}
2311
2312
2313//////////////////////////////////////////////////////////////////////////////////////////
2314/// Process data for single primitive
2315/// Returns object pad if object was modified
2316
2318{
2319 TObjLink *lnk = nullptr;
2320 TPad *objpad = nullptr;
2321 TObject *obj = FindPrimitive(item.snapid, idcnt, pad, &lnk, &objpad);
2322
2323 if (item.fcust.compare("exec") == 0) {
2324 auto pos = item.opt.find("(");
2325 if (obj && (pos != std::string::npos) && obj->IsA()->GetMethodAllAny(item.opt.substr(0,pos).c_str())) {
2326 std::stringstream exec;
2327 exec << "((" << obj->ClassName() << " *) " << std::hex << std::showbase
2328 << (size_t)obj << ")->" << item.opt << ";";
2329 Info("ProcessObjectOptions", "Obj %s Execute %s", obj->GetName(), exec.str().c_str());
2330 gROOT->ProcessLine(exec.str().c_str());
2331 } else {
2332 Error("ProcessObjectOptions", "Fail to execute %s for object %p %s", item.opt.c_str(), obj, obj ? obj->ClassName() : "---");
2333 objpad = nullptr;
2334 }
2335 return objpad;
2336 }
2337
2338 bool modified = false;
2339
2340 if (obj && lnk) {
2341 auto pos = item.opt.find(";;use_"); // special coding of extra options
2342 if (pos != std::string::npos) item.opt.resize(pos);
2343
2344 if (gDebug > 1)
2345 Info("ProcessObjectOptions", "Set draw option %s for object %s %s", item.opt.c_str(),
2346 obj->ClassName(), obj->GetName());
2347
2348 lnk->SetOption(item.opt.c_str());
2349
2350 modified = true;
2351 }
2352
2353 if (item.fcust.compare(0,10,"auto_exec:") == 0) {
2354 ProcessLinesForObject(obj, item.fcust.substr(10));
2355 } else if (item.fcust.compare("frame") == 0) {
2356 if (obj && obj->InheritsFrom(TFrame::Class())) {
2357 TFrame *frame = static_cast<TFrame *>(obj);
2358 if (item.fopt.size() >= 4) {
2359 frame->SetX1(item.fopt[0]);
2360 frame->SetY1(item.fopt[1]);
2361 frame->SetX2(item.fopt[2]);
2362 frame->SetY2(item.fopt[3]);
2363 modified = true;
2364 }
2365 }
2366 } else if (item.fcust.compare(0,4,"pave") == 0) {
2367 if (obj && obj->InheritsFrom(TPave::Class())) {
2368 TPave *pave = static_cast<TPave *>(obj);
2369 if ((item.fopt.size() >= 4) && objpad) {
2370 TVirtualPad::TContext ctxt(objpad, kFALSE);
2371
2372 // first time need to overcome init problem
2373 pave->ConvertNDCtoPad();
2374
2375 pave->SetX1NDC(item.fopt[0]);
2376 pave->SetY1NDC(item.fopt[1]);
2377 pave->SetX2NDC(item.fopt[2]);
2378 pave->SetY2NDC(item.fopt[3]);
2379 modified = true;
2380
2381 pave->ConvertNDCtoPad();
2382 }
2383 if ((item.fcust.length() > 4) && pave->InheritsFrom(TPaveStats::Class())) {
2384 // add text lines for statsbox
2385 auto stats = static_cast<TPaveStats *>(pave);
2386 stats->Clear();
2387 size_t pos_start = 6, pos_end;
2388 while ((pos_end = item.fcust.find(";;", pos_start)) != std::string::npos) {
2389 stats->AddText(item.fcust.substr(pos_start, pos_end - pos_start).c_str());
2390 pos_start = pos_end + 2;
2391 }
2392 stats->AddText(item.fcust.substr(pos_start).c_str());
2393 }
2394 }
2395 } else if (item.fcust.compare(0,9,"func_fail") == 0) {
2396 if (!fTF1UseSave) {
2398 modified = true;
2399 } else {
2400 Error("ProcessObjectOptions", "Client fails to calculate function %s cl %s but it should not try!", obj ? obj->GetName() : "---", obj ? obj->ClassName() : "---");
2401 }
2402 }
2403
2404 return modified ? objpad : nullptr;
2405}
2406
2407//////////////////////////////////////////////////////////////////////////////////////////////////
2408/// Search of object with given id in list of primitives
2409/// One could specify pad where search could be start
2410/// Also if object is in list of primitives, one could ask for entry link for such object,
2411/// This can allow to change draw option
2412
2413TObject *TWebCanvas::FindPrimitive(const std::string &sid, int idcnt, TPad *pad, TObjLink **objlnk, TPad **objpad)
2414{
2415 if (sid.empty() || (sid == "0"s))
2416 return nullptr;
2417
2418 if (!pad)
2419 pad = Canvas();
2420
2421 std::string subelement;
2422 long unsigned id = 0;
2423 bool search_hist = (sid == sid_pad_histogram);
2424 if (!search_hist) {
2425 auto separ = sid.find("#");
2426
2427 if (separ == std::string::npos) {
2428 id = std::stoul(sid);
2429 } else {
2430 subelement = sid.substr(separ + 1);
2431 id = std::stoul(sid.substr(0, separ));
2432 }
2433 if (TString::Hash(&pad, sizeof(pad)) == id)
2434 return pad;
2435 }
2436
2437 for (auto lnk = pad->GetListOfPrimitives()->FirstLink(); lnk != nullptr; lnk = lnk->Next()) {
2438 TObject *obj = lnk->GetObject();
2439 if (!obj) continue;
2440
2441 if (!search_hist && (TString::Hash(&obj, sizeof(obj)) != id)) {
2442 if (obj->InheritsFrom(TPad::Class())) {
2443 obj = FindPrimitive(sid, idcnt, (TPad *)obj, objlnk, objpad);
2444 if (objpad && !*objpad)
2445 *objpad = pad;
2446 if (obj)
2447 return obj;
2448 }
2449 continue;
2450 }
2451
2452 // one may require to access n-th object
2453 if (!search_hist && --idcnt > 0)
2454 continue;
2455
2456 if (objpad)
2457 *objpad = pad;
2458
2459 if (objlnk)
2460 *objlnk = lnk;
2461
2462 if (search_hist)
2463 subelement = "hist";
2464
2465 auto getHistogram = [](TObject *container) -> TH1* {
2466 auto offset = container->IsA()->GetDataMemberOffset("fHistogram");
2467 if (offset > 0)
2468 return *((TH1 **)((char *)container + offset));
2469 ::Error("getHistogram", "Cannot access fHistogram data member in %s", container->ClassName());
2470 return nullptr;
2471 };
2472
2473 while(!subelement.empty() && obj) {
2474 // do not return link if sub-selement is searched - except for histogram
2475 if (!search_hist && objlnk)
2476 *objlnk = nullptr;
2477
2478 std::string kind = subelement;
2479 auto separ = kind.find("#");
2480 if (separ == std::string::npos) {
2481 subelement.clear();
2482 } else {
2483 kind.resize(separ);
2484 subelement = subelement.substr(separ + 1);
2485 }
2486
2487 TH1 *h1 = obj->InheritsFrom(TH1::Class()) ? static_cast<TH1 *>(obj) : nullptr;
2488 TGraph *gr = obj->InheritsFrom(TGraph::Class()) ? static_cast<TGraph *>(obj) : nullptr;
2489 TGraph2D *gr2d = obj->InheritsFrom(TGraph2D::Class()) ? static_cast<TGraph2D *>(obj) : nullptr;
2490 TScatter *scatter = obj->InheritsFrom(TScatter::Class()) ? static_cast<TScatter *>(obj) : nullptr;
2491 TMultiGraph *mg = obj->InheritsFrom(TMultiGraph::Class()) ? static_cast<TMultiGraph *>(obj) : nullptr;
2492 THStack *hs = obj->InheritsFrom(THStack::Class()) ? static_cast<THStack *>(obj) : nullptr;
2493 TF1 *f1 = obj->InheritsFrom(TF1::Class()) ? static_cast<TF1 *>(obj) : nullptr;
2494
2495 if (kind.compare("hist") == 0) {
2496 if (h1)
2497 obj = h1;
2498 else if (gr)
2499 obj = getHistogram(gr);
2500 else if (mg)
2501 obj = getHistogram(mg);
2502 else if (hs)
2503 obj = getHistogram(hs);
2504 else if (scatter)
2505 obj = getHistogram(scatter);
2506 else if (f1)
2507 obj = getHistogram(f1);
2508 else if (gr2d)
2509 obj = getHistogram(gr2d);
2510 else
2511 obj = nullptr;
2512 } else if (kind.compare("x") == 0) {
2513 obj = h1 ? h1->GetXaxis() : nullptr;
2514 } else if (kind.compare("y") == 0) {
2515 obj = h1 ? h1->GetYaxis() : nullptr;
2516 } else if (kind.compare("z") == 0) {
2517 obj = h1 ? h1->GetZaxis() : nullptr;
2518 } else if ((kind.compare(0,5,"func_") == 0) || (kind.compare(0,5,"indx_") == 0)) {
2519 auto funcname = kind.substr(5);
2520 TList *col = nullptr;
2521 if (h1)
2522 col = h1->GetListOfFunctions();
2523 else if (gr)
2524 col = gr->GetListOfFunctions();
2525 else if (mg)
2526 col = mg->GetListOfFunctions();
2527 else if (scatter->GetGraph())
2528 col = scatter->GetGraph()->GetListOfFunctions();
2529 if (!col)
2530 obj = nullptr;
2531 else if (kind.compare(0,5,"func_") == 0)
2532 obj = col->FindObject(funcname.c_str());
2533 else
2534 obj = col->At(std::stoi(funcname));
2535 } else if (kind.compare(0,7,"graphs_") == 0) {
2536 TList *graphs = mg ? mg->GetListOfGraphs() : nullptr;
2537 obj = graphs ? graphs->At(std::stoi(kind.substr(7))) : nullptr;
2538 } else if (kind.compare(0,6,"hists_") == 0) {
2539 TList *hists = hs ? hs->GetHists() : nullptr;
2540 obj = hists ? hists->At(std::stoi(kind.substr(6))) : nullptr;
2541 } else if (kind.compare(0,6,"stack_") == 0) {
2542 auto stack = hs ? hs->GetStack() : nullptr;
2543 obj = stack ? stack->At(std::stoi(kind.substr(6))) : nullptr;
2544 } else if (kind.compare(0,7,"member_") == 0) {
2545 auto member = kind.substr(7);
2546 auto offset = obj->IsA() ? obj->IsA()->GetDataMemberOffset(member.c_str()) : 0;
2547 obj = (offset > 0) ? *((TObject **)((char *) obj + offset)) : nullptr;
2548 } else {
2549 obj = nullptr;
2550 }
2551 }
2552
2553 if (!search_hist || obj)
2554 return obj;
2555 }
2556
2557 return nullptr;
2558}
2559
2560//////////////////////////////////////////////////////////////////////////////////////////////////
2561/// Static method to create TWebCanvas instance
2562/// Used by plugin manager
2563
2565{
2566 Bool_t readonly = gEnv->GetValue("WebGui.FullCanvas", (Int_t) 1) == 0;
2567
2568 auto imp = new TWebCanvas(c, name, x, y, width, height, readonly);
2569
2570 c->fWindowTopX = x;
2571 c->fWindowTopY = y;
2572 c->fWindowWidth = width;
2573 c->fWindowHeight = height;
2574 if (!gROOT->IsBatch() && (height > 25))
2575 height -= 25;
2576 c->fCw = width;
2577 c->fCh = height;
2578
2579 return imp;
2580}
@ kMouseMotion
Definition Buttons.h:23
@ kButton1Double
Definition Buttons.h:24
@ kButton1Up
Definition Buttons.h:19
nlohmann::json json
#define c(i)
Definition RSha256.hxx:101
#define h(i)
Definition RSha256.hxx:106
int Int_t
Definition RtypesCore.h:45
short Font_t
Definition RtypesCore.h:88
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
constexpr Ssiz_t kNPOS
Definition RtypesCore.h:124
long long Long64_t
Definition RtypesCore.h:80
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
R__EXTERN TEnv * gEnv
Definition TEnv.h:170
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
Definition TError.cxx:218
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:185
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t hmin
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t hmax
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void funcs
Option_t Option_t width
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t src
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t height
char name[80]
Definition TGX11.cxx:110
@ kCanDelete
Definition TObject.h:367
@ kMustCleanup
Definition TObject.h:368
Int_t gDebug
Definition TROOT.cxx:597
#define gROOT
Definition TROOT.h:407
R__EXTERN TStyle * gStyle
Definition TStyle.h:433
@ kReadPermission
Definition TSystem.h:45
R__EXTERN TSystem * gSystem
Definition TSystem.h:555
R__EXTERN TVirtualPS * gVirtualPS
Definition TVirtualPS.h:81
#define gPad
#define gVirtualX
Definition TVirtualX.h:337
static std::vector< WebFont_t > gWebFonts
static const std::string sid_pad_histogram
Color * colors
Definition X3DBuffer.c:21
Holds different arguments for starting browser with RWebDisplayHandle::Display() method.
EBrowserKind GetBrowserKind() const
returns configured browser kind, see EBrowserKind for supported values
RWebDisplayArgs & SetWidgetKind(const std::string &kind)
set widget kind
RWebDisplayArgs & SetSize(int w, int h)
set preferable web window width and height
RWebDisplayArgs & SetPos(int x=-1, int y=-1)
set preferable web window x and y position, negative is default
@ kCEF
Chromium Embedded Framework - local display with CEF libs.
@ kQt5
Qt5 QWebEngine libraries - Chromium code packed in qt5.
@ kQt6
Qt6 QWebEngine libraries - Chromium code packed in qt6.
static bool ProduceImages(const std::string &fname, const std::vector< std::string > &jsons, const std::vector< int > &widths, const std::vector< int > &heights, const char *batch_file=nullptr)
Produce image file(s) using JSON data as source Invokes JSROOT drawing functionality in headless brow...
static bool ProduceImage(const std::string &fname, const std::string &json, int width=800, int height=600, const char *batch_file=nullptr)
Produce image file using JSON data as source Invokes JSROOT drawing functionality in headless browser...
static std::shared_ptr< RWebWindow > Create()
Create new RWebWindow Using default RWebWindowsManager.
static bool EmbedFileDialog(const std::shared_ptr< RWebWindow > &window, unsigned connid, const std::string &args)
Create dialog instance to use as embedded dialog inside provided widget Loads libROOTBrowserv7 and tr...
static bool IsFileDialogMessage(const std::string &msg)
Check if this could be the message send by client to start new file dialog If returns true,...
Array of integers (32 bits per element).
Definition TArrayI.h:27
const Int_t * GetArray() const
Definition TArrayI.h:43
Int_t GetSize() const
Definition TArray.h:47
static TClass * Class()
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:37
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition TAttFill.h:39
virtual void SetBottomMargin(Float_t bottommargin)
Set Pad bottom margin in fraction of the pad height.
Definition TAttPad.cxx:99
virtual void SetLeftMargin(Float_t leftmargin)
Set Pad left margin in fraction of the pad width.
Definition TAttPad.cxx:109
virtual void SetRightMargin(Float_t rightmargin)
Set Pad right margin in fraction of the pad width.
Definition TAttPad.cxx:119
Float_t GetRightMargin() const
Definition TAttPad.h:45
virtual void SetTopMargin(Float_t topmargin)
Set Pad top margin in fraction of the pad height.
Definition TAttPad.cxx:129
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition TAttText.h:42
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition TAttText.h:44
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition TAttText.h:46
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition TAttText.h:47
Double_t GetXmax() const
Definition TAxis.h:140
Double_t GetXmin() const
Definition TAxis.h:139
Int_t GetNbins() const
Definition TAxis.h:125
virtual void SetRangeUser(Double_t ufirst, Double_t ulast)
Set the viewing range for the axis from ufirst to ulast (in user coordinates, that is,...
Definition TAxis.cxx:1080
virtual void SetRange(Int_t first=0, Int_t last=0)
Set the viewing range for the axis using bin numbers.
Definition TAxis.cxx:1052
static TString Decode(const char *data)
Decode a base64 string date into a generic TString.
Definition TBase64.cxx:131
static TString Encode(const char *data)
Transform data into a null terminated base64 string.
Definition TBase64.cxx:107
virtual void SetY2(Double_t y2)
Definition TBox.h:65
virtual void SetX1(Double_t x1)
Definition TBox.h:62
virtual void SetX2(Double_t x2)
Definition TBox.h:63
virtual void SetY1(Double_t y1)
Definition TBox.h:64
static Int_t ExportToFile(const char *filename, const TObject *obj, const char *option=nullptr)
Convert object into JSON and store in text file Returns size of the produce file Used in TObject::Sav...
static TString ToJSON(const T *obj, Int_t compact=0, const char *member_name=nullptr)
Definition TBufferJSON.h:75
@ kNoSpaces
no new lines plus remove all spaces around "," and ":" symbols
Definition TBufferJSON.h:39
@ kMapAsObject
store std::map, std::unordered_map as JSON object
Definition TBufferJSON.h:41
@ kSameSuppression
zero suppression plus compress many similar values together
Definition TBufferJSON.h:45
A TButton object is a user interface object.
Definition TButton.h:18
static TClass * Class()
ABC describing GUI independent main window (with menubar, scrollbars and a drawing area).
Definition TCanvasImp.h:30
TCanvas * Canvas() const
Definition TCanvasImp.h:58
void SetScripts(const std::string &src)
void SetFixedSize(bool on=true)
void SetHighlightConnect(bool on=true)
The Canvas class.
Definition TCanvas.h:23
UInt_t fCw
Width of the canvas along X (pixels)
Definition TCanvas.h:43
UInt_t GetWindowHeight() const
Definition TCanvas.h:162
void SetClickSelectedPad(TPad *pad)
Definition TCanvas.h:211
Int_t fWindowTopX
Top X position of window (in pixels)
Definition TCanvas.h:39
Int_t fEventX
! Last X mouse position in canvas
Definition TCanvas.h:46
TVirtualPadPainter * GetCanvasPainter()
Access and (probably) creation of pad painter.
Definition TCanvas.cxx:2603
UInt_t fWindowWidth
Width of window (including borders, etc.)
Definition TCanvas.h:41
Int_t fEventY
! Last Y mouse position in canvas
Definition TCanvas.h:47
UInt_t fWindowHeight
Height of window (including menubar, borders, etc.)
Definition TCanvas.h:42
TObject * fSelected
! Currently selected object
Definition TCanvas.h:49
UInt_t fCh
Height of the canvas along Y (pixels)
Definition TCanvas.h:44
UInt_t GetWindowWidth() const
Definition TCanvas.h:161
Int_t fWindowTopY
Top Y position of window (in pixels)
Definition TCanvas.h:40
void SetClickSelected(TObject *obj)
Definition TCanvas.h:209
@ kShowToolTips
Definition TCanvas.h:97
@ kShowEventStatus
Definition TCanvas.h:89
@ kMenuBar
Definition TCanvas.h:91
@ kShowEditor
Definition TCanvas.h:93
UInt_t GetWw() const override
Definition TCanvas.h:163
UInt_t GetWh() const override
Definition TCanvas.h:164
virtual void Highlighted(TVirtualPad *pad, TObject *obj, Int_t x, Int_t y)
Emit Highlighted() signal.
Definition TCanvas.cxx:1610
static TClass * Class()
Int_t fEvent
! Type of current or last handled event
Definition TCanvas.h:45
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
Longptr_t GetDataMemberOffset(const char *membername) const
return offset for member name.
Definition TClass.cxx:3477
Int_t Size() const
Return size of object of this class.
Definition TClass.cxx:5704
Bool_t InheritsFrom(const char *cl) const override
Return kTRUE if this class inherits from a class with name "classname".
Definition TClass.cxx:4874
TMethod * GetMethodAllAny(const char *method)
Return pointer to method without looking at parameters.
Definition TClass.cxx:4384
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
The color creation and management class.
Definition TColor.h:21
static const TArrayI & GetPalette()
Static function returning the current active palette.
Definition TColor.cxx:1467
static TClass * Class()
static Bool_t DefinedColors(Int_t set_always_on=0)
Static method returning kTRUE if some new colors have been defined after initialisation or since the ...
Definition TColor.cxx:1488
static TClass * Class()
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:491
TExec is a utility class that can be used to execute a C++ command when some event happens in a pad.
Definition TExec.h:26
virtual void Exec(const char *command="")
Execute the command referenced by this object.
Definition TExec.cxx:143
static TClass * Class()
1-Dim function class
Definition TF1.h:233
virtual TH1 * GetHistogram() const
Return a pointer to the histogram used to visualise the function Note that this histogram is managed ...
Definition TF1.cxx:1586
static TClass * Class()
@ kNotDraw
Definition TF1.h:346
virtual void Save(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Double_t zmin, Double_t zmax)
Save values of function in array fSave.
Definition TF1.cxx:3161
TClass * IsA() const override
Definition TF1.h:748
static TClass * Class()
Define a Frame.
Definition TFrame.h:19
static TClass * Class()
The axis painter class.
Definition TGaxis.h:24
static TClass * Class()
TF1 * GetFunction() const
Definition TGaxis.h:77
Graphics object made of three arrays X, Y and Z with the same number of points each.
Definition TGraph2D.h:41
static TClass * Class()
TH2D * GetHistogram(Option_t *option="")
By default returns a pointer to the Delaunay histogram.
Definition TGraph2D.cxx:979
TList * GetListOfFunctions() const
Definition TGraph2D.h:110
A TGraph is an object made of two arrays X and Y with npoints each.
Definition TGraph.h:41
static TClass * Class()
@ kNoStats
Don't draw stats box.
Definition TGraph.h:75
TList * GetListOfFunctions() const
Definition TGraph.h:125
virtual TH1F * GetHistogram() const
Returns a pointer to the histogram used to draw the axis Takes into account the two following cases.
Definition TGraph.cxx:1406
1-D histogram with a double per channel (see TH1 documentation)
Definition TH1.h:669
TH1K class supports the nearest K Neighbours method, widely used in cluster analysis.
Definition TH1K.h:26
Double_t GetBinContent(Int_t bin) const override
Return content of global bin number bin.
Definition TH1K.cxx:116
static TClass * Class()
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:59
virtual void SetDirectory(TDirectory *dir)
By default, when a histogram is created, it is added to the list of histogram objects in the current ...
Definition TH1.cxx:8905
TAxis * GetZaxis()
Definition TH1.h:326
static TClass * Class()
virtual Int_t GetDimension() const
Definition TH1.h:283
@ kNoTitle
Don't draw the histogram title.
Definition TH1.h:170
TAxis * GetXaxis()
Definition TH1.h:324
virtual void SetMaximum(Double_t maximum=-1111)
Definition TH1.h:403
TAxis * GetYaxis()
Definition TH1.h:325
virtual void SetMinimum(Double_t minimum=-1111)
Definition TH1.h:404
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition TH1.cxx:9190
virtual Double_t GetEntries() const
Return the current number of entries.
Definition TH1.cxx:4423
TList * GetListOfFunctions() const
Definition TH1.h:244
void SetName(const char *name) override
Change the name of this histogram.
Definition TH1.cxx:8928
virtual Int_t BufferEmpty(Int_t action=0)
Fill histogram with all entries in the buffer.
Definition TH1.cxx:1414
The Histogram stack class.
Definition THStack.h:40
TList * GetHists() const
Definition THStack.h:72
TObjArray * GetStack()
Return pointer to Stack. Build it if not yet done.
Definition THStack.cxx:597
static TClass * Class()
Option_t * GetOption() const
void Reset()
A doubly linked list.
Definition TList.h:38
TObject * FindObject(const char *name) const override
Find an object in this list using its name.
Definition TList.cxx:576
void Add(TObject *obj) override
Definition TList.h:83
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition TList.cxx:820
void AddLast(TObject *obj) override
Add object at the end of the list.
Definition TList.cxx:150
TObject * Last() const override
Return the last object in the list. Returns 0 when list is empty.
Definition TList.cxx:691
virtual TObjLink * FirstLink() const
Definition TList.h:104
TObject * At(Int_t idx) const override
Returns the object at position idx. Returns 0 if idx is out of range.
Definition TList.cxx:355
void AddFirst(TObject *obj) override
Add object at the beginning of the list.
Definition TList.cxx:98
A TMultiGraph is a collection of TGraph (or derived) objects.
Definition TMultiGraph.h:34
TList * GetListOfGraphs() const
Definition TMultiGraph.h:68
static TClass * Class()
TList * GetListOfFunctions()
Return pointer to list of functions.
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48
An array of TObjects.
Definition TObjArray.h:31
Mother of all ROOT objects.
Definition TObject.h:41
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:439
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:199
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition TObject.cxx:223
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:207
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:403
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:525
virtual const char * GetTitle() const
Returns title of object.
Definition TObject.cxx:483
virtual TClass * IsA() const
Definition TObject.h:243
virtual void Paint(Option_t *option="")
This method must be overridden if a class wants to paint itself.
Definition TObject.cxx:607
TPadWebSnapshot & NewSubPad()
Create new entry for subpad.
TWebSnapshot & NewPrimitive(TObject *obj=nullptr, const std::string &opt="", const std::string &suffix="")
Create new entry in list of primitives.
TWebSnapshot & NewSpecials()
Create new entry in list of primitives in the front.
void SetHasExecs(bool on=true)
void SetWithoutPrimitives(bool on=true)
void SetActive(bool on=true)
bool IsSetObjectIds() const
bool IsBatchMode() const
The most important graphics class in the ROOT system.
Definition TPad.h:28
Int_t GetTicky() const override
Definition TPad.h:237
Double_t fAbsYlowNDC
Absolute Y top left corner of pad in NDC [0,1].
Definition TPad.h:70
Double_t fXtoAbsPixelk
Conversion coefficient for X World to absolute pixel.
Definition TPad.h:41
virtual void DivideSquare(Int_t n, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0)
"n" is the total number of sub-pads.
Definition TPad.cxx:1288
static TClass * Class()
Double_t fWNDC
Width of pad along X in Normalized Coordinates (NDC)
Definition TPad.h:66
void SetView(TView *view=nullptr) override
Set the current TView. Delete previous view if view=0.
Definition TPad.cxx:6125
TVirtualViewer3D * GetViewer3D(Option_t *type="") override
Create/obtain handle to 3D viewer.
Definition TPad.cxx:7080
Double_t fPixeltoYk
Conversion coefficient for pixel to Y World.
Definition TPad.h:59
void SetGrid(Int_t valuex=1, Int_t valuey=1) override
Definition TPad.h:332
Double_t fPixeltoY
yworld = fPixeltoYk + fPixeltoY*ypixel
Definition TPad.h:60
Double_t fAbsXlowNDC
Absolute X top left corner of pad in NDC [0,1].
Definition TPad.h:69
TList * GetListOfExecs() const override
Definition TPad.h:244
void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0) override
Automatic pad generation by division.
Definition TPad.cxx:1196
Double_t fXtoPixel
xpixel = fXtoPixelk + fXtoPixel*xworld
Definition TPad.h:43
Bool_t GetGridx() const override
Definition TPad.h:233
Double_t fX2
X of upper X coordinate.
Definition TPad.h:38
Double_t fPixeltoX
xworld = fPixeltoXk + fPixeltoX*xpixel
Definition TPad.h:57
Double_t fYtoPixel
ypixel = fYtoPixelk + fYtoPixel*yworld
Definition TPad.h:46
Double_t fAbsWNDC
Absolute Width of pad along X in NDC.
Definition TPad.h:71
UInt_t GetWw() const override
Get Ww.
Definition TPad.cxx:2784
Double_t fX1
X of lower X coordinate.
Definition TPad.h:36
TList * GetListOfPrimitives() const override
Definition TPad.h:243
Double_t fUymin
Minimum value on the Y axis.
Definition TPad.h:75
Int_t fLogz
(=0 if Z linear scale, =1 if log scale)
Definition TPad.h:93
Double_t fYtoPixelk
Conversion coefficient for Y World to pixel.
Definition TPad.h:45
Double_t fPixeltoXk
Conversion coefficient for pixel to X World.
Definition TPad.h:56
Bool_t IsModified() const override
Definition TPad.h:272
Double_t fY1
Y of lower Y coordinate.
Definition TPad.h:37
Double_t fYlowNDC
Y bottom left corner of pad in NDC [0,1].
Definition TPad.h:63
Double_t fAbsPixeltoXk
Conversion coefficient for absolute pixel to X World.
Definition TPad.h:55
void Clear(Option_t *option="") override
Delete all pad primitives.
Definition TPad.cxx:669
Int_t GetTickx() const override
Definition TPad.h:236
Double_t fUymax
Maximum value on the Y axis.
Definition TPad.h:77
TVirtualPad * GetMother() const override
Definition TPad.h:257
void Modified(Bool_t flag=true) override
Mark pad modified Will be repainted when TCanvas::Update() will be called next time.
Definition TPad.cxx:7298
TView * GetView() const override
Definition TPad.h:252
TClass * IsA() const override
Definition TPad.h:416
Bool_t GetGridy() const override
Definition TPad.h:234
Double_t fAbsHNDC
Absolute Height of pad along Y in NDC.
Definition TPad.h:72
void SetFixedAspectRatio(Bool_t fixed=kTRUE) override
Fix pad aspect ratio to current value if fixed is true.
Definition TPad.cxx:5961
Int_t fLogx
(=0 if X linear scale, =1 if log scale)
Definition TPad.h:91
Double_t GetAbsWNDC() const override
Definition TPad.h:220
UInt_t GetWh() const override
Get Wh.
Definition TPad.cxx:2776
TCanvas * GetCanvas() const override
Definition TPad.h:260
Double_t fXUpNDC
Definition TPad.h:64
TVirtualPad * cd(Int_t subpadnumber=0) override
Set Current pad.
Definition TPad.cxx:640
void Print(const char *filename="") const override
This method is equivalent to SaveAs("filename"). See TPad::SaveAs for details.
Definition TPad.cxx:4743
TFrame * GetFrame() override
Get frame.
Definition TPad.cxx:2902
Double_t fYUpNDC
Definition TPad.h:65
Double_t fYtoAbsPixelk
Conversion coefficient for Y World to absolute pixel.
Definition TPad.h:44
Double_t fXtoPixelk
Conversion coefficient for X World to pixel.
Definition TPad.h:42
Int_t fLogy
(=0 if Y linear scale, =1 if log scale)
Definition TPad.h:92
Double_t fHNDC
Height of pad along Y in Normalized Coordinates (NDC)
Definition TPad.h:67
Double_t fXlowNDC
X bottom left corner of pad in NDC [0,1].
Definition TPad.h:62
Double_t fUxmin
Minimum value on the X axis.
Definition TPad.h:74
Double_t GetAbsHNDC() const override
Definition TPad.h:221
void SetTicks(Int_t valuex=1, Int_t valuey=1) override
Definition TPad.h:352
Double_t fUxmax
Maximum value on the X axis.
Definition TPad.h:76
Double_t fY2
Y of upper Y coordinate.
Definition TPad.h:39
Double_t fAbsPixeltoYk
Conversion coefficient for absolute pixel to Y World.
Definition TPad.h:58
const char * GetName() const override
Returns name of object.
Definition TPad.h:258
The histogram statistics painter class.
Definition TPaveStats.h:18
virtual void SetStatFormat(const char *format="6.4g")
Change (i.e. set) the format for printing statistics.
virtual void SetFitFormat(const char *format="5.4g")
Change (i.e. set) the format for printing fit parameters in statistics box.
void SetParent(TObject *obj) override
Definition TPaveStats.h:52
static TClass * Class()
A Pave (see TPave) with text, lines or/and boxes inside.
Definition TPaveText.h:21
virtual TText * AddText(Double_t x1, Double_t y1, const char *label)
Add a new Text line to this pavetext at given coordinates.
static TClass * Class()
void Clear(Option_t *option="") override
Clear all lines in this pavetext.
virtual TText * GetLine(Int_t number) const
Get Pointer to line number in this pavetext.
A TBox with a bordersize and a shadow option.
Definition TPave.h:19
virtual void SetY1NDC(Double_t y1)
Definition TPave.h:84
virtual void ConvertNDCtoPad()
Convert pave coordinates from NDC to Pad coordinates.
Definition TPave.cxx:139
virtual void SetName(const char *name="")
Definition TPave.h:79
virtual void SetBorderSize(Int_t bordersize=4)
Sets the border size of the TPave box and shadow.
Definition TPave.h:77
virtual void SetY2NDC(Double_t y2)
Definition TPave.h:85
static TClass * Class()
virtual void SetX1NDC(Double_t x1)
Definition TPave.h:82
virtual void SetX2NDC(Double_t x2)
Definition TPave.h:83
A TScatter is able to draw four variables scatter plot on a single plot.
Definition TScatter.h:32
TGraph * GetGraph() const
Get the graph holding X and Y positions.
Definition TScatter.h:58
TH2F * GetHistogram() const
Get the graph histogram used for drawing axis.
Definition TScatter.cxx:159
static TClass * Class()
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
const char * Data() const
Definition TString.h:376
@ kIgnoreCase
Definition TString.h:277
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition TString.cxx:931
void ToUpper()
Change string to upper case.
Definition TString.cxx:1195
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.
Definition TString.cxx:677
TString & Append(const char *cs)
Definition TString.h:572
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2378
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:632
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:651
Int_t GetOptStat() const
Definition TStyle.h:243
Color_t GetStatTextColor() const
Definition TStyle.h:256
Int_t GetOptTitle() const
Definition TStyle.h:244
Float_t GetStatFontSize() const
Definition TStyle.h:259
Float_t GetStatX() const
Definition TStyle.h:262
Float_t GetPadRightMargin() const
Definition TStyle.h:212
Style_t GetTitleFont(Option_t *axis="X") const
Return title font.
Definition TStyle.cxx:1212
Float_t GetStatY() const
Definition TStyle.h:263
Color_t GetTitleFillColor() const
Definition TStyle.h:269
Style_t GetTitleStyle() const
Definition TStyle.h:271
Color_t GetStatColor() const
Definition TStyle.h:255
Float_t GetStatH() const
Definition TStyle.h:265
static TClass * Class()
Width_t GetTitleBorderSize() const
Definition TStyle.h:273
Width_t GetStatBorderSize() const
Definition TStyle.h:257
Color_t GetTitleTextColor() const
Definition TStyle.h:270
Style_t GetStatStyle() const
Definition TStyle.h:260
Float_t GetStatW() const
Definition TStyle.h:264
const char * GetFitFormat() const
Definition TStyle.h:198
const char * GetStatFormat() const
Definition TStyle.h:261
Style_t GetStatFont() const
Definition TStyle.h:258
Float_t GetTitleFontSize() const
Definition TStyle.h:272
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition TSystem.cxx:1274
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition TSystem.cxx:1296
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition TSystem.cxx:437
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition TSystem.cxx:416
Handles synchronous and a-synchronous timer events.
Definition TTimer.h:51
virtual void TurnOn()
Add the timer to the system timer list.
Definition TTimer.cxx:243
void SetTime(Long_t milliSec)
Definition TTimer.h:91
See TView3D.
Definition TView.h:25
static TView * CreateView(Int_t system=1, const Double_t *rmin=nullptr, const Double_t *rmax=nullptr)
Create a concrete default 3-d view via the plug-in manager.
Definition TView.cxx:27
virtual void SetAutoRange(Bool_t autorange=kTRUE)=0
TVirtualPS is an abstract interface to Postscript, PDF, SVG.
Definition TVirtualPS.h:30
To make it possible to use GL for 2D graphic in a TPad/TCanvas.
small helper class to store/restore gPad context in TPad methods
Definition TVirtualPad.h:61
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
Semi-Abstract base class defining a generic interface to the underlying, low level,...
Definition TVirtualX.h:46
void SetSlow(Bool_t slow=kTRUE)
TWebCanvasTimer(TWebCanvas &canv)
Bool_t IsSlow() const
void Timeout() override
used to send control messages to clients
TWebCanvas & fCanv
Basic TCanvasImp ABI implementation for Web-based Graphics Provides painting of main ROOT classes in ...
Definition TWebCanvas.h:35
TVirtualPadPainter * CreatePadPainter() override
Creates web-based pad painter.
void ForceUpdate() override
Increment canvas version and force sending data to client - do not wait for reply.
void AddCustomClass(const std::string &clname, bool with_derived=false)
Assign custom class.
static TString CreatePadJSON(TPad *pad, Int_t json_compression=0, Bool_t batchmode=kFALSE)
Create JSON painting output for given pad Produce JSON can be used for offline drawing with JSROOT.
Bool_t fTF1UseSave
! use save buffer for TF1/TF2, need when evaluation failed on client side
Definition TWebCanvas.h:108
void SetCanvasSize(UInt_t w, UInt_t h) override
Set canvas size of web canvas.
UInt_t fColorsHash
! last hash of colors/palette
Definition TWebCanvas.h:107
void ShowCmd(const std::string &arg, Bool_t show)
Function used to send command to browser to toggle menu, toolbar, editors, ...
Long64_t fColorsVersion
! current colors/palette version, checked every time when new snapshot created
Definition TWebCanvas.h:106
std::string fCustomScripts
! custom JavaScript code or URL on JavaScript files to load before start drawing
Definition TWebCanvas.h:98
virtual Bool_t IsReadOnly() const
Definition TWebCanvas.h:177
std::shared_ptr< ROOT::RWebWindow > fWindow
Definition TWebCanvas.h:88
virtual Bool_t IsJSSupportedClass(TObject *obj, Bool_t many_primitives=kFALSE)
Returns kTRUE when object is fully supported on JSROOT side In ROOT7 Paint function will just return ...
void AddCtrlMsg(unsigned connid, const std::string &key, const std::string &value)
Add control message for specified connection Same control message can be overwritten many time before...
void SetCustomScripts(const std::string &src)
Configures custom script for canvas.
ObjectSelectSignal_t fObjSelectSignal
! signal emitted when new object selected in the pad
Definition TWebCanvas.h:116
PadClickedSignal_t fPadClickedSignal
! signal emitted when simple mouse click performed on the pad
Definition TWebCanvas.h:114
void SetLongerPolling(Bool_t on)
Definition TWebCanvas.h:233
UInt_t fStyleHash
! last hash of gStyle
Definition TWebCanvas.h:105
virtual Bool_t CanCreateObject(const std::string &)
Definition TWebCanvas.h:159
void ShowWebWindow(const ROOT::RWebDisplayArgs &user_args="")
Show canvas in specified place.
Int_t fPrimitivesMerge
! number of PS primitives, which will be merged together
Definition TWebCanvas.h:96
void Show() override
Show canvas in browser window.
Bool_t WaitWhenCanvasPainted(Long64_t ver)
Wait when specified version of canvas was painted and confirmed by browser.
std::vector< std::string > fCustomClasses
! list of custom classes, which can be delivered as is to client
Definition TWebCanvas.h:99
Bool_t IsAsyncMode() const
Definition TWebCanvas.h:242
UInt_t CalculateColorsHash()
Calculate hash function for all colors and palette.
Bool_t HasStatusBar() const override
Returns kTRUE if web canvas has status bar.
void Close() override
Close web canvas - not implemented.
static bool ProduceImages(std::vector< TPad * > pads, const char *filename, Int_t width=0, Int_t height=0)
Create images for several pads using batch (headless) capability of Chrome or Firefox browsers Suppor...
Bool_t HasMenuBar() const override
Returns kTRUE if web canvas has menu bar.
Int_t InitWindow() override
Initialize window for the web canvas At this place canvas is not yet register to the list of canvases...
void CheckPadModified(TPad *pad)
Returns true if any pad in the canvas were modified Reset modified flags, increment canvas version (i...
void RaiseWindow() override
Raise browser window.
static bool ProduceImage(TPad *pad, const char *filename, Int_t width=0, Int_t height=0)
Create image using batch (headless) capability of Chrome or Firefox browsers Supported png,...
void ActivateInEditor(TPad *pad, TObject *obj)
Activate object in editor in web browser.
std::vector< WebConn > fWebConn
! connections
Definition TWebCanvas.h:83
PadSignal_t fActivePadChangedSignal
! signal emitted when active pad changed in the canvas
Definition TWebCanvas.h:113
Bool_t GetLongerPolling() const
Definition TWebCanvas.h:234
UInt_t fClientBits
! latest status bits from client like editor visible or not
Definition TWebCanvas.h:92
std::function< void(TPadWebSnapshot *)> PadPaintingReady_t
Function called when pad painting produced.
Definition TWebCanvas.h:55
Int_t fPaletteDelivery
! colors palette delivery 0:never, 1:once, 2:always, 3:per subpad
Definition TWebCanvas.h:95
Bool_t fProcessingData
! flag used to prevent blocking methods when process data is invoked
Definition TWebCanvas.h:102
Bool_t HasToolTips() const override
Returns kTRUE if tooltips are activated in web canvas.
std::vector< TPad * > fAllPads
! list of all pads recognized during streaming
Definition TWebCanvas.h:93
friend class TWebCanvasTimer
Definition TWebCanvas.h:37
TWebCanvasTimer * fTimer
! timer to submit control messages
Definition TWebCanvas.h:84
Long64_t fCanvVersion
! actual canvas version, changed with every new Modified() call
Definition TWebCanvas.h:91
bool IsCustomClass(const TClass *cl) const
Checks if class belongs to custom.
std::vector< int > fWindowGeometry
! last received window geometry
Definition TWebCanvas.h:109
TPad * ProcessObjectOptions(TWebObjectOptions &item, TPad *pad, int idcnt=1)
Process data for single primitive Returns object pad if object was modified.
void CreateObjectSnapshot(TPadWebSnapshot &master, TPad *pad, TObject *obj, const char *opt, TWebPS *masterps=nullptr)
Creates representation of the object for painting in web browser.
void AddColorsPalette(TPadWebSnapshot &master)
Add special canvas objects with list of colors and color palette.
Long64_t fStyleVersion
! current gStyle object version, checked every time when new snapshot created
Definition TWebCanvas.h:104
void AddSendQueue(unsigned connid, const std::string &msg)
Add message to send queue for specified connection If connid == 0, message will be add to all connect...
void SetWindowPosition(Int_t x, Int_t y) override
Set window position of web canvas.
UpdatedSignal_t fUpdatedSignal
! signal emitted when canvas updated or state is changed
Definition TWebCanvas.h:112
Int_t fJsonComp
! compression factor for messages send to the client
Definition TWebCanvas.h:97
Bool_t IsFirstConn(unsigned connid) const
Definition TWebCanvas.h:147
~TWebCanvas() override
Destructor.
Bool_t fReadOnly
!< configured display
Definition TWebCanvas.h:90
std::map< TPad *, PadStatus > fPadsStatus
! map of pads in canvas and their status flags
Definition TWebCanvas.h:86
static Font_t AddFont(const char *name, const char *ttffile, Int_t precision=2)
Add font to static list of fonts upported by the canvas Name specifies name of the font,...
void AddCustomFonts(TPadWebSnapshot &master)
Add special canvas objects with custom fonts.
Bool_t CheckDataToSend(unsigned connid=0)
Check if any data should be send to client If connid != 0, only selected connection will be checked.
Bool_t PerformUpdate(Bool_t async) override
if canvas or any subpad was modified, scan all primitives in the TCanvas and subpads and convert them...
void AssignStatusBits(UInt_t bits)
Assign clients bits.
virtual Bool_t ProcessData(unsigned connid, const std::string &arg)
Handle data from web browser Returns kFALSE if message was not processed.
void ProcessLinesForObject(TObject *obj, const std::string &lines)
Execute one or several methods for selected object String can be separated by ";;" to let execute sev...
TWebCanvas(TCanvas *c, const char *name, Int_t x, Int_t y, UInt_t width, UInt_t height, Bool_t readonly=kTRUE)
Constructor.
static Int_t StoreCanvasJSON(TCanvas *c, const char *filename, const char *option="")
Create JSON painting output for given canvas and store into the file See TBufferJSON::ExportToFile() ...
void Iconify() override
Iconify browser window.
void SetWindowTitle(const char *newTitle) override
Set window title of web canvas.
UInt_t GetWindowGeometry(Int_t &x, Int_t &y, UInt_t &w, UInt_t &h) override
Returns window geometry including borders and menus.
static TCanvasImp * NewCanvas(TCanvas *c, const char *name, Int_t x, Int_t y, UInt_t width, UInt_t height)
Static method to create TWebCanvas instance Used by plugin manager.
static TString CreateCanvasJSON(TCanvas *c, Int_t json_compression=0, Bool_t batchmode=kFALSE)
Create JSON painting output for given canvas Produce JSON can be used for offline drawing with JSROOT...
Bool_t HasEditor() const override
Returns kTRUE if web canvas has graphical editor.
Int_t fStyleDelivery
! gStyle delivery to clients: 0:never, 1:once, 2:always
Definition TWebCanvas.h:94
PadClickedSignal_t fPadDblClickedSignal
! signal emitted when simple mouse click performed on the pad
Definition TWebCanvas.h:115
void ProcessExecs(TPad *pad, TExec *extra=nullptr)
Process TExec objects in the pad.
void CreatePadSnapshot(TPadWebSnapshot &paddata, TPad *pad, Long64_t version, PadPaintingReady_t func)
Create snapshot for pad and all primitives Callback function is used to create JSON in the middle of ...
Bool_t CheckCanvasModified(bool force_modified=false)
Check if any pad on the canvas was modified If yes, increment version of correspondent pad Returns tr...
virtual Bool_t DecodePadOptions(const std::string &, bool process_execs=false)
Decode all pad options, which includes ranges plus objects options.
Int_t GetPaletteDelivery() const
Definition TWebCanvas.h:228
void SetWindowSize(UInt_t w, UInt_t h) override
Set window size of web canvas.
TObject * FindPrimitive(const std::string &id, int idcnt=1, TPad *pad=nullptr, TObjLink **objlnk=nullptr, TPad **objpad=nullptr)
Search of object with given id in list of primitives One could specify pad where search could be star...
Bool_t fFixedSize
! is canvas size fixed
Definition TWebCanvas.h:110
Int_t GetStyleDelivery() const
Definition TWebCanvas.h:225
void PopulateObjectMenu(void *obj, TClass *cl)
Class used to transport drawing options from the client.
std::vector< double > fopt
custom float array
std::string fcust
custom string
std::string snapid
id of the object
std::string opt
drawing options
void CreatePainting()
Definition TWebPS.cxx:26
Bool_t IsEmptyPainting() const
Definition TWebPS.h:32
TWebPainting * TakePainting()
Definition TWebPS.h:34
TWebPainting * GetPainting()
Definition TWebPS.h:33
Implement TVirtualPadPainter which abstracts painting operations.
Object used to store paint operations and deliver them to JSROOT.
void AddColor(Int_t indx, TColor *col)
Add custom color to operations.
void AddOper(const std::string &oper)
Add next custom operator to painting Operations are separated by semicolons Following operations are ...
@ kStyle
gStyle object
@ kObject
object itself
@ kSVG
list of SVG primitives
@ kSubPad
subpad
@ kFont
custom web font
@ kColors
list of ROOT colors + palette
void SetSnapshot(Int_t kind, TObject *snapshot, Bool_t owner=kFALSE)
SetUse pointer to assign object id - TString::Hash.
void SetObjectIDAsPtr(void *ptr, const std::string &suffix="")
Use pointer to assign object id - TString::Hash.
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
const Int_t n
Definition legend1.C:16
TGraphErrors * gr
Definition legend1.C:25
TH1F * h1
Definition legend1.C:5
TF1 * f1
Definition legend1.C:11
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Definition TMath.h:721
bool _detected
! if pad was detected during last scan
Definition TWebCanvas.h:78
TString fName
TString fFormat
WebFont_t()=default
TString fData
WebFont_t(Int_t indx, const TString &name, const TString &fmt, const TString &data)