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 if (r.active && (pad != gPad)) gPad = pad;
1328
1329 if ((pad->GetTickx() != r.tickx) || (pad->GetTicky() != r.ticky))
1330 pad->SetTicks(r.tickx, r.ticky);
1331 if ((pad->GetGridx() != (r.gridx > 0)) || (pad->GetGridy() != (r.gridy > 0)))
1332 pad->SetGrid(r.gridx, r.gridy);
1333 pad->fLogx = r.logx;
1334 pad->fLogy = r.logy;
1335 pad->fLogz = r.logz;
1336
1337 pad->SetLeftMargin(r.mleft);
1338 pad->SetRightMargin(r.mright);
1339 pad->SetTopMargin(r.mtop);
1340 pad->SetBottomMargin(r.mbottom);
1341
1342 if (r.ranges) {
1343 // avoid call of original methods, set members directly
1344 // pad->Range(r.px1, r.py1, r.px2, r.py2);
1345 // pad->RangeAxis(r.ux1, r.uy1, r.ux2, r.uy2);
1346
1347 pad->fX1 = r.px1;
1348 pad->fX2 = r.px2;
1349 pad->fY1 = r.py1;
1350 pad->fY2 = r.py2;
1351
1352 pad->fUxmin = r.ux1;
1353 pad->fUxmax = r.ux2;
1354 pad->fUymin = r.uy1;
1355 pad->fUymax = r.uy2;
1356 }
1357
1358 // pad->SetPad(r.mleft, r.mbottom, 1-r.mright, 1-r.mtop);
1359
1360 pad->fAbsXlowNDC = r.xlow;
1361 pad->fAbsYlowNDC = r.ylow;
1362 pad->fAbsWNDC = r.xup - r.xlow;
1363 pad->fAbsHNDC = r.yup - r.ylow;
1364
1365 if (pad == Canvas()) {
1366 pad->fXlowNDC = r.xlow;
1367 pad->fYlowNDC = r.ylow;
1368 pad->fXUpNDC = r.xup;
1369 pad->fYUpNDC = r.yup;
1370 pad->fWNDC = r.xup - r.xlow;
1371 pad->fHNDC = r.yup - r.ylow;
1372 } else {
1373 auto mother = pad->GetMother();
1374 if (mother->GetAbsWNDC() > 0. && mother->GetAbsHNDC() > 0.) {
1375 pad->fXlowNDC = (r.xlow - mother->GetAbsXlowNDC()) / mother->GetAbsWNDC();
1376 pad->fYlowNDC = (r.ylow - mother->GetAbsYlowNDC()) / mother->GetAbsHNDC();
1377 pad->fXUpNDC = (r.xup - mother->GetAbsXlowNDC()) / mother->GetAbsWNDC();
1378 pad->fYUpNDC = (r.yup - mother->GetAbsYlowNDC()) / mother->GetAbsHNDC();
1379 pad->fWNDC = (r.xup - r.xlow) / mother->GetAbsWNDC();
1380 pad->fHNDC = (r.yup - r.ylow) / mother->GetAbsHNDC();
1381 }
1382 }
1383
1384 // copy of code from TPad::ResizePad()
1385
1386 Double_t pxlow = r.xlow * r.cw;
1387 Double_t pylow = (1-r.ylow) * r.ch;
1388 Double_t pxrange = (r.xup - r.xlow) * r.cw;
1389 Double_t pyrange = -1*(r.yup - r.ylow) * r.ch;
1390
1391 Double_t rounding = 0.00005;
1392 Double_t xrange = r.px2 - r.px1;
1393 Double_t yrange = r.py2 - r.py1;
1394
1395 if ((xrange != 0.) && (pxrange != 0)) {
1396 // Linear X axis
1397 pad->fXtoAbsPixelk = rounding + pxlow - pxrange*r.px1/xrange; //origin at left
1398 pad->fXtoPixelk = rounding + -pxrange*r.px1/xrange;
1399 pad->fXtoPixel = pxrange/xrange;
1400 pad->fAbsPixeltoXk = r.px1 - pxlow*xrange/pxrange;
1401 pad->fPixeltoXk = r.px1;
1402 pad->fPixeltoX = xrange/pxrange;
1403 }
1404
1405 if ((yrange != 0.) && (pyrange != 0.)) {
1406 // Linear Y axis
1407 pad->fYtoAbsPixelk = rounding + pylow - pyrange*r.py1/yrange; //origin at top
1408 pad->fYtoPixelk = rounding + -pyrange - pyrange*r.py1/yrange;
1409 pad->fYtoPixel = pyrange/yrange;
1410 pad->fAbsPixeltoYk = r.py1 - pylow*yrange/pyrange;
1411 pad->fPixeltoYk = r.py1;
1412 pad->fPixeltoY = yrange/pyrange;
1413 }
1414
1416
1417 TObjLink *objlnk = nullptr;
1418
1419 TH1 *hist = static_cast<TH1 *>(FindPrimitive(sid_pad_histogram, 1, pad, &objlnk));
1420
1421 if (hist) {
1422
1423 TObject *hist_holder = objlnk ? objlnk->GetObject() : nullptr;
1424 if (hist_holder == hist)
1425 hist_holder = nullptr;
1426
1427 Bool_t no_entries = hist->GetEntries();
1428
1429 Double_t hmin = 0., hmax = 0.;
1430
1431 if (r.zx1 == r.zx2)
1432 hist->GetXaxis()->SetRange(0,0);
1433 else
1434 hist->GetXaxis()->SetRangeUser(r.zx1, r.zx2);
1435
1436 if (hist->GetDimension() == 1) {
1437 hmin = r.zy1;
1438 hmax = r.zy2;
1439 if ((hmin == hmax) && !no_entries) {
1440 // if there are no zooming on Y and histogram has no entries, hmin/hmax should be set to full range
1441 hmin = pad->fLogy ? TMath::Power(pad->fLogy < 2 ? 10 : pad->fLogy, r.uy1) : r.uy1;
1442 hmax = pad->fLogy ? TMath::Power(pad->fLogy < 2 ? 10 : pad->fLogy, r.uy2) : r.uy2;
1443 }
1444 } else if (r.zy1 == r.zy2) {
1445 hist->GetYaxis()->SetRange(0., 0.);
1446 } else {
1447 hist->GetYaxis()->SetRangeUser(r.zy1, r.zy2);
1448 }
1449
1450 if (hist->GetDimension() == 2) {
1451 hmin = r.zz1;
1452 hmax = r.zz2;
1453 if ((hmin == hmax) && !no_entries) {
1454 // z scale is not transformed
1455 hmin = r.uz1;
1456 hmax = r.uz2;
1457 }
1458 } else if (hist->GetDimension() == 3) {
1459 if (r.zz1 == r.zz2) {
1460 hist->GetZaxis()->SetRange(0., 0.);
1461 } else {
1462 hist->GetZaxis()->SetRangeUser(r.zz1, r.zz2);
1463 }
1464 }
1465
1466 if (hmin == hmax)
1467 hmin = hmax = -1111;
1468
1469 if (!hist_holder || (hist_holder->IsA() == TScatter::Class())) {
1470 hist->SetMinimum(hmin);
1471 hist->SetMaximum(hmax);
1472 } else {
1473 auto SetMember = [hist_holder](const char *name, Double_t value) {
1474 auto offset = hist_holder->IsA()->GetDataMemberOffset(name);
1475 if (offset > 0)
1476 *((Double_t *)((char*) hist_holder + offset)) = value;
1477 else
1478 ::Error("SetMember", "Cannot find %s data member in %s", name, hist_holder->ClassName());
1479 };
1480
1481 // directly set min/max in classes like THStack, TGraph, TMultiGraph
1482 SetMember("fMinimum", hmin);
1483 SetMember("fMaximum", hmax);
1484 }
1485
1486 TIter next(hist->GetListOfFunctions());
1487 while (auto fobj = next())
1488 if (!hist_exec && fobj->InheritsFrom(TExec::Class())) {
1489 hist_exec = (TExec *) fobj;
1490 need_update = kTRUE;
1491 }
1492 }
1493
1494 std::map<std::string, int> idmap;
1495
1496 for (auto &item : r.primitives) {
1497 auto iter = idmap.find(item.snapid);
1498 int idcnt = 1;
1499 if (iter == idmap.end())
1500 idmap[item.snapid] = 1;
1501 else
1502 idcnt = ++iter->second;
1503
1504 ProcessObjectOptions(item, pad, idcnt);
1505 }
1506
1507 // without special objects no need for explicit update of the pad
1508 if (fPadsStatus[pad]._has_specials) {
1509 pad->Modified(kTRUE);
1510 need_update = kTRUE;
1511 }
1512
1513 if (process_execs && (gPad == pad))
1514 pad_with_execs = pad;
1515 }
1516
1517 ProcessExecs(pad_with_execs, hist_exec);
1518
1519 if (fUpdatedSignal) fUpdatedSignal(); // invoke signal
1520
1521 return need_update;
1522}
1523
1524//////////////////////////////////////////////////////////////////////////////////////////////////
1525/// Process TExec objects in the pad
1526
1528{
1529 auto execs = pad ? pad->GetListOfExecs() : nullptr;
1530
1531 if ((!execs || !execs->GetSize()) && !extra)
1532 return;
1533
1534 auto saveps = gVirtualPS;
1535 TWebPS ps;
1536 gVirtualPS = &ps;
1537
1538 auto savex = gVirtualX;
1539 TVirtualX x;
1540 gVirtualX = &x;
1541
1542 TIter next(execs);
1543 while (auto obj = next()) {
1544 auto exec = dynamic_cast<TExec *>(obj);
1545 if (exec)
1546 exec->Exec();
1547 }
1548
1549 if (extra)
1550 extra->Exec();
1551
1552 gVirtualPS = saveps;
1553 gVirtualX = savex;
1554}
1555
1556//////////////////////////////////////////////////////////////////////////////////////////
1557/// Execute one or several methods for selected object
1558/// String can be separated by ";;" to let execute several methods at once
1559void TWebCanvas::ProcessLinesForObject(TObject *obj, const std::string &lines)
1560{
1561 std::string buf = lines;
1562
1563 Int_t indx = 0;
1564
1565 while (obj && !buf.empty()) {
1566 std::string sub = buf;
1567 auto pos = buf.find(";;");
1568 if (pos == std::string::npos) {
1569 sub = buf;
1570 buf.clear();
1571 } else {
1572 sub = buf.substr(0,pos);
1573 buf = buf.substr(pos+2);
1574 }
1575 if (sub.empty()) continue;
1576
1577 std::stringstream exec;
1578 exec << "((" << obj->ClassName() << " *) " << std::hex << std::showbase << (size_t)obj << ")->" << sub << ";";
1579 if (indx < 3 || gDebug > 0)
1580 Info("ProcessLinesForObject", "Obj %s Execute %s", obj->GetName(), exec.str().c_str());
1581 gROOT->ProcessLine(exec.str().c_str());
1582 indx++;
1583 }
1584}
1585
1586//////////////////////////////////////////////////////////////////////////////////////////
1587/// Handle data from web browser
1588/// Returns kFALSE if message was not processed
1589
1590Bool_t TWebCanvas::ProcessData(unsigned connid, const std::string &arg)
1591{
1592 if (arg.empty())
1593 return kTRUE;
1594
1595 // try to identify connection for given WS request
1596 unsigned indx = 0; // first connection is batch and excluded
1597 while(++indx < fWebConn.size()) {
1598 if (fWebConn[indx].fConnId == connid)
1599 break;
1600 }
1601 if (indx >= fWebConn.size())
1602 return kTRUE;
1603
1604 Bool_t is_main_connection = indx == 1; // first connection allow to make changes
1605
1606 struct FlagGuard {
1607 Bool_t &flag;
1608 FlagGuard(Bool_t &_flag) : flag(_flag) { flag = true; }
1609 ~FlagGuard() { flag = false; }
1610 };
1611
1612 FlagGuard guard(fProcessingData);
1613
1614 const char *cdata = arg.c_str();
1615
1616 if (arg == "KEEPALIVE") {
1617 // do nothing
1618
1619 } else if (arg == "QUIT") {
1620
1621 // use window manager to correctly terminate http server
1622 fWindow->TerminateROOT();
1623
1624 } else if (arg.compare(0, 7, "READY6:") == 0) {
1625
1626 // this is reply on drawing of ROOT6 snapshot
1627 // it confirms when drawing of specific canvas version is completed
1628
1629 cdata += 7;
1630
1631 const char *separ = strchr(cdata, ':');
1632 if (!separ) {
1633 fWebConn[indx].fDrawVersion = std::stoll(cdata);
1634 } else {
1635 fWebConn[indx].fDrawVersion = std::stoll(std::string(cdata, separ - cdata));
1636 if (is_main_connection && !IsReadOnly())
1637 if (DecodePadOptions(separ+1, false))
1639 }
1640
1641 } else if (arg == "RELOAD") {
1642
1643 // trigger reload of canvas data
1644 fWebConn[indx].reset();
1645
1646 } else if (arg.compare(0, 5, "SAVE:") == 0) {
1647
1648 // save image produced by the client side - like png or svg
1649 const char *img = cdata + 5;
1650
1651 const char *separ = strchr(img, ':');
1652 if (separ) {
1653 TString filename(img, separ - img);
1654 img = separ + 1;
1655
1656 std::ofstream ofs(filename.Data());
1657
1658 if (filename.Index(".svg") != kNPOS) {
1659 // ofs << "<?xml version=\"1.0\" standalone=\"no\"?>";
1660 ofs << img;
1661 } else {
1662 TString binary = TBase64::Decode(img);
1663 ofs.write(binary.Data(), binary.Length());
1664 }
1665 ofs.close();
1666
1667 Info("ProcessData", "File %s has been created", filename.Data());
1668 }
1669
1670 } else if (arg.compare(0, 8, "PRODUCE:") == 0) {
1671
1672 // create ROOT, PDF, ... files using native ROOT functionality
1673 Canvas()->Print(arg.c_str() + 8);
1674
1675 } else if (arg.compare(0, 9, "OPTIONS6:") == 0) {
1676
1677 if (is_main_connection && !IsReadOnly())
1678 if (DecodePadOptions(arg.substr(9), true))
1680
1681 } else if (arg.compare(0, 11, "STATUSBITS:") == 0) {
1682
1683 if (is_main_connection) {
1684 AssignStatusBits(std::stoul(arg.substr(11)));
1685 if (fUpdatedSignal) fUpdatedSignal(); // invoke signal
1686 }
1687 } else if (arg.compare(0, 10, "HIGHLIGHT:") == 0) {
1688 if (is_main_connection) {
1689 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(10));
1690 if (!arr || (arr->size() != 4)) {
1691 Error("ProcessData", "Wrong arguments count %d in highlight message", (int)(arr ? arr->size() : -1));
1692 } else {
1693 auto pad = dynamic_cast<TVirtualPad *>(FindPrimitive(arr->at(0)));
1694 auto obj = FindPrimitive(arr->at(1));
1695 int argx = std::stoi(arr->at(2));
1696 int argy = std::stoi(arr->at(3));
1697 if (pad && obj) {
1698 Canvas()->Highlighted(pad, obj, argx, argy);
1700 }
1701 }
1702 }
1703 } else if (ROOT::RWebWindow::IsFileDialogMessage(arg)) {
1704
1706
1707 } else if (arg == "FITPANEL"s) {
1708
1709 TH1 *hist = nullptr;
1710 TIter iter(Canvas()->GetListOfPrimitives());
1711 while (auto obj = iter()) {
1712 hist = dynamic_cast<TH1 *>(obj);
1713 if (hist) break;
1714 }
1715
1716 TString cmd = TString::Format("auto panel = std::make_shared<ROOT::Experimental::RFitPanel>(\"FitPanel\");"
1717 "panel->AssignCanvas(\"%s\");"
1718 "panel->AssignHistogram((TH1 *)0x%zx);"
1719 "panel->Show();"
1720 "panel->ClearOnClose(panel);", Canvas()->GetName(), (size_t) hist);
1721
1722 gROOT->ProcessLine(cmd.Data());
1723
1724 } else if (arg == "START_BROWSER"s) {
1725
1726 gROOT->ProcessLine("new TBrowser;");
1727
1728 } else if (IsReadOnly()) {
1729
1730 // all following messages are not allowed in readonly mode
1731 return kFALSE;
1732
1733 } else if (arg.compare(0, 6, "EVENT:") == 0) {
1734 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(6));
1735 if (!arr || (arr->size() != 5)) {
1736 Error("ProcessData", "Wrong arguments count %d in event message", (int)(arr ? arr->size() : -1));
1737 } else {
1738 auto pad = dynamic_cast<TPad *>(FindPrimitive(arr->at(0)));
1739 std::string kind = arr->at(1);
1740 int event = -1;
1741 if (kind == "move"s) event = kMouseMotion;
1742 int argx = std::stoi(arr->at(2));
1743 int argy = std::stoi(arr->at(3));
1744 auto selobj = FindPrimitive(arr->at(4));
1745
1746 if ((event >= 0) && pad && (pad == gPad)) {
1747 Canvas()->fEvent = event;
1748 Canvas()->fEventX = argx;
1749 Canvas()->fEventY = argy;
1750
1751 Canvas()->fSelected = selobj;
1752
1753 ProcessExecs(pad);
1754 }
1755 }
1756
1757 } else if (arg.compare(0, 8, "GETMENU:") == 0) {
1758
1759 TObject *obj = FindPrimitive(arg.substr(8));
1760 if (!obj)
1761 obj = Canvas();
1762
1763 TWebMenuItems items(arg.c_str() + 8);
1764 items.PopulateObjectMenu(obj, obj->IsA());
1765 std::string buf = "MENU:";
1766 buf.append(TBufferJSON::ToJSON(&items, 103).Data());
1767
1768 AddSendQueue(connid, buf);
1769
1770 } else if (arg.compare(0, 8, "PRIMIT6:") == 0) {
1771
1772 if (IsFirstConn(connid) && !IsReadOnly()) { // only first connection can modify object
1773
1774 auto opt = TBufferJSON::FromJSON<TWebObjectOptions>(arg.c_str() + 8);
1775
1776 if (opt) {
1777 TPad *modpad = ProcessObjectOptions(*opt, nullptr);
1778
1779 // indicate that pad was modified
1780 if (modpad)
1781 modpad->Modified();
1782 }
1783 }
1784
1785 } else if (arg.compare(0, 11, "PADCLICKED:") == 0) {
1786
1787 auto click = TBufferJSON::FromJSON<TWebPadClick>(arg.c_str() + 11);
1788
1789 if (click && IsFirstConn(connid) && !IsReadOnly()) {
1790
1791 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(click->padid));
1792
1793 if (pad && pad->InheritsFrom(TButton::Class())) {
1794 auto btn = (TButton *) pad;
1795 const char *mthd = btn->GetMethod();
1796 if (mthd && *mthd) {
1797 TVirtualPad::TContext ctxt(gROOT->GetSelectedPad(), kTRUE, kTRUE);
1798 gROOT->ProcessLine(mthd);
1799 }
1800 return kTRUE;
1801 }
1802
1803 if (pad && (pad != gPad)) {
1804 gPad = pad;
1808 }
1809
1810 if (!click->objid.empty()) {
1811 auto selobj = FindPrimitive(click->objid);
1812 Canvas()->SetClickSelected(selobj);
1813 Canvas()->fSelected = selobj;
1814 if (pad && selobj && fObjSelectSignal)
1815 fObjSelectSignal(pad, selobj);
1816 }
1817
1818 if ((click->x >= 0) && (click->y >= 0)) {
1819 Canvas()->fEvent = click->dbl ? kButton1Double : kButton1Up;
1820 Canvas()->fEventX = click->x;
1821 Canvas()->fEventY = click->y;
1822 if (click->dbl && fPadDblClickedSignal)
1823 fPadDblClickedSignal(pad, click->x, click->y);
1824 else if (!click->dbl && fPadClickedSignal)
1825 fPadClickedSignal(pad, click->x, click->y);
1826 }
1827
1828 ProcessExecs(pad);
1829 }
1830
1831 } else if (arg.compare(0, 8, "OBJEXEC:") == 0) {
1832
1833 auto buf = arg.substr(8);
1834 auto pos = buf.find(":");
1835
1836 if ((pos > 0) && IsFirstConn(connid) && !IsReadOnly()) { // only first client can execute commands
1837 auto sid = buf.substr(0, pos);
1838 buf.erase(0, pos + 1);
1839
1840 TObjLink *lnk = nullptr;
1841 TPad *objpad = nullptr;
1842
1843 TObject *obj = FindPrimitive(sid, 1, nullptr, &lnk, &objpad);
1844
1845 if (obj && !buf.empty()) {
1846
1847 ProcessLinesForObject(obj, buf);
1848
1849 if (objpad)
1850 objpad->Modified();
1851 else
1852 Canvas()->Modified();
1853
1855 }
1856 }
1857
1858 } else if (arg.compare(0, 12, "EXECANDSEND:") == 0) {
1859
1860 // execute method and send data, used by drawing projections
1861
1862 std::string buf = arg.substr(12);
1863 std::string reply;
1864 TObject *obj = nullptr;
1865
1866 auto pos = buf.find(":");
1867
1868 if ((pos > 0) && IsFirstConn(connid) && !IsReadOnly()) {
1869 // only first client can execute commands
1870 reply = buf.substr(0, pos);
1871 buf.erase(0, pos + 1);
1872 pos = buf.find(":");
1873 if (pos > 0) {
1874 auto sid = buf.substr(0, pos);
1875 buf.erase(0, pos + 1);
1876 obj = FindPrimitive(sid);
1877 }
1878 }
1879
1880 if (obj && !buf.empty() && !reply.empty()) {
1881 std::stringstream exec;
1882 exec << "((" << obj->ClassName() << " *) " << std::hex << std::showbase << (size_t)obj
1883 << ")->" << buf << ";";
1884 if (gDebug > 1)
1885 Info("ProcessData", "Obj %s Exec %s", obj->GetName(), exec.str().c_str());
1886
1887 auto res = gROOT->ProcessLine(exec.str().c_str());
1888 TObject *resobj = (TObject *)(res);
1889 if (resobj) {
1890 std::string send = reply;
1891 send.append(":");
1892 send.append(TBufferJSON::ToJSON(resobj, 23).Data());
1893 AddSendQueue(connid, send);
1894 if (reply[0] == 'D')
1895 delete resobj; // delete object if first symbol in reply is D
1896 }
1897 }
1898
1899 } else if (arg.compare(0, 6, "CLEAR:") == 0) {
1900 std::string snapid = arg.substr(6);
1901
1902 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(snapid));
1903
1904 if (pad) {
1905 pad->Clear();
1906 pad->Modified();
1908 } else {
1909 Error("ProcessData", "Not found pad with id %s to clear\n", snapid.c_str());
1910 }
1911 } else if (arg.compare(0, 7, "DIVIDE:") == 0) {
1912 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(7));
1913 if (arr && arr->size() == 2) {
1914 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(arr->at(0)));
1915 int nn = 0, n1 = 0, n2 = 0;
1916
1917 std::string divide = arr->at(1);
1918 auto p = divide.find('x');
1919 if (p == std::string::npos)
1920 p = divide.find('X');
1921
1922 if (p != std::string::npos) {
1923 n1 = std::stoi(divide.substr(0,p));
1924 n2 = std::stoi(divide.substr(p+1));
1925 } else {
1926 nn = std::stoi(divide);
1927 }
1928
1929 if (pad && ((nn > 1) || (n1*n2 > 1))) {
1930 pad->Clear();
1931 pad->Modified();
1932 if (nn > 1)
1933 pad->DivideSquare(nn);
1934 else
1935 pad->Divide(n1, n2);
1936 pad->cd(1);
1938 }
1939 }
1940
1941 } else if (arg.compare(0, 8, "DRAWOPT:") == 0) {
1942 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(8));
1943 if (arr && arr->size() == 2) {
1944 TObjLink *objlnk = nullptr;
1945 FindPrimitive(arr->at(0), 1, nullptr, &objlnk);
1946 if (objlnk)
1947 objlnk->SetOption(arr->at(1).c_str());
1948 }
1949 } else if (arg.compare(0, 8, "RESIZED:") == 0) {
1950 auto arr = TBufferJSON::FromJSON<std::vector<int>>(arg.substr(8));
1951 if (arr && arr->size() == 7) {
1952 // set members directly to avoid redrawing of the client again
1953 Canvas()->fCw = arr->at(4);
1954 Canvas()->fCh = arr->at(5);
1955 fFixedSize = arr->at(6) > 0;
1956 arr->resize(4);
1957 fWindowGeometry = *arr;
1962 }
1963 } else if (arg.compare(0, 7, "POPOBJ:") == 0) {
1964 auto arr = TBufferJSON::FromJSON<std::vector<std::string>>(arg.substr(7));
1965 if (arr && arr->size() == 2) {
1966 TPad *pad = dynamic_cast<TPad *>(FindPrimitive(arr->at(0)));
1967 TObject *obj = FindPrimitive(arr->at(1), 0, pad);
1968 if (pad && obj && (obj != pad->GetListOfPrimitives()->Last())) {
1969 TIter next(pad->GetListOfPrimitives());
1970 while (auto o = next())
1971 if (obj == o) {
1972 TString opt = next.GetOption();
1973 pad->GetListOfPrimitives()->Remove(obj);
1974 pad->GetListOfPrimitives()->AddLast(obj, opt.Data());
1975 pad->Modified();
1976 break;
1977 }
1978 }
1979 }
1980 } else if (arg == "INTERRUPT"s) {
1981 gROOT->SetInterrupt();
1982 } else {
1983 // unknown message, probably should be processed by other implementation
1984 return kFALSE;
1985 }
1986
1987 return kTRUE;
1988}
1989
1990//////////////////////////////////////////////////////////////////////////////////////////
1991/// Returns true if any pad in the canvas were modified
1992/// Reset modified flags, increment canvas version (if inc_version is true)
1993
1995{
1996 if (fPadsStatus.find(pad) == fPadsStatus.end())
1997 fPadsStatus[pad] = PadStatus{0, true, true};
1998
1999 auto &entry = fPadsStatus[pad];
2000 entry._detected = true;
2001 if (pad->IsModified()) {
2002 pad->Modified(kFALSE);
2003 entry._modified = true;
2004 }
2005
2006 TIter iter(pad->GetListOfPrimitives());
2007 while (auto obj = iter()) {
2008 if (obj->InheritsFrom(TPad::Class()))
2009 CheckPadModified(static_cast<TPad *>(obj));
2010 }
2011}
2012
2013//////////////////////////////////////////////////////////////////////////////////////////
2014/// Check if any pad on the canvas was modified
2015/// If yes, increment version of correspondent pad
2016/// Returns true when canvas really modified
2017
2019{
2020 // clear temporary flags
2021 for (auto &entry : fPadsStatus) {
2022 entry.second._detected = false;
2023 entry.second._modified = force_modified;
2024 }
2025
2026 // scan sub-pads
2028
2029 // remove no-longer existing pads
2030 bool is_any_modified = false;
2031 for(auto iter = fPadsStatus.begin(); iter != fPadsStatus.end(); ) {
2032 if (iter->second._modified)
2033 is_any_modified = true;
2034 if (!iter->second._detected)
2035 fPadsStatus.erase(iter++);
2036 else
2037 iter++;
2038 }
2039
2040 // if any pad modified, increment canvas version and set version of modified pads
2041 if (is_any_modified) {
2042 fCanvVersion++;
2043 for(auto &entry : fPadsStatus)
2044 if (entry.second._modified)
2045 entry.second.fVersion = fCanvVersion;
2046 }
2047
2048 return is_any_modified;
2049}
2050
2051
2052//////////////////////////////////////////////////////////////////////////////////////////
2053/// Returns window geometry including borders and menus
2054
2056{
2057 if (fWindowGeometry.size() == 4) {
2058 x = fWindowGeometry[0];
2059 y = fWindowGeometry[1];
2060 w = fWindowGeometry[2];
2061 h = fWindowGeometry[3];
2062 } else {
2063 x = Canvas()->fWindowTopX;
2064 y = Canvas()->fWindowTopY;
2065 w = Canvas()->fWindowWidth;
2066 h = Canvas()->fWindowHeight;
2067 }
2068 return 0;
2069}
2070
2071
2072//////////////////////////////////////////////////////////////////////////////////////////
2073/// if canvas or any subpad was modified,
2074/// scan all primitives in the TCanvas and subpads and convert them into
2075/// the structure which will be delivered to JSROOT client
2076
2078{
2080
2082
2083 if (!fProcessingData && !IsAsyncMode() && !async)
2085
2086 return kTRUE;
2087}
2088
2089//////////////////////////////////////////////////////////////////////////////////////////
2090/// Increment canvas version and force sending data to client - do not wait for reply
2091
2093{
2094 CheckCanvasModified(true);
2095
2096 if (!fWindow) {
2097 TCanvasWebSnapshot holder(IsReadOnly(), false, true); // readonly, set ids, batchmode
2098 CreatePadSnapshot(holder, Canvas(), 0, nullptr);
2099 } else {
2101 }
2102}
2103
2104//////////////////////////////////////////////////////////////////////////////////////////
2105/// Wait when specified version of canvas was painted and confirmed by browser
2106
2108{
2109 if (!fWindow)
2110 return kTRUE;
2111
2112 // simple polling loop until specified version delivered to the clients
2113 // first 500 loops done without sleep, then with 1ms sleep and last 500 with 100 ms sleep
2114
2115 long cnt = 0, cnt_limit = GetLongerPolling() ? 5500 : 1500;
2116
2117 if (gDebug > 2)
2118 Info("WaitWhenCanvasPainted", "version %ld", (long)ver);
2119
2120 while (cnt++ < cnt_limit) {
2121
2122 if (!fWindow->HasConnection(0, false)) {
2123 if (gDebug > 2)
2124 Info("WaitWhenCanvasPainted", "no connections - abort");
2125 return kFALSE; // wait ~1 min if no new connection established
2126 }
2127
2128 if ((fWebConn.size() > 1) && (fWebConn[1].fDrawVersion >= ver)) {
2129 if (gDebug > 2)
2130 Info("WaitWhenCanvasPainted", "ver %ld got painted", (long)ver);
2131 return kTRUE;
2132 }
2133
2135 if (cnt > 500)
2136 gSystem->Sleep((cnt < cnt_limit - 500) ? 1 : 100); // increase sleep interval when do very often
2137 }
2138
2139 if (gDebug > 2)
2140 Info("WaitWhenCanvasPainted", "timeout");
2141
2142 return kFALSE;
2143}
2144
2145//////////////////////////////////////////////////////////////////////////////////////////
2146/// Create JSON painting output for given pad
2147/// Produce JSON can be used for offline drawing with JSROOT
2148
2149TString TWebCanvas::CreatePadJSON(TPad *pad, Int_t json_compression, Bool_t batchmode)
2150{
2151 TString res;
2152 if (!pad)
2153 return res;
2154
2155 TCanvas *c = dynamic_cast<TCanvas *>(pad);
2156 if (c) {
2157 res = CreateCanvasJSON(c, json_compression, batchmode);
2158 } else {
2159 auto imp = std::make_unique<TWebCanvas>(pad->GetCanvas(), pad->GetName(), 0, 0, pad->GetWw(), pad->GetWh(), kTRUE);
2160
2161 TPadWebSnapshot holder(true, false, batchmode); // readonly, no ids, batchmode
2162
2163 imp->CreatePadSnapshot(holder, pad, 0, [&res, json_compression](TPadWebSnapshot *snap) {
2164 res = TBufferJSON::ToJSON(snap, json_compression);
2165 });
2166 }
2167
2168 return res;
2169}
2170
2171//////////////////////////////////////////////////////////////////////////////////////////
2172/// Create JSON painting output for given canvas
2173/// Produce JSON can be used for offline drawing with JSROOT
2174
2176{
2177 TString res;
2178
2179 if (!c)
2180 return res;
2181
2182 {
2183 auto imp = std::make_unique<TWebCanvas>(c, c->GetName(), 0, 0, c->GetWw(), c->GetWh(), kTRUE);
2184
2185 TCanvasWebSnapshot holder(true, false, batchmode); // readonly, no ids, batchmode
2186
2187 imp->CreatePadSnapshot(holder, c, 0, [&res, json_compression](TPadWebSnapshot *snap) {
2188 res = TBufferJSON::ToJSON(snap, json_compression);
2189 });
2190 }
2191
2192 return res;
2193}
2194
2195//////////////////////////////////////////////////////////////////////////////////////////
2196/// Create JSON painting output for given canvas and store into the file
2197/// See TBufferJSON::ExportToFile() method for more details about option
2198/// If option string starts with symbol 'b', JSON for batch mode will be generated
2199
2201{
2202 Int_t res = 0;
2203 Bool_t batchmode = kFALSE;
2204 if (option && *option == 'b') {
2205 batchmode = kTRUE;
2206 ++option;
2207 }
2208
2209 if (!c)
2210 return res;
2211
2212 {
2213 auto imp = std::make_unique<TWebCanvas>(c, c->GetName(), 0, 0, c->GetWw(), c->GetWh(), kTRUE);
2214
2215 TCanvasWebSnapshot holder(true, false, batchmode); // readonly, no ids, batchmode
2216
2217 imp->CreatePadSnapshot(holder, c, 0, [&res, filename, option](TPadWebSnapshot *snap) {
2219 });
2220 }
2221
2222 return res;
2223}
2224
2225//////////////////////////////////////////////////////////////////////////////////////////
2226/// Create image using batch (headless) capability of Chrome or Firefox browsers
2227/// Supported png, jpeg, svg, pdf formats
2228
2229bool TWebCanvas::ProduceImage(TPad *pad, const char *fileName, Int_t width, Int_t height)
2230{
2231 if (!pad)
2232 return false;
2233
2235 if (!json.Length())
2236 return false;
2237
2238 if (!width && !height) {
2239 if ((pad->GetCanvas() == pad) || (pad->IsA() == TCanvas::Class())) {
2240 width = pad->GetWw();
2241 height = pad->GetWh();
2242 } else {
2243 width = (Int_t) (pad->GetAbsWNDC() * pad->GetCanvas()->GetWw());
2244 height = (Int_t) (pad->GetAbsHNDC() * pad->GetCanvas()->GetWh());
2245 }
2246 }
2247
2248 return ROOT::RWebDisplayHandle::ProduceImage(fileName, json.Data(), width, height);
2249}
2250
2251//////////////////////////////////////////////////////////////////////////////////////////
2252/// Create images for several pads using batch (headless) capability of Chrome or Firefox browsers
2253/// Supported png, jpeg, svg, pdf, webp formats
2254/// One can include %d qualifier which will be replaced by image index using printf functionality.
2255/// If for pdf format %d qualifier not specified, all images will be stored in single PDF file.
2256/// For all other formats %d qualifier will be add before extension automatically
2257
2258bool TWebCanvas::ProduceImages(std::vector<TPad *> pads, const char *filename, Int_t width, Int_t height)
2259{
2260 if (pads.empty())
2261 return false;
2262
2263 std::vector<std::string> jsons;
2264 std::vector<Int_t> widths, heights;
2265
2266 bool isMultiPdf = (strstr(filename, ".pdf") || strstr(filename, ".PDF")) && strstr(filename, "%");
2267 bool is_multipdf_ok = true;
2268
2269 for (unsigned n = 0; n < pads.size(); ++n) {
2270 auto pad = pads[n];
2271
2273 if (!json.Length())
2274 continue;
2275
2276 Int_t w = width, h = height;
2277
2278 if (!w && !h) {
2279 if ((pad->GetCanvas() == pad) || (pad->IsA() == TCanvas::Class())) {
2280 w = pad->GetWw();
2281 h = pad->GetWh();
2282 } else {
2283 w = (Int_t) (pad->GetAbsWNDC() * pad->GetCanvas()->GetWw());
2284 h = (Int_t) (pad->GetAbsHNDC() * pad->GetCanvas()->GetWh());
2285 }
2286 }
2287
2288 if (isMultiPdf) {
2289 TString pdfname = TString::Format(filename, (int)n);
2290 if (!ROOT::RWebDisplayHandle::ProduceImage(pdfname.Data(), json.Data(), w, h))
2291 is_multipdf_ok = false;
2292 } else {
2293 jsons.emplace_back(json.Data());
2294 widths.emplace_back(w);
2295 heights.emplace_back(h);
2296 }
2297 }
2298
2299 if (isMultiPdf)
2300 return is_multipdf_ok;
2301
2302 return ROOT::RWebDisplayHandle::ProduceImages(filename, jsons, widths, heights);
2303}
2304
2305
2306//////////////////////////////////////////////////////////////////////////////////////////
2307/// Process data for single primitive
2308/// Returns object pad if object was modified
2309
2311{
2312 TObjLink *lnk = nullptr;
2313 TPad *objpad = nullptr;
2314 TObject *obj = FindPrimitive(item.snapid, idcnt, pad, &lnk, &objpad);
2315
2316 if (item.fcust.compare("exec") == 0) {
2317 auto pos = item.opt.find("(");
2318 if (obj && (pos != std::string::npos) && obj->IsA()->GetMethodAllAny(item.opt.substr(0,pos).c_str())) {
2319 std::stringstream exec;
2320 exec << "((" << obj->ClassName() << " *) " << std::hex << std::showbase
2321 << (size_t)obj << ")->" << item.opt << ";";
2322 Info("ProcessObjectOptions", "Obj %s Execute %s", obj->GetName(), exec.str().c_str());
2323 gROOT->ProcessLine(exec.str().c_str());
2324 } else {
2325 Error("ProcessObjectOptions", "Fail to execute %s for object %p %s", item.opt.c_str(), obj, obj ? obj->ClassName() : "---");
2326 objpad = nullptr;
2327 }
2328 return objpad;
2329 }
2330
2331 bool modified = false;
2332
2333 if (obj && lnk) {
2334 auto pos = item.opt.find(";;use_"); // special coding of extra options
2335 if (pos != std::string::npos) item.opt.resize(pos);
2336
2337 if (gDebug > 1)
2338 Info("ProcessObjectOptions", "Set draw option %s for object %s %s", item.opt.c_str(),
2339 obj->ClassName(), obj->GetName());
2340
2341 lnk->SetOption(item.opt.c_str());
2342
2343 modified = true;
2344 }
2345
2346 if (item.fcust.compare(0,10,"auto_exec:") == 0) {
2347 ProcessLinesForObject(obj, item.fcust.substr(10));
2348 } else if (item.fcust.compare("frame") == 0) {
2349 if (obj && obj->InheritsFrom(TFrame::Class())) {
2350 TFrame *frame = static_cast<TFrame *>(obj);
2351 if (item.fopt.size() >= 4) {
2352 frame->SetX1(item.fopt[0]);
2353 frame->SetY1(item.fopt[1]);
2354 frame->SetX2(item.fopt[2]);
2355 frame->SetY2(item.fopt[3]);
2356 modified = true;
2357 }
2358 }
2359 } else if (item.fcust.compare(0,4,"pave") == 0) {
2360 if (obj && obj->InheritsFrom(TPave::Class())) {
2361 TPave *pave = static_cast<TPave *>(obj);
2362 if ((item.fopt.size() >= 4) && objpad) {
2363 TVirtualPad::TContext ctxt(objpad, kFALSE);
2364
2365 // first time need to overcome init problem
2366 pave->ConvertNDCtoPad();
2367
2368 pave->SetX1NDC(item.fopt[0]);
2369 pave->SetY1NDC(item.fopt[1]);
2370 pave->SetX2NDC(item.fopt[2]);
2371 pave->SetY2NDC(item.fopt[3]);
2372 modified = true;
2373
2374 pave->ConvertNDCtoPad();
2375 }
2376 if ((item.fcust.length() > 4) && pave->InheritsFrom(TPaveStats::Class())) {
2377 // add text lines for statsbox
2378 auto stats = static_cast<TPaveStats *>(pave);
2379 stats->Clear();
2380 size_t pos_start = 6, pos_end;
2381 while ((pos_end = item.fcust.find(";;", pos_start)) != std::string::npos) {
2382 stats->AddText(item.fcust.substr(pos_start, pos_end - pos_start).c_str());
2383 pos_start = pos_end + 2;
2384 }
2385 stats->AddText(item.fcust.substr(pos_start).c_str());
2386 }
2387 }
2388 } else if (item.fcust.compare(0,9,"func_fail") == 0) {
2389 if (!fTF1UseSave) {
2391 modified = true;
2392 } else {
2393 Error("ProcessObjectOptions", "Client fails to calculate function %s cl %s but it should not try!", obj ? obj->GetName() : "---", obj ? obj->ClassName() : "---");
2394 }
2395 }
2396
2397 return modified ? objpad : nullptr;
2398}
2399
2400//////////////////////////////////////////////////////////////////////////////////////////////////
2401/// Search of object with given id in list of primitives
2402/// One could specify pad where search could be start
2403/// Also if object is in list of primitives, one could ask for entry link for such object,
2404/// This can allow to change draw option
2405
2406TObject *TWebCanvas::FindPrimitive(const std::string &sid, int idcnt, TPad *pad, TObjLink **objlnk, TPad **objpad)
2407{
2408 if (sid.empty() || (sid == "0"s))
2409 return nullptr;
2410
2411 if (!pad)
2412 pad = Canvas();
2413
2414 std::string subelement;
2415 long unsigned id = 0;
2416 bool search_hist = (sid == sid_pad_histogram);
2417 if (!search_hist) {
2418 auto separ = sid.find("#");
2419
2420 if (separ == std::string::npos) {
2421 id = std::stoul(sid);
2422 } else {
2423 subelement = sid.substr(separ + 1);
2424 id = std::stoul(sid.substr(0, separ));
2425 }
2426 if (TString::Hash(&pad, sizeof(pad)) == id)
2427 return pad;
2428 }
2429
2430 for (auto lnk = pad->GetListOfPrimitives()->FirstLink(); lnk != nullptr; lnk = lnk->Next()) {
2431 TObject *obj = lnk->GetObject();
2432 if (!obj) continue;
2433
2434 if (!search_hist && (TString::Hash(&obj, sizeof(obj)) != id)) {
2435 if (obj->InheritsFrom(TPad::Class())) {
2436 obj = FindPrimitive(sid, idcnt, (TPad *)obj, objlnk, objpad);
2437 if (objpad && !*objpad)
2438 *objpad = pad;
2439 if (obj)
2440 return obj;
2441 }
2442 continue;
2443 }
2444
2445 // one may require to access n-th object
2446 if (!search_hist && --idcnt > 0)
2447 continue;
2448
2449 if (objpad)
2450 *objpad = pad;
2451
2452 if (objlnk)
2453 *objlnk = lnk;
2454
2455 if (search_hist)
2456 subelement = "hist";
2457
2458 auto getHistogram = [](TObject *container) -> TH1* {
2459 auto offset = container->IsA()->GetDataMemberOffset("fHistogram");
2460 if (offset > 0)
2461 return *((TH1 **)((char *)container + offset));
2462 ::Error("getHistogram", "Cannot access fHistogram data member in %s", container->ClassName());
2463 return nullptr;
2464 };
2465
2466 while(!subelement.empty() && obj) {
2467 // do not return link if sub-selement is searched - except for histogram
2468 if (!search_hist && objlnk)
2469 *objlnk = nullptr;
2470
2471 std::string kind = subelement;
2472 auto separ = kind.find("#");
2473 if (separ == std::string::npos) {
2474 subelement.clear();
2475 } else {
2476 kind.resize(separ);
2477 subelement = subelement.substr(separ + 1);
2478 }
2479
2480 TH1 *h1 = obj->InheritsFrom(TH1::Class()) ? static_cast<TH1 *>(obj) : nullptr;
2481 TGraph *gr = obj->InheritsFrom(TGraph::Class()) ? static_cast<TGraph *>(obj) : nullptr;
2482 TGraph2D *gr2d = obj->InheritsFrom(TGraph2D::Class()) ? static_cast<TGraph2D *>(obj) : nullptr;
2483 TScatter *scatter = obj->InheritsFrom(TScatter::Class()) ? static_cast<TScatter *>(obj) : nullptr;
2484 TMultiGraph *mg = obj->InheritsFrom(TMultiGraph::Class()) ? static_cast<TMultiGraph *>(obj) : nullptr;
2485 THStack *hs = obj->InheritsFrom(THStack::Class()) ? static_cast<THStack *>(obj) : nullptr;
2486 TF1 *f1 = obj->InheritsFrom(TF1::Class()) ? static_cast<TF1 *>(obj) : nullptr;
2487
2488 if (kind.compare("hist") == 0) {
2489 if (h1)
2490 obj = h1;
2491 else if (gr)
2492 obj = getHistogram(gr);
2493 else if (mg)
2494 obj = getHistogram(mg);
2495 else if (hs)
2496 obj = getHistogram(hs);
2497 else if (scatter)
2498 obj = getHistogram(scatter);
2499 else if (f1)
2500 obj = getHistogram(f1);
2501 else if (gr2d)
2502 obj = getHistogram(gr2d);
2503 else
2504 obj = nullptr;
2505 } else if (kind.compare("x") == 0) {
2506 obj = h1 ? h1->GetXaxis() : nullptr;
2507 } else if (kind.compare("y") == 0) {
2508 obj = h1 ? h1->GetYaxis() : nullptr;
2509 } else if (kind.compare("z") == 0) {
2510 obj = h1 ? h1->GetZaxis() : nullptr;
2511 } else if ((kind.compare(0,5,"func_") == 0) || (kind.compare(0,5,"indx_") == 0)) {
2512 auto funcname = kind.substr(5);
2513 TList *col = nullptr;
2514 if (h1)
2515 col = h1->GetListOfFunctions();
2516 else if (gr)
2517 col = gr->GetListOfFunctions();
2518 else if (mg)
2519 col = mg->GetListOfFunctions();
2520 else if (scatter->GetGraph())
2521 col = scatter->GetGraph()->GetListOfFunctions();
2522 if (!col)
2523 obj = nullptr;
2524 else if (kind.compare(0,5,"func_") == 0)
2525 obj = col->FindObject(funcname.c_str());
2526 else
2527 obj = col->At(std::stoi(funcname));
2528 } else if (kind.compare(0,7,"graphs_") == 0) {
2529 TList *graphs = mg ? mg->GetListOfGraphs() : nullptr;
2530 obj = graphs ? graphs->At(std::stoi(kind.substr(7))) : nullptr;
2531 } else if (kind.compare(0,6,"hists_") == 0) {
2532 TList *hists = hs ? hs->GetHists() : nullptr;
2533 obj = hists ? hists->At(std::stoi(kind.substr(6))) : nullptr;
2534 } else if (kind.compare(0,6,"stack_") == 0) {
2535 auto stack = hs ? hs->GetStack() : nullptr;
2536 obj = stack ? stack->At(std::stoi(kind.substr(6))) : nullptr;
2537 } else if (kind.compare(0,7,"member_") == 0) {
2538 auto member = kind.substr(7);
2539 auto offset = obj->IsA() ? obj->IsA()->GetDataMemberOffset(member.c_str()) : 0;
2540 obj = (offset > 0) ? *((TObject **)((char *) obj + offset)) : nullptr;
2541 } else {
2542 obj = nullptr;
2543 }
2544 }
2545
2546 if (!search_hist || obj)
2547 return obj;
2548 }
2549
2550 return nullptr;
2551}
2552
2553//////////////////////////////////////////////////////////////////////////////////////////////////
2554/// Static method to create TWebCanvas instance
2555/// Used by plugin manager
2556
2558{
2559 Bool_t readonly = gEnv->GetValue("WebGui.FullCanvas", (Int_t) 1) == 0;
2560
2561 auto imp = new TWebCanvas(c, name, x, y, width, height, readonly);
2562
2563 c->fWindowTopX = x;
2564 c->fWindowTopY = y;
2565 c->fWindowWidth = width;
2566 c->fWindowHeight = height;
2567 if (!gROOT->IsBatch() && (height > 25))
2568 height -= 25;
2569 c->fCw = width;
2570 c->fCh = height;
2571
2572 return imp;
2573}
@ 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:369
@ kMustCleanup
Definition TObject.h:370
Int_t gDebug
Definition TROOT.cxx:595
#define gROOT
Definition TROOT.h:406
R__EXTERN TStyle * gStyle
Definition TStyle.h:433
@ kReadPermission
Definition TSystem.h:47
R__EXTERN TSystem * gSystem
Definition TSystem.h:560
R__EXTERN TVirtualPS * gVirtualPS
Definition TVirtualPS.h:81
#define gPad
#define gVirtualX
Definition TVirtualX.h:338
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:1078
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:2610
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:747
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:74
TList * GetListOfFunctions() const
Definition TGraph.h:124
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:1402
1-D histogram with a double per channel (see TH1 documentation)}
Definition TH1.h:621
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:58
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:8808
TAxis * GetZaxis()
Definition TH1.h:325
static TClass * Class()
virtual Int_t GetDimension() const
Definition TH1.h:282
@ kNoTitle
Don't draw the histogram title.
Definition TH1.h:169
TAxis * GetXaxis()
Definition TH1.h:323
virtual void SetMaximum(Double_t maximum=-1111)
Definition TH1.h:401
TAxis * GetYaxis()
Definition TH1.h:324
virtual void SetMinimum(Double_t minimum=-1111)
Definition TH1.h:402
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:9093
virtual Double_t GetEntries() const
Return the current number of entries.
Definition TH1.cxx:4404
TList * GetListOfFunctions() const
Definition TH1.h:243
void SetName(const char *name) override
Change the name of this histogram.
Definition TH1.cxx:8831
virtual Int_t BufferEmpty(Int_t action=0)
Fill histogram with all entries in the buffer.
Definition TH1.cxx:1402
The Histogram stack class.
Definition THStack.h:38
TList * GetHists() const
Definition THStack.h:70
TObjArray * GetStack()
Return pointer to Stack. Build it if not yet done.
Definition THStack.cxx:595
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:578
void Add(TObject *obj) override
Definition TList.h:81
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition TList.cxx:822
void AddLast(TObject *obj) override
Add object at the end of the list.
Definition TList.cxx:152
TObject * Last() const override
Return the last object in the list. Returns 0 when list is empty.
Definition TList.cxx:693
virtual TObjLink * FirstLink() const
Definition TList.h:102
TObject * At(Int_t idx) const override
Returns the object at position idx. Returns 0 if idx is out of range.
Definition TList.cxx:357
void AddFirst(TObject *obj) override
Add object at the beginning of the list.
Definition TList.cxx:100
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:201
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:245
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:1245
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:6070
TVirtualViewer3D * GetViewer3D(Option_t *type="") override
Create/obtain handle to 3D viewer.
Definition TPad.cxx:7025
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:331
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:1153
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:2741
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:626
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
Definition TPad.h:420
TView * GetView() const override
Definition TPad.h:252
TClass * IsA() const override
Definition TPad.h:415
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:5906
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:2733
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:597
void Print(const char *filename="") const override
This method is equivalent to SaveAs("filename"). See TPad::SaveAs for details.
Definition TPad.cxx:4688
TFrame * GetFrame() override
Get frame.
Definition TPad.cxx:2859
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:351
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:80
virtual void ConvertNDCtoPad()
Convert pave coordinates from NDC to Pad coordinates.
Definition TPave.cxx:139
virtual void SetName(const char *name="")
Definition TPave.h:75
virtual void SetBorderSize(Int_t bordersize=4)
Definition TPave.h:73
virtual void SetY2NDC(Double_t y2)
Definition TPave.h:81
static TClass * Class()
virtual void SetX1NDC(Double_t x1)
Definition TPave.h:78
virtual void SetX2NDC(Double_t x2)
Definition TPave.h:79
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:419
const char * Data() const
Definition TString.h:378
@ kIgnoreCase
Definition TString.h:279
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition TString.cxx:924
void ToUpper()
Change string to upper case.
Definition TString.cxx:1183
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.
Definition TString.cxx:670
TString & Append(const char *cs)
Definition TString.h:574
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:2356
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:634
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:649
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:1261
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:1283
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition TSystem.cxx:424
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition TSystem.cxx:403
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)