Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TRootCanvas.cxx
Go to the documentation of this file.
1// @(#)root/gui:$Id: b4c21444ab4f787f65b2b44199fc0440c3c2ce81 $
2// Author: Fons Rademakers 15/01/98
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12
13/** \class TRootCanvas
14 \ingroup guiwidgets
15
16This class creates a main window with menubar, scrollbars and a
17drawing area. The widgets used are the new native ROOT GUI widgets.
18
19*/
20
21
22#include "RConfigure.h"
23
24#include "TRootCanvas.h"
25#include "TRootApplication.h"
26#include "TRootHelpDialog.h"
27#include "TGClient.h"
28#include "TGCanvas.h"
29#include "TGMenu.h"
30#include "TGWidget.h"
31#include "TGFileDialog.h"
32#include "TGStatusBar.h"
33#include "TGTextEditDialogs.h"
34#include "TROOT.h"
35#include "TClass.h"
36#include "TSystem.h"
37#include "TCanvas.h"
38#include "TBrowser.h"
39#include "TClassTree.h"
40#include "TMarker.h"
41#include "TStyle.h"
42#include "TColorWheel.h"
43#include "TVirtualX.h"
44#include "TApplication.h"
45#include "TFile.h"
46#include "TInterpreter.h"
47#include "TEnv.h"
48#include "TMath.h"
49#include <iostream>
50#include "TGDockableFrame.h"
51
52#include "TG3DLine.h"
53#include "TGToolBar.h"
54#include "TGToolTip.h"
55#include "TVirtualPadEditor.h"
56#include "TRootControlBar.h"
57#include "TGuiBuilder.h"
58#include "TImage.h"
59#include "TError.h"
60#include "TGDNDManager.h"
61#include "TBufferFile.h"
62#include "TRootBrowser.h"
63#include "TGTab.h"
64#include "TGedEditor.h"
65
66#include "TPluginManager.h"
67#include "TVirtualGL.h"
68
69#ifdef WIN32
70#include "TWin32SplashThread.h"
71#endif
72
73#include "HelpText.h"
74
75
76// Canvas menu command ids
93
102
113
125
132
140
158
160
161static const char *gOpenTypes[] = { "ROOT files", "*.root",
162 "All files", "*",
163 0, 0 };
164
165static const char *gSaveAsTypes[] = { "PDF", "*.pdf",
166 "PostScript", "*.ps",
167 "Encapsulated PostScript", "*.eps",
168 "SVG", "*.svg",
169 "TeX", "*.tex",
170 "GIF", "*.gif",
171 "ROOT macros", "*.C",
172 "ROOT files", "*.root",
173 "XML", "*.xml",
174 "PNG", "*.png",
175 "XPM", "*.xpm",
176 "JPEG", "*.jpg",
177 "TIFF", "*.tiff",
178 "XCF", "*.xcf",
179 "All files", "*",
180 0, 0 };
181
183 // { filename, tooltip, staydown, id, button}
184 { "newcanvas.xpm", "New", kFALSE, kFileNewCanvas, 0 },
185 { "open.xpm", "Open", kFALSE, kFileOpen, 0 },
186 { "save.xpm", "Save As", kFALSE, kFileSaveAs, 0 },
187 { "printer.xpm", "Print", kFALSE, kFilePrint, 0 },
188 { "", "", kFALSE, -1, 0 },
189 { "interrupt.xpm", "Interrupt", kFALSE, kOptionInterrupt,0 },
190 { "refresh2.xpm", "Refresh", kFALSE, kOptionRefresh, 0 },
191 { "", "", kFALSE, -1, 0 },
192 { "inspect.xpm", "Inspect", kFALSE, kInspectRoot, 0 },
193 { "browser.xpm", "Browser", kFALSE, kToolsBrowser, 0 },
194 { 0, 0, kFALSE, 0, 0 }
195};
196
198 { "pointer.xpm", "Modify", kFALSE, kToolModify, 0 },
199 { "arc.xpm", "Arc", kFALSE, kToolArc, 0 },
200 { "line.xpm", "Line", kFALSE, kToolLine, 0 },
201 { "arrow.xpm", "Arrow", kFALSE, kToolArrow, 0 },
202 { "diamond.xpm", "Diamond", kFALSE, kToolDiamond, 0 },
203 { "ellipse.xpm", "Ellipse", kFALSE, kToolEllipse, 0 },
204 { "pad.xpm", "Pad", kFALSE, kToolPad, 0 },
205 { "pave.xpm", "Pave", kFALSE, kToolPave, 0 },
206 { "pavelabel.xpm", "Pave Label", kFALSE, kToolPLabel, 0 },
207 { "pavetext.xpm", "Pave Text", kFALSE, kToolPText, 0 },
208 { "pavestext.xpm", "Paves Text", kFALSE, kToolPsText, 0 },
209 { "graph.xpm", "Graph", kFALSE, kToolGraph, 0 },
210 { "curlyline.xpm", "Curly Line", kFALSE, kToolCurlyLine, 0 },
211 { "curlyarc.xpm", "Curly Arc", kFALSE, kToolCurlyArc, 0 },
212 { "latex.xpm", "Text/Latex", kFALSE, kToolLatex, 0 },
213 { "marker.xpm", "Marker", kFALSE, kToolMarker, 0 },
214 { "cut.xpm", "Graphical Cut", kFALSE, kToolCutG, 0 },
215 { 0, 0, kFALSE, 0, 0 }
216};
217
218//////////////////////////////////////////////////////////////////////////
219// //
220// TRootContainer //
221// //
222// Utility class used by TRootCanvas. The TRootContainer is the frame //
223// embedded in the TGCanvas widget. The ROOT graphics goes into this //
224// frame. This class is used to enable input events on this graphics //
225// frame and forward the events to the TRootCanvas handlers. //
226// //
227//////////////////////////////////////////////////////////////////////////
228
230private:
231 TRootCanvas *fCanvas; // pointer back to canvas imp
232public:
233 TRootContainer(TRootCanvas *c, Window_t id, const TGWindow *parent);
234
235 Bool_t HandleButton(Event_t *ev) override;
237 { return fCanvas->HandleContainerDoubleClick(ev); }
240 return fCanvas->HandleContainerConfigure(ev); }
242 { return fCanvas->HandleContainerKey(ev); }
244 { return fCanvas->HandleContainerMotion(ev); }
246 { return fCanvas->HandleContainerExpose(ev); }
248 { return fCanvas->HandleContainerCrossing(ev); }
249 void SavePrimitive(std::ostream &out, Option_t * = "") override;
250 void SetEditable(Bool_t) override { }
251};
252
253////////////////////////////////////////////////////////////////////////////////
254/// Create a canvas container.
255
258{
259 fCanvas = c;
260
261 gVirtualX->GrabButton(fId, kAnyButton, kAnyModifier,
264
268}
269
270////////////////////////////////////////////////////////////////////////////////
271/// Directly handle scroll mouse buttons (4 and 5), only pass buttons
272/// 1, 2 and 3 on to the TCanvas.
273
275{
277 UInt_t page = vp->GetHeight()/4;
278 Int_t newpos;
279
280 gVirtualX->SetInputFocus(GetMainFrame()->GetId());
281
282 if (event->fCode == kButton4) {
283 //scroll up
284 newpos = fCanvas->fCanvasWindow->GetVsbPosition() - page;
285 if (newpos < 0) newpos = 0;
287// return kTRUE;
288 }
289 if (event->fCode == kButton5) {
290 // scroll down
291 newpos = fCanvas->fCanvasWindow->GetVsbPosition() + page;
293// return kTRUE;
294 }
295 return fCanvas->HandleContainerButton(event);
296}
297
299
300////////////////////////////////////////////////////////////////////////////////
301/// Create a basic ROOT canvas.
302
304 : TGMainFrame(gClient->GetRoot(), width, height), TCanvasImp(c)
305{
307
310
312}
313
314////////////////////////////////////////////////////////////////////////////////
315/// Create a basic ROOT canvas.
316
318 : TGMainFrame(gClient->GetRoot(), width, height), TCanvasImp(c)
319{
321
324
326 SetWMPosition(x, y);
327}
328
329////////////////////////////////////////////////////////////////////////////////
330/// Create the actual canvas.
331
333{
334 fButton = 0;
335 fAutoFit = kTRUE; // check also menu entry
336 fEditor = 0;
338
339 // Create menus
346
347 static Int_t img = 0;
348
349 if (!img) {
352 TImage* itmp = TImage::Create();
353 img = itmp ? 1 : -1;
354 if (itmp) {
355 delete itmp;
356 itmp=NULL;
357 }
358 gErrorIgnoreLevel = sav;
359 }
360 if (img > 0) {
363 }
364
367
369 fFileMenu->AddEntry("&New Canvas", kFileNewCanvas);
370 fFileMenu->AddEntry("&Open...", kFileOpen);
371 fFileMenu->AddEntry("&Close Canvas", kFileCloseCanvas);
374 fFileMenu->AddEntry("Save &As...", kFileSaveAs);
376 fFileMenu->AddEntry("&Print...", kFilePrint);
378 fFileMenu->AddEntry("&Quit ROOT", kFileQuit);
379
383
385 fEditMenu->AddEntry("&Style...", kEditStyle);
387 fEditMenu->AddEntry("Cu&t", kEditCut);
388 fEditMenu->AddEntry("&Copy", kEditCopy);
389 fEditMenu->AddEntry("&Paste", kEditPaste);
393 fEditMenu->AddEntry("&Undo", kEditUndo);
394 fEditMenu->AddEntry("&Redo", kEditRedo);
395
401
405
407 fViewMenu->AddEntry("&Editor", kViewEditor);
408 fViewMenu->AddEntry("&Toolbar", kViewToolbar);
409 fViewMenu->AddEntry("Event &Statusbar", kViewEventStatus);
410 fViewMenu->AddEntry("T&oolTip Info", kViewToolTips);
412 fViewMenu->AddEntry("&Colors", kViewColors);
413 fViewMenu->AddEntry("&Fonts", kViewFonts);
414 fViewMenu->AddEntry("&Markers", kViewMarkers);
416 fViewMenu->AddEntry("&Iconify", kViewIconify);
418 fViewMenu->AddPopup("&View With", fViewWithMenu);
419
421
423 fOptionMenu->AddEntry("&Auto Resize Canvas", kOptionAutoResize);
424 fOptionMenu->AddEntry("&Resize Canvas", kOptionResizeCanvas);
425 fOptionMenu->AddEntry("&Move Opaque", kOptionMoveOpaque);
426 fOptionMenu->AddEntry("Resize &Opaque", kOptionResizeOpaque);
428 fOptionMenu->AddEntry("&Interrupt", kOptionInterrupt);
429 fOptionMenu->AddEntry("R&efresh", kOptionRefresh);
431 fOptionMenu->AddEntry("&Pad Auto Exec", kOptionAutoExec);
433 fOptionMenu->AddEntry("&Statistics", kOptionStatistics);
434 fOptionMenu->AddEntry("Histogram &Title", kOptionHistTitle);
435 fOptionMenu->AddEntry("&Fit Parameters", kOptionFitParams);
436 fOptionMenu->AddEntry("Can Edit &Histograms", kOptionCanEdit);
437
438 // Opaque options initialized in InitWindow()
440 if (gStyle->GetOptStat())
442 if (gStyle->GetOptTitle())
444 if (gStyle->GetOptFit())
446 if (gROOT->GetEditHistograms())
448
450 fToolsMenu->AddEntry("&Inspect ROOT", kInspectRoot);
451 fToolsMenu->AddEntry("&Class Tree", kClassesTree);
452 fToolsMenu->AddEntry("&Fit Panel", kFitPanel);
453 fToolsMenu->AddEntry("&Start Browser", kToolsBrowser);
454 fToolsMenu->AddEntry("&Gui Builder", kToolsBuilder);
455 fToolsMenu->AddEntry("&Event Recorder", kToolsRecorder);
456
458 fHelpMenu->AddLabel("Basic Help On...");
460 fHelpMenu->AddEntry("&Canvas", kHelpOnCanvas);
461 fHelpMenu->AddEntry("&Menus", kHelpOnMenus);
462 fHelpMenu->AddEntry("&Graphics Editor", kHelpOnGraphicsEd);
463 fHelpMenu->AddEntry("&Browser", kHelpOnBrowser);
464 fHelpMenu->AddEntry("&Objects", kHelpOnObjects);
465 fHelpMenu->AddEntry("&PostScript", kHelpOnPS);
467 fHelpMenu->AddEntry("&About ROOT...", kHelpAbout);
468
469 // This main frame will process the menu commands
470 fFileMenu->Associate(this);
472 fEditMenu->Associate(this);
474 fViewMenu->Associate(this);
476 fOptionMenu->Associate(this);
477 fToolsMenu->Associate(this);
478 fHelpMenu->Associate(this);
479
480 // Create menubar layout hints
484
485 // Create menubar
486 fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame);
493
495
499
500 // Create toolbar dock
501 fToolDock = new TGDockableFrame(this);
505
506 // will allocate it later
507 fToolBar = 0;
508 fVertical1 = 0;
509 fVertical2 = 0;
512
516
517 fMainFrame = new TGCompositeFrame(this, GetWidth() + 4, GetHeight() + 4,
520
521 // Create editor frame that will host the pad editor
525
526 // Create canvas and canvas container that will host the ROOT graphics
529
530 fCanvasID = -1;
531
532 if (fCanvas->UseGL()) {
534 //first, initialize GL (if not yet)
535 if (!gGLManager) {
536 TString x = "win32";
537 if (gVirtualX->InheritsFrom("TGX11"))
538 x = "x11";
539 else if (gVirtualX->InheritsFrom("TGCocoa"))
540 x = "osx";
541
542 TPluginHandler *ph = gROOT->GetPluginManager()->FindHandler("TGLManager", x);
543
544 if (ph && ph->LoadPlugin() != -1) {
545 if (!ph->ExecPlugin(0))
546 Error("CreateCanvas", "GL manager plugin failed");
547 }
548 }
549
550 if (gGLManager) {
552 if (fCanvasID != -1) {
553 //Create gl context.
554 const Int_t glCtx = gGLManager->CreateGLContext(fCanvasID);
555 if (glCtx != -1) {
557 fCanvas->SetGLDevice(glCtx);//Now, fCanvas is responsible for context deletion!
558 } else
559 Error("CreateCanvas", "GL context creation failed.");
560 } else
561 Error("CreateCanvas", "GL window creation failed\n");
562 }
563 }
564
565 if (fCanvasID == -1)
567
568 Window_t win = gVirtualX->GetWindowID(fCanvasID);
572
575
576 // create the tooltip with a timeout of 250 ms
578
579 fCanvas->Connect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
580 "TRootCanvas", this,
581 "EventInfo(Int_t, Int_t, Int_t, TObject*)");
582
583 // Create status bar
584 int parts[] = { 33, 10, 10, 47 };
585 fStatusBar = new TGStatusBar(this, 10, 10);
586 fStatusBar->SetParts(parts, 4);
587
589
591
592 // Misc
595 fIconPic = SetIconPixmap("macro_s.xpm");
596 SetClassHints("ROOT", "Canvas");
597
600
601 // by default status bar, tool bar and pad editor are hidden
606
609
610 // we need to use GetDefaultSize() to initialize the layout algorithm...
612
613 gVirtualX->SetDNDAware(fId, fDNDTypeList);
615}
616
617////////////////////////////////////////////////////////////////////////////////
618/// Delete ROOT basic canvas. Order is significant. Delete in reverse
619/// order of creation.
620
622{
623 delete fToolTip;
624 if (fIconPic) gClient->FreePicture(fIconPic);
625 if (fEditor && !fEmbedded) delete fEditor;
626 if (fToolBar) {
627 Disconnect(fToolDock, "Docked()", this, "AdjustSize()");
628 Disconnect(fToolDock, "Undocked()", this, "AdjustSize()");
629 fToolBar->Cleanup();
630 delete fToolBar;
631 }
632
633 if (!MustCleanup()) {
634 delete fStatusBar;
635 delete fStatusBarLayout;
636 delete fCanvasContainer;
637 delete fCanvasWindow;
638
639 delete fEditorFrame;
640 delete fEditorLayout;
641 delete fMainFrame;
642 delete fMainFrameLayout;
643 delete fToolBarSep;
644 delete fToolDock;
645 delete fToolBarLayout;
646 delete fHorizontal1;
647 delete fHorizontal1Layout;
648
649 delete fMenuBar;
650 delete fMenuBarLayout;
651 delete fMenuBarItemLayout;
652 delete fMenuBarHelpLayout;
653 delete fCanvasLayout;
654 delete fDockLayout;
655 }
656
657 delete fFileMenu;
658 delete fFileSaveMenu;
659 delete fEditMenu;
660 delete fEditClearMenu;
661 delete fViewMenu;
662 delete fViewWithMenu;
663 delete fOptionMenu;
664 delete fToolsMenu;
665 delete fHelpMenu;
666}
667
668////////////////////////////////////////////////////////////////////////////////
669/// Called via TCanvasImp interface by TCanvas.
670
672{
674 if(gged && gged->GetCanvas() == fCanvas) {
675 if (fEmbedded) {
676 ((TGedEditor *)gged)->SetModel(0, 0, kButton1Down);
677 ((TGedEditor *)gged)->SetCanvas(0);
678 }
679 else gged->Hide();
680 }
681
682 gVirtualX->CloseWindow();
683}
684
685////////////////////////////////////////////////////////////////////////////////
686/// Really delete the canvas and this GUI.
687
689{
691 if(gged && gged->GetCanvas() == fCanvas) {
692 if (fEmbedded) {
693 ((TGedEditor *)gged)->SetModel(0, 0, kButton1Down);
694 ((TGedEditor *)gged)->SetCanvas(0);
695 }
696 else gged->Hide();
697 }
698
699 fToolTip->Hide();
700 Disconnect(fCanvas, "ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
701 this, "EventInfo(Int_t, Int_t, Int_t, TObject*)");
702
704 fCanvas->Clear();
705 fCanvas->SetName("");
706 if (gPad && gPad->GetCanvas() == fCanvas)
707 gPad = nullptr;
708 delete this;
709}
710
711////////////////////////////////////////////////////////////////////////////////
712/// In case window is closed via WM we get here.
713
715{
716 DeleteWindow();
717}
718
719////////////////////////////////////////////////////////////////////////////////
720/// Return width of canvas container.
721
723{
724 return fCanvasContainer->GetWidth();
725}
726
727////////////////////////////////////////////////////////////////////////////////
728/// Return height of canvas container.
729
731{
732 return fCanvasContainer->GetHeight();
733}
734
735////////////////////////////////////////////////////////////////////////////////
736/// Gets the size and position of the window containing the canvas. This
737/// size includes the menubar and borders.
738
740{
741 gVirtualX->GetWindowSize(fId, x, y, w, h);
742
743 Window_t childdum;
744 gVirtualX->TranslateCoordinates(fId, gClient->GetDefaultRoot()->GetId(),
745 0, 0, x, y, childdum);
746 if (!fCanvas->GetShowEditor()) return 0;
747 return fEditorFrame->GetWidth();
748}
749
750////////////////////////////////////////////////////////////////////////////////
751/// Set text in status bar.
752
753void TRootCanvas::SetStatusText(const char *txt, Int_t partidx)
754{
755 fStatusBar->SetText(txt, partidx);
756}
757
758////////////////////////////////////////////////////////////////////////////////
759/// Handle menu and other command generated by the user.
760
762{
763 TRootHelpDialog *hd;
764 TList *lc;
765
766 switch (GET_MSG(msg)) {
767
768 case kC_COMMAND:
769
770 switch (GET_SUBMSG(msg)) {
771
772 case kCM_BUTTON:
773 case kCM_MENU:
774
775 switch (parm1) {
776 // Handle toolbar items...
777 case kToolModify:
778 gROOT->SetEditorMode();
779 break;
780 case kToolArc:
781 gROOT->SetEditorMode("Arc");
782 break;
783 case kToolLine:
784 gROOT->SetEditorMode("Line");
785 break;
786 case kToolArrow:
787 gROOT->SetEditorMode("Arrow");
788 break;
789 case kToolDiamond:
790 gROOT->SetEditorMode("Diamond");
791 break;
792 case kToolEllipse:
793 gROOT->SetEditorMode("Ellipse");
794 break;
795 case kToolPad:
796 gROOT->SetEditorMode("Pad");
797 break;
798 case kToolPave:
799 gROOT->SetEditorMode("Pave");
800 break;
801 case kToolPLabel:
802 gROOT->SetEditorMode("PaveLabel");
803 break;
804 case kToolPText:
805 gROOT->SetEditorMode("PaveText");
806 break;
807 case kToolPsText:
808 gROOT->SetEditorMode("PavesText");
809 break;
810 case kToolGraph:
811 gROOT->SetEditorMode("PolyLine");
812 break;
813 case kToolCurlyLine:
814 gROOT->SetEditorMode("CurlyLine");
815 break;
816 case kToolCurlyArc:
817 gROOT->SetEditorMode("CurlyArc");
818 break;
819 case kToolLatex:
820 gROOT->SetEditorMode("Text");
821 break;
822 case kToolMarker:
823 gROOT->SetEditorMode("Marker");
824 break;
825 case kToolCutG:
826 gROOT->SetEditorMode("CutG");
827 break;
828
829 // Handle File menu items...
830 case kFileNewCanvas:
831 gROOT->MakeDefCanvas();
832 break;
833 case kFileOpen:
834 {
835 static TString dir(".");
836 TGFileInfo fi;
838 fi.SetIniDir(dir);
839 new TGFileDialog(fClient->GetDefaultRoot(), this, kFDOpen,&fi);
840 if (!fi.fFilename) return kTRUE;
841 dir = fi.fIniDir;
842 new TFile(fi.fFilename, "update");
843 }
844 break;
845 case kFileSaveAs:
846 {
847 TString workdir = gSystem->WorkingDirectory();
848 static TString dir(".");
849 static Int_t typeidx = 0;
850 static Bool_t overwr = kFALSE;
851 TGFileInfo fi;
852 TString defaultType = gEnv->GetValue("Canvas.SaveAsDefaultType", ".pdf");
853 if (typeidx == 0) {
854 for (int i=1;gSaveAsTypes[i];i+=2) {
855 TString ftype = gSaveAsTypes[i];
856 if (ftype.EndsWith(defaultType.Data())) {
857 typeidx = i-1;
858 break;
859 }
860 }
861 }
863 fi.SetIniDir(dir);
864 fi.fFileTypeIdx = typeidx;
865 fi.fOverwrite = overwr;
866 new TGFileDialog(fClient->GetDefaultRoot(), this, kFDSave, &fi);
867 gSystem->ChangeDirectory(workdir.Data());
868 if (!fi.fFilename) return kTRUE;
869 Bool_t appendedType = kFALSE;
870 TString fn = fi.fFilename;
871 TString ft = fi.fFileTypes[fi.fFileTypeIdx+1];
872 dir = fi.fIniDir;
873 typeidx = fi.fFileTypeIdx;
874 overwr = fi.fOverwrite;
875again:
876 if (fn.EndsWith(".root") ||
877 fn.EndsWith(".ps") ||
878 fn.EndsWith(".eps") ||
879 fn.EndsWith(".pdf") ||
880 fn.EndsWith(".svg") ||
881 fn.EndsWith(".tex") ||
882 fn.EndsWith(".gif") ||
883 fn.EndsWith(".xml") ||
884 fn.EndsWith(".xpm") ||
885 fn.EndsWith(".jpg") ||
886 fn.EndsWith(".png") ||
887 fn.EndsWith(".xcf") ||
888 fn.EndsWith(".tiff")) {
889 fCanvas->SaveAs(fn);
890 } else if (fn.EndsWith(".C"))
891 fCanvas->SaveSource(fn);
892 else {
893 if (!appendedType) {
894 if (ft.Index(".") != kNPOS) {
895 fn += ft(ft.Index("."), ft.Length());
896 appendedType = kTRUE;
897 goto again;
898 }
899 }
900 Warning("ProcessMessage", "file %s cannot be saved with this extension", fi.fFilename);
901 }
902 for (int i=1;gSaveAsTypes[i];i+=2) {
903 TString ftype = gSaveAsTypes[i];
904 ftype.ReplaceAll("*.", ".");
905 if (fn.EndsWith(ftype.Data())) {
906 typeidx = i-1;
907 break;
908 }
909 }
910 }
911 break;
912 case kFileSaveAsRoot:
913 fCanvas->SaveAs(".root");
914 break;
915 case kFileSaveAsC:
917 break;
918 case kFileSaveAsPS:
919 fCanvas->SaveAs();
920 break;
921 case kFileSaveAsEPS:
922 fCanvas->SaveAs(".eps");
923 break;
924 case kFileSaveAsPDF:
925 fCanvas->SaveAs(".pdf");
926 break;
927 case kFileSaveAsGIF:
928 fCanvas->SaveAs(".gif");
929 break;
930 case kFileSaveAsJPG:
931 fCanvas->SaveAs(".jpg");
932 break;
933 case kFileSaveAsPNG:
934 fCanvas->SaveAs(".png");
935 break;
936 case kFileSaveAsTEX:
937 fCanvas->SaveAs(".tex");
938 break;
939 case kFilePrint:
940 PrintCanvas();
941 break;
942 case kFileCloseCanvas:
944 break;
945 case kFileQuit:
946 if (!gApplication->ReturnFromRun()) {
950 }
953 if (TClass::GetClass("TStyleManager"))
954 gROOT->ProcessLine("TStyleManager::Terminate()");
956 break;
957
958 // Handle Edit menu items...
959 case kEditStyle:
960 if (!TClass::GetClass("TStyleManager"))
961 gSystem->Load("libGed");
962 gROOT->ProcessLine("TStyleManager::Show()");
963 break;
964 case kEditCut:
965 // still noop
966 break;
967 case kEditCopy:
968 // still noop
969 break;
970 case kEditPaste:
971 // still noop
972 break;
973 case kEditUndo:
974 // noop
975 break;
976 case kEditRedo:
977 // noop
978 break;
979 case kEditClearPad:
980 gPad->Clear();
981 gPad->Modified();
982 gPad->Update();
983 break;
984 case kEditClearCanvas:
985 fCanvas->Clear();
986 fCanvas->Modified();
987 fCanvas->Update();
988 break;
989
990 // Handle View menu items...
991 case kViewEditor:
993 break;
994 case kViewToolbar:
996 break;
997 case kViewEventStatus:
999 break;
1000 case kViewToolTips:
1002 break;
1003 case kViewColors:
1004 {
1005 TVirtualPad *padsav = gPad->GetCanvas();
1006 //This was the code with the old color table
1007 // TCanvas *m = new TCanvas("colors","Color Table");
1008 // TPad::DrawColorTable();
1009 // m->Update();
1010 TColorWheel *wheel = new TColorWheel();
1011 wheel->Draw();
1012
1013 //tp: with Cocoa, window is visible (and repainted)
1014 //before wheel->Draw() was called and you can see "empty"
1015 //canvas.
1016 gPad->Update();
1017 //
1018 if (padsav) padsav->cd();
1019 }
1020 break;
1021 case kViewFonts:
1022 // noop
1023 break;
1024 case kViewMarkers:
1025 {
1026 TVirtualPad *padsav = gPad ? gPad->GetCanvas() : nullptr;
1027 TCanvas *m = new TCanvas("markers","Marker Types",600,200);
1029 m->Update();
1030 if (padsav) padsav->cd();
1031 }
1032 break;
1033 case kViewIconify:
1034 Iconify();
1035 break;
1036 case kViewX3D:
1037 gPad->GetViewer3D("x3d");
1038 break;
1039 case kViewOpenGL:
1040 gPad->GetViewer3D("ogl");
1041 break;
1042
1043 // Handle Option menu items...
1044 case kOptionAutoExec:
1046 if (fCanvas->GetAutoExec()) {
1048 } else {
1050 }
1051 break;
1052 case kOptionAutoResize:
1053 {
1055 int opt = fCanvasContainer->GetOptions();
1056 if (fAutoFit) {
1057 opt &= ~kFixedSize;
1059 } else {
1060 opt |= kFixedSize;
1062 }
1064 // in case of autofit this will generate a configure
1065 // event for the container and this will force the
1066 // update of the TCanvas
1067 //Layout();
1068 }
1069 Layout();
1070 break;
1072 FitCanvas();
1073 break;
1074 case kOptionMoveOpaque:
1075 if (fCanvas->OpaqueMoving()) {
1076 fCanvas->MoveOpaque(0);
1078 } else {
1079 fCanvas->MoveOpaque(1);
1081 }
1082 break;
1084 if (fCanvas->OpaqueResizing()) {
1087 } else {
1090 }
1091 break;
1092 case kOptionInterrupt:
1093 gROOT->SetInterrupt();
1094 break;
1095 case kOptionRefresh:
1096 fCanvas->Paint();
1097 fCanvas->Update();
1098 break;
1099 case kOptionStatistics:
1100 if (gStyle->GetOptStat()) {
1101 gStyle->SetOptStat(0);
1102 delete gPad->FindObject("stats");
1104 } else {
1105 gStyle->SetOptStat(1);
1107 }
1108 gPad->Modified();
1109 fCanvas->Update();
1110 break;
1111 case kOptionHistTitle:
1112 if (gStyle->GetOptTitle()) {
1113 gStyle->SetOptTitle(0);
1114 delete gPad->FindObject("title");
1116 } else {
1117 gStyle->SetOptTitle(1);
1119 }
1120 gPad->Modified();
1121 fCanvas->Update();
1122 break;
1123 case kOptionFitParams:
1124 if (gStyle->GetOptFit()) {
1125 gStyle->SetOptFit(0);
1127 } else {
1128 gStyle->SetOptFit(1);
1130 }
1131 gPad->Modified();
1132 fCanvas->Update();
1133 break;
1134 case kOptionCanEdit:
1135 if (gROOT->GetEditHistograms()) {
1136 gROOT->SetEditHistograms(kFALSE);
1138 } else {
1139 gROOT->SetEditHistograms(kTRUE);
1141 }
1142 break;
1143
1144 // Handle Tools menu items...
1145 case kInspectRoot:
1146 fCanvas->cd();
1147 gROOT->Inspect();
1148 fCanvas->Update();
1149 break;
1150 case kToolsBrowser:
1151 new TBrowser("browser");
1152 break;
1153 case kToolsBuilder:
1155 break;
1156 case kToolsRecorder:
1157 gROOT->ProcessLine("new TGRecorder()");
1158 break;
1159
1160 // Handle Tools menu items...
1161 case kClassesTree:
1162 {
1163 TString cdef;
1164 lc = (TList*)gROOT->GetListOfCanvases();
1165 if (lc->FindObject("ClassTree")) {
1166 cdef = TString::Format("ClassTree_%d", lc->GetSize()+1);
1167 } else {
1168 cdef = "ClassTree";
1169 }
1170 new TClassTree(cdef.Data(), "TObject");
1171 fCanvas->Update();
1172 }
1173 break;
1174
1175 case kFitPanel:
1176 {
1177 // use plugin manager to create instance of TFitEditor
1178 TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TFitEditor");
1179 if (handler && handler->LoadPlugin() != -1) {
1180 if (handler->ExecPlugin(2, fCanvas, 0) == 0)
1181 Error("FitPanel", "Unable to crate the FitPanel");
1182 }
1183 else
1184 Error("FitPanel", "Unable to find the FitPanel plug-in");
1185 }
1186 break;
1187
1188 // Handle Help menu items...
1189 case kHelpAbout:
1190 {
1191#ifdef R__UNIX
1192 TString rootx = TROOT::GetBinDir() + "/root -a &";
1193 gSystem->Exec(rootx);
1194#else
1195#ifdef WIN32
1197#else
1198
1199 char str[32];
1200 sprintf(str, "About ROOT %s...", gROOT->GetVersion());
1201 hd = new TRootHelpDialog(this, str, 600, 400);
1202 hd->SetText(gHelpAbout);
1203 hd->Popup();
1204#endif
1205#endif
1206 }
1207 break;
1208 case kHelpOnCanvas:
1209 hd = new TRootHelpDialog(this, "Help on Canvas...", 600, 400);
1210 hd->SetText(gHelpCanvas);
1211 hd->Popup();
1212 break;
1213 case kHelpOnMenus:
1214 hd = new TRootHelpDialog(this, "Help on Menus...", 600, 400);
1216 hd->Popup();
1217 break;
1218 case kHelpOnGraphicsEd:
1219 hd = new TRootHelpDialog(this, "Help on Graphics Editor...", 600, 400);
1221 hd->Popup();
1222 break;
1223 case kHelpOnBrowser:
1224 hd = new TRootHelpDialog(this, "Help on Browser...", 600, 400);
1225 hd->SetText(gHelpBrowser);
1226 hd->Popup();
1227 break;
1228 case kHelpOnObjects:
1229 hd = new TRootHelpDialog(this, "Help on Objects...", 600, 400);
1230 hd->SetText(gHelpObjects);
1231 hd->Popup();
1232 break;
1233 case kHelpOnPS:
1234 hd = new TRootHelpDialog(this, "Help on PostScript...", 600, 400);
1236 hd->Popup();
1237 break;
1238 }
1239 default:
1240 break;
1241 }
1242 default:
1243 break;
1244 }
1245 return kTRUE;
1246}
1247
1248////////////////////////////////////////////////////////////////////////////////
1249/// Called by TCanvas ctor to get window indetifier.
1250
1252{
1253 if (fCanvas->OpaqueMoving())
1255 if (fCanvas->OpaqueResizing())
1257
1258 return fCanvasID;
1259}
1260
1261////////////////////////////////////////////////////////////////////////////////
1262/// Set size of canvas container. Units in pixels.
1263/// If w==0 and h==0, set autofit mode
1264
1266{
1267 // turn off autofit, we want to stay at the given size
1268 int opt = fCanvasContainer->GetOptions();
1269 if (!w && !h) {
1270 fAutoFit = kTRUE;
1272 opt &= ~kFixedSize; // turn off fixed size mode
1273 } else {
1274 fAutoFit = kFALSE;
1276 opt |= kFixedSize; // turn on fixed size mode
1277 }
1281 Layout(); // force layout (will update container to given size)
1282 fCanvas->Resize();
1283 fCanvas->Update();
1284}
1285
1286////////////////////////////////////////////////////////////////////////////////
1287/// Set canvas position (units in pixels).
1288
1290{
1291 Move(x, y);
1292}
1293
1294////////////////////////////////////////////////////////////////////////////////
1295/// Set size of canvas (units in pixels).
1296
1298{
1299 Resize(w, h);
1300
1301 // Make sure the change of size is really done.
1302 gVirtualX->Update(1);
1303 if (!gThreadXAR) {
1304 gSystem->Sleep(100);
1306 gSystem->Sleep(10);
1308 }
1309}
1310
1311////////////////////////////////////////////////////////////////////////////////
1312/// Put canvas window on top of the window stack.
1313
1315{
1316 gVirtualX->RaiseWindow(GetId());
1317}
1318
1319////////////////////////////////////////////////////////////////////////////////
1320/// Change title on window.
1321
1322void TRootCanvas::SetWindowTitle(const char *title)
1323{
1324 SetWindowName(title);
1325 SetIconName(title);
1326 fToolDock->SetWindowName(Form("ToolBar: %s", title));
1327}
1328
1329////////////////////////////////////////////////////////////////////////////////
1330/// Fit canvas container to current window size.
1331
1333{
1334 if (!fAutoFit) {
1335 int opt = fCanvasContainer->GetOptions();
1336 int oopt = opt;
1337 opt &= ~kFixedSize; // turn off fixed size mode
1339 Layout(); // force layout
1340 fCanvas->Resize();
1341 fCanvas->Update();
1343 }
1344}
1345
1346////////////////////////////////////////////////////////////////////////////////
1347/// Print the canvas.
1348
1350{
1351 Int_t ret = 0;
1352 Bool_t pname = kTRUE;
1353 char *printer, *printCmd;
1354 static TString sprinter, sprintCmd;
1355
1356 if (sprinter == "")
1357 printer = StrDup(gEnv->GetValue("Print.Printer", ""));
1358 else
1359 printer = StrDup(sprinter);
1360 if (sprintCmd == "")
1361#ifndef WIN32
1362 printCmd = StrDup(gEnv->GetValue("Print.Command", ""));
1363#else
1364 printCmd = StrDup(gEnv->GetValue("Print.Command", "start AcroRd32.exe /p"));
1365#endif
1366 else
1367 printCmd = StrDup(sprintCmd);
1368
1369 new TGPrintDialog(fClient->GetDefaultRoot(), this, 400, 150,
1370 &printer, &printCmd, &ret);
1371 if (ret) {
1372 sprinter = printer;
1373 sprintCmd = printCmd;
1374
1375 if (sprinter == "")
1376 pname = kFALSE;
1377
1378 TString fn = "rootprint";
1379 FILE *f = gSystem->TempFileName(fn, gEnv->GetValue("Print.Directory", gSystem->TempDirectory()));
1380 if (f) fclose(f);
1381 fn += TString::Format(".%s",gEnv->GetValue("Print.FileType", "pdf"));
1382 fCanvas->Print(fn);
1383
1384 TString cmd = sprintCmd;
1385 if (cmd.Contains("%p"))
1386 cmd.ReplaceAll("%p", sprinter);
1387 else if (pname) {
1388 cmd += " "; cmd += sprinter; cmd += " ";
1389 }
1390
1391 if (cmd.Contains("%f"))
1392 cmd.ReplaceAll("%f", fn);
1393 else {
1394 cmd += " "; cmd += fn; cmd += " ";
1395 }
1396
1397 gSystem->Exec(cmd);
1398#ifndef WIN32
1399 gSystem->Unlink(fn);
1400#endif
1401 }
1402 delete [] printer;
1403 delete [] printCmd;
1404}
1405
1406////////////////////////////////////////////////////////////////////////////////
1407/// Display a tooltip with infos about the primitive below the cursor.
1408
1409void TRootCanvas::EventInfo(Int_t event, Int_t px, Int_t py, TObject *selected)
1410{
1411 fToolTip->Hide();
1412 if (!fCanvas->GetShowToolTips() || selected == 0 ||
1413 event != kMouseMotion || fButton != 0)
1414 return;
1415 TString tipInfo;
1416 TString objInfo = selected->GetObjectInfo(px, py);
1417 if (objInfo.BeginsWith("-")) {
1418 // if the string begins with '-', display only the object info
1419 objInfo.Remove(TString::kLeading, '-');
1420 tipInfo = objInfo;
1421 }
1422 else {
1423 const char *title = selected->GetTitle();
1424 tipInfo += TString::Format("%s::%s", selected->ClassName(),
1425 selected->GetName());
1426 if (title && strlen(title))
1427 tipInfo += TString::Format("\n%s", selected->GetTitle());
1428 tipInfo += TString::Format("\n%d, %d", px, py);
1429 if (!objInfo.IsNull())
1430 tipInfo += TString::Format("\n%s", objInfo.Data());
1431 }
1432 fToolTip->SetText(tipInfo.Data());
1433 fToolTip->SetPosition(px+15, py+15);
1434 fToolTip->Reset();
1435}
1436
1437////////////////////////////////////////////////////////////////////////////////
1438/// Show or hide menubar.
1439
1441{
1442 if (show) ShowFrame(fMenuBar);
1443 else HideFrame(fMenuBar);
1444}
1445
1446////////////////////////////////////////////////////////////////////////////////
1447/// Show or hide statusbar.
1448
1450{
1453
1454 UInt_t h = GetHeight();
1455 UInt_t sh = fStatusBar->GetHeight()+2;
1456
1457 if (show) {
1460 if (dh - ch >= sh) h = h + sh;
1461 else h = ch;
1462 } else {
1465 if (dh - ch < sh) h = ch;
1466 else h = h - sh;
1467 }
1468 Resize(GetWidth(), h);
1469}
1470
1471////////////////////////////////////////////////////////////////////////////////
1472/// Show or hide side frame.
1473
1475{
1477
1478 UInt_t w = GetWidth();
1480 UInt_t h = GetHeight();
1482
1483 auto lambda_show = [&, this]() {
1484 if (show) {
1485 if (!fEditor)
1486 CreateEditor();
1488 if (gged && gged->GetCanvas() == fCanvas) {
1489 gged->Hide();
1490 }
1493 h += s;
1494 }
1496 fEditor->Show();
1498 w += e;
1499 } else {
1502 h -= s;
1503 }
1504 if (fEditor)
1505 fEditor->Hide();
1508 w -= e;
1509 }
1510 };
1511
1512 if (fParent && fParent != fClient->GetDefaultRoot()) {
1515 if (main && main->InheritsFrom("TRootBrowser")) {
1516 TRootBrowser *browser = (TRootBrowser *)main;
1517 if (!fEmbedded)
1518 browser->GetTabRight()->Connect("Selected(Int_t)", "TRootCanvas",
1519 this, "Activated(Int_t)");
1520 fEmbedded = kTRUE;
1521 if (show && (!fEditor || !((TGedEditor *)fEditor)->IsMapped())) {
1522 if (!browser->GetTabLeft()->GetTabTab("Pad Editor")) {
1523 if (browser->GetActFrame()) { //already in edit mode
1524 TTimer::SingleShot(200, "TRootCanvas", this, "ShowEditor(=kTRUE)");
1525 } else {
1527 if (!fEditor)
1529 else {
1530 ((TGedEditor *)fEditor)->ReparentWindow(fClient->GetRoot());
1531 ((TGedEditor *)fEditor)->MapWindow();
1532 }
1533 browser->StopEmbedding("Pad Editor");
1534 if (fEditor) {
1536 gROOT->GetListOfCleanups()->Remove((TGedEditor *)fEditor);
1537 ((TGedEditor *)fEditor)->SetCanvas(fCanvas);
1538 ((TGedEditor *)fEditor)->SetModel(fCanvas, fCanvas, kButton1Down);
1539 }
1540 }
1541 }
1542 else
1544 }
1545 if (show) browser->GetTabLeft()->SetTab("Pad Editor");
1546 } else {
1547 lambda_show();
1548 main->Layout();
1549 }
1550 }
1551 else {
1552 lambda_show();
1553 Resize(w, h);
1554 }
1555}
1556
1557////////////////////////////////////////////////////////////////////////////////
1558/// Create embedded editor.
1559
1561{
1564 gPad = Canvas();
1565 // next two lines are related to the old editor
1566 Int_t show = gEnv->GetValue("Canvas.ShowEditor", 0);
1567 gEnv->SetValue("Canvas.ShowEditor","true");
1572
1573 // next line is related to the old editor
1574 if (show == 0) gEnv->SetValue("Canvas.ShowEditor","false");
1575}
1576
1577////////////////////////////////////////////////////////////////////////////////
1578/// Show or hide toolbar.
1579
1581{
1582 if (show && !fToolBar) {
1583
1586
1587 Int_t spacing = 6, i;
1588 for (i = 0; gToolBarData[i].fPixmap; i++) {
1589 if (strlen(gToolBarData[i].fPixmap) == 0) {
1590 spacing = 6;
1591 continue;
1592 }
1593 fToolBar->AddButton(this, &gToolBarData[i], spacing);
1594 spacing = 0;
1595 }
1602
1603 spacing = 6;
1604 for (i = 0; gToolBarData1[i].fPixmap; i++) {
1605 if (strlen(gToolBarData1[i].fPixmap) == 0) {
1606 spacing = 6;
1607 continue;
1608 }
1609 fToolBar->AddButton(this, &gToolBarData1[i], spacing);
1610 spacing = 0;
1611 }
1613 fToolDock->Layout();
1614 fToolDock->SetWindowName(Form("ToolBar: %s", GetWindowName()));
1615 fToolDock->Connect("Docked()", "TRootCanvas", this, "AdjustSize()");
1616 fToolDock->Connect("Undocked()", "TRootCanvas", this, "AdjustSize()");
1617 }
1618
1619 if (!fToolBar) return;
1620
1621 UInt_t h = GetHeight();
1623 UInt_t dh = fToolBar->GetHeight();
1624
1625 if (show) {
1629 h = h + sh;
1630 }
1633 h = h + dh + sh;
1634 } else {
1635 if (fToolDock->IsUndocked()) {
1637 h = h + 2*sh;
1638 } else h = h - dh;
1639
1643 h = h - sh;
1644 }
1646 h = h - sh;
1648 }
1649 Resize(GetWidth(), h);
1650}
1651
1652////////////////////////////////////////////////////////////////////////////////
1653/// Enable or disable tooltip info.
1654
1656{
1657 if (show)
1659 else
1661}
1662
1663////////////////////////////////////////////////////////////////////////////////
1664/// Returns kTRUE if the editor is shown.
1665
1667{
1669}
1670
1671////////////////////////////////////////////////////////////////////////////////
1672/// Returns kTRUE if the menu bar is shown.
1673
1675{
1676 return (fMenuBar) && fMenuBar->IsMapped();
1677}
1678
1679////////////////////////////////////////////////////////////////////////////////
1680/// Returns kTRUE if the status bar is shown.
1681
1683{
1684 return (fStatusBar) && fStatusBar->IsMapped();
1685}
1686
1687////////////////////////////////////////////////////////////////////////////////
1688/// Returns kTRUE if the tool bar is shown.
1689
1691{
1692 return (fToolBar) && fToolBar->IsMapped();
1693}
1694
1695////////////////////////////////////////////////////////////////////////////////
1696/// Returns kTRUE if the tooltips are enabled.
1697
1699{
1700 return (fCanvas) && fCanvas->GetShowToolTips();
1701}
1702
1703////////////////////////////////////////////////////////////////////////////////
1704/// Keep the same canvas size while docking/undocking toolbar.
1705
1707{
1708 UInt_t h = GetHeight();
1709 UInt_t dh = fToolBar->GetHeight();
1711
1712 if (fToolDock->IsUndocked()) {
1715 h = h - sh;
1716 }
1718 h = h - dh - sh;
1719 } else {
1722 h = h + sh;
1723 }
1725 h = h + dh + sh;
1726 }
1727 Resize(GetWidth(), h);
1728}
1729
1730////////////////////////////////////////////////////////////////////////////////
1731/// Handle mouse button events in the canvas container.
1732
1734{
1735 Int_t button = event->fCode;
1736 Int_t x = event->fX;
1737 Int_t y = event->fY;
1738
1739 if (event->fType == kButtonPress) {
1740 if (fToolTip && fCanvas->GetShowToolTips()) {
1741 fToolTip->Hide();
1742 gVirtualX->UpdateWindow(0);
1744 }
1745 fButton = button;
1746 if (button == kButton1) {
1747 if (event->fState & kKeyShiftMask)
1749 else
1751 }
1752 if (button == kButton2)
1754 if (button == kButton3) {
1756 fButton = 0; // button up is consumed by TContextMenu
1757 }
1758
1759 } else if (event->fType == kButtonRelease) {
1760 if (button == kButton4)
1762 if (button == kButton5)
1764 if (button == kButton1)
1766 if (button == kButton2)
1768 if (button == kButton3)
1770
1771 fButton = 0;
1772 }
1773
1774 return kTRUE;
1775}
1776
1777////////////////////////////////////////////////////////////////////////////////
1778/// Handle mouse button double click events in the canvas container.
1779
1781{
1782 Int_t button = event->fCode;
1783 Int_t x = event->fX;
1784 Int_t y = event->fY;
1785
1786 if (button == kButton1)
1788 if (button == kButton2)
1790 if (button == kButton3)
1792
1793 return kTRUE;
1794}
1795
1796////////////////////////////////////////////////////////////////////////////////
1797/// Handle configure (i.e. resize) event.
1798
1800{
1801 if (fAutoFit) {
1802 fCanvas->Resize();
1803 fCanvas->Update();
1804 }
1805
1807 // get menu height
1808 static Int_t dh = 0;
1809 if (!dh)
1812 fCanvas->GetAspectRatio()) + dh;
1814 }
1815 return kTRUE;
1816}
1817
1818////////////////////////////////////////////////////////////////////////////////
1819/// Handle keyboard events in the canvas container.
1820
1822{
1823 static EGEventType previous_event = kOtherEvent;
1824 static UInt_t previous_keysym = 0;
1825
1826 if (event->fType == kGKeyPress) {
1827 fButton = event->fCode;
1828 UInt_t keysym;
1829 char str[2];
1830 gVirtualX->LookupString(event, str, sizeof(str), keysym);
1831
1832 if (str[0] == kESC){ // ESC sets the escape flag
1833 gROOT->SetEscape();
1836 gPad->Modified();
1837 return kTRUE;
1838 }
1839 if (str[0] == 3) // ctrl-c sets the interrupt flag
1840 gROOT->SetInterrupt();
1841
1842 // handle arrow keys
1843 if (keysym > 0x1011 && keysym < 0x1016) {
1844 Window_t dum1, dum2, wid;
1845 UInt_t mask = 0;
1846 Int_t mx, my, tx, ty;
1847 wid = gVirtualX->GetDefaultRootWindow();
1848 gVirtualX->QueryPointer(wid, dum1, dum2, mx, my, mx, my, mask);
1849 gVirtualX->TranslateCoordinates(gClient->GetDefaultRoot()->GetId(),
1851 mx, my, tx, ty, dum1);
1853 // handle case where we got consecutive same keypressed events coming
1854 // from auto-repeat on Windows (as it fires only successive keydown events)
1855 if ((previous_keysym == keysym) && (previous_event == kGKeyPress)) {
1856 switch (keysym) {
1857 case 0x1012: // left
1858 gVirtualX->Warp(--mx, my, wid); --tx;
1859 break;
1860 case 0x1013: // up
1861 gVirtualX->Warp(mx, --my, wid); --ty;
1862 break;
1863 case 0x1014: // right
1864 gVirtualX->Warp(++mx, my, wid); ++tx;
1865 break;
1866 case 0x1015: // down
1867 gVirtualX->Warp(mx, ++my, wid); ++ty;
1868 break;
1869 default:
1870 break;
1871 }
1873 }
1874 previous_keysym = keysym;
1875 }
1876 else {
1877 fCanvas->HandleInput(kKeyPress, str[0], keysym);
1878 }
1879 } else if (event->fType == kKeyRelease) {
1880 UInt_t keysym;
1881 char str[2];
1882 gVirtualX->LookupString(event, str, sizeof(str), keysym);
1883
1884 if (keysym > 0x1011 && keysym < 0x1016) {
1885 Window_t dum1, dum2, wid;
1886 UInt_t mask = 0;
1887 Int_t mx, my, tx, ty;
1888 wid = gVirtualX->GetDefaultRootWindow();
1889 gVirtualX->QueryPointer(wid, dum1, dum2, mx, my, mx, my, mask);
1890 switch (keysym) {
1891 case 0x1012: // left
1892 gVirtualX->Warp(--mx, my, wid);
1893 break;
1894 case 0x1013: // up
1895 gVirtualX->Warp(mx, --my, wid);
1896 break;
1897 case 0x1014: // right
1898 gVirtualX->Warp(++mx, my, wid);
1899 break;
1900 case 0x1015: // down
1901 gVirtualX->Warp(mx, ++my, wid);
1902 break;
1903 default:
1904 break;
1905 }
1906 gVirtualX->TranslateCoordinates(gClient->GetDefaultRoot()->GetId(),
1908 mx, my, tx, ty, dum1);
1910 previous_keysym = keysym;
1911 }
1912 fButton = 0;
1913 }
1914 previous_event = event->fType;
1915 return kTRUE;
1916}
1917
1918////////////////////////////////////////////////////////////////////////////////
1919/// Handle mouse motion event in the canvas container.
1920
1922{
1923 Int_t x = event->fX;
1924 Int_t y = event->fY;
1925
1926 if (fButton == 0)
1928 if (fButton == kButton1) {
1929 if (event->fState & kKeyShiftMask)
1931 else
1933 }
1934 if (fButton == kButton2)
1936
1937 return kTRUE;
1938}
1939
1940////////////////////////////////////////////////////////////////////////////////
1941/// Handle expose events.
1942
1944{
1945 if (event->fCount == 0) {
1946 fCanvas->Flush();
1947 }
1948
1949 return kTRUE;
1950}
1951
1952////////////////////////////////////////////////////////////////////////////////
1953/// Handle enter/leave events. Only leave is activated at the moment.
1954
1956{
1957 Int_t x = event->fX;
1958 Int_t y = event->fY;
1959
1960 // pointer grabs create also an enter and leave event but with fCode
1961 // either kNotifyGrab or kNotifyUngrab, don't propagate these events
1962 if (event->fType == kLeaveNotify && event->fCode == kNotifyNormal)
1964
1965 return kTRUE;
1966}
1967
1968////////////////////////////////////////////////////////////////////////////////
1969/// Handle drop events.
1970
1972{
1973 static Atom_t rootObj = gVirtualX->InternAtom("application/root", kFALSE);
1974 static Atom_t uriObj = gVirtualX->InternAtom("text/uri-list", kFALSE);
1975
1976 if (data->fDataType == rootObj) {
1977 TBufferFile buf(TBuffer::kRead, data->fDataLength, (void *)data->fData);
1978 buf.SetReadMode();
1980 if (!obj) return kTRUE;
1981 gPad->Clear();
1982 if (obj->InheritsFrom("TKey")) {
1983 TObject *object = (TObject *)gROOT->ProcessLine(Form("((TKey *)0x%zx)->ReadObj();", (size_t)obj));
1984 if (!object) return kTRUE;
1985 if (object->InheritsFrom("TGraph"))
1986 object->Draw("ALP");
1987 else if (object->InheritsFrom("TImage"))
1988 object->Draw("x");
1989 else if (object->IsA()->GetMethodAllAny("Draw"))
1990 object->Draw();
1991 }
1992 else if (obj->InheritsFrom("TGraph"))
1993 obj->Draw("ALP");
1994 else if (obj->IsA()->GetMethodAllAny("Draw"))
1995 obj->Draw();
1996 gPad->Modified();
1997 gPad->Update();
1998 return kTRUE;
1999 }
2000 else if (data->fDataType == uriObj) {
2001 TString sfname((char *)data->fData);
2002 if (sfname.Length() > 7) {
2003 sfname.ReplaceAll("\r\n", "");
2004 TUrl uri(sfname.Data());
2005 if (sfname.EndsWith(".bmp") ||
2006 sfname.EndsWith(".gif") ||
2007 sfname.EndsWith(".jpg") ||
2008 sfname.EndsWith(".png") ||
2009 sfname.EndsWith(".ps") ||
2010 sfname.EndsWith(".eps") ||
2011 sfname.EndsWith(".pdf") ||
2012 sfname.EndsWith(".tiff") ||
2013 sfname.EndsWith(".xpm")) {
2014 TImage *img = TImage::Open(uri.GetFile());
2015 if (img) {
2016 img->Draw("x");
2017 img->SetEditable(kTRUE);
2018 }
2019 }
2020 gPad->Modified();
2021 gPad->Update();
2022 }
2023 }
2024 return kFALSE;
2025}
2026
2027////////////////////////////////////////////////////////////////////////////////
2028/// Handle dragging position events.
2029
2031 Int_t /*xroot*/, Int_t /*yroot*/)
2032{
2033 TPad *pad = fCanvas->Pick(x, y, 0);
2034 if (pad) {
2035 pad->cd();
2036 gROOT->SetSelectedPad(pad);
2037 // make sure the pad is highlighted (on Windows)
2038 pad->Update();
2039 }
2040 return action;
2041}
2042
2043////////////////////////////////////////////////////////////////////////////////
2044/// Handle drag enter events.
2045
2047{
2048 static Atom_t rootObj = gVirtualX->InternAtom("application/root", kFALSE);
2049 static Atom_t uriObj = gVirtualX->InternAtom("text/uri-list", kFALSE);
2050 Atom_t ret = kNone;
2051 for (int i = 0; typelist[i] != kNone; ++i) {
2052 if (typelist[i] == rootObj)
2053 ret = rootObj;
2054 if (typelist[i] == uriObj)
2055 ret = uriObj;
2056 }
2057 return ret;
2058}
2059
2060////////////////////////////////////////////////////////////////////////////////
2061/// Handle drag leave events.
2062
2064{
2065 return kTRUE;
2066}
2067
2068////////////////////////////////////////////////////////////////////////////////
2069/// Slot handling tab switching in the browser, to properly set the canvas
2070/// and the model to the editor.
2071
2073{
2074 if (fEmbedded) {
2075 TGTab *sender = (TGTab *)gTQSender;
2076 if (sender) {
2077 TGCompositeFrame *cont = sender->GetTabContainer(id);
2078 if (cont == fParent) {
2079 if (!fEditor)
2081 if (fEditor && ((TGedEditor *)fEditor)->IsMapped()) {
2082 ((TGedEditor *)fEditor)->SetCanvas(fCanvas);
2083 ((TGedEditor *)fEditor)->SetModel(fCanvas, fCanvas, kButton1Down);
2084 }
2085 }
2086 }
2087 }
2088}
2089
2090////////////////////////////////////////////////////////////////////////////////
2091/// Save a canvas container as a C++ statement(s) on output stream out.
2092
2093void TRootContainer::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
2094{
2095 out << std::endl << " // canvas container" << std::endl;
2096 out << " Int_t canvasID = gVirtualX->InitWindow((ULongptr_t)"
2097 << GetParent()->GetParent()->GetName() << "->GetId());" << std::endl;
2098 out << " Window_t winC = gVirtualX->GetWindowID(canvasID);" << std::endl;
2099 out << " TGCompositeFrame *";
2100 out << GetName() << " = new TGCompositeFrame(gClient,winC"
2101 << "," << GetParent()->GetName() << ");" << std::endl;
2102}
EEventType
Definition Buttons.h:15
@ kMouseMotion
Definition Buttons.h:23
@ kWheelUp
Definition Buttons.h:18
@ kButton3Up
Definition Buttons.h:19
@ kButton2Motion
Definition Buttons.h:20
@ kButton3Down
Definition Buttons.h:17
@ kButton2Down
Definition Buttons.h:17
@ kKeyPress
Definition Buttons.h:20
@ kButton2Double
Definition Buttons.h:24
@ kArrowKeyRelease
Definition Buttons.h:21
@ kButton1Double
Definition Buttons.h:24
@ kButton3Double
Definition Buttons.h:24
@ kButton1Shift
Definition Buttons.h:18
@ kButton1Motion
Definition Buttons.h:20
@ kButton1Up
Definition Buttons.h:19
@ kWheelDown
Definition Buttons.h:18
@ kArrowKeyPress
Definition Buttons.h:21
@ kButton2Up
Definition Buttons.h:19
@ kMouseLeave
Definition Buttons.h:23
@ kButton1Down
Definition Buttons.h:17
@ kESC
Definition Buttons.h:22
Handle_t Atom_t
WM token.
Definition GuiTypes.h:37
EGEventType
Definition GuiTypes.h:59
@ kGKeyPress
Definition GuiTypes.h:60
@ kButtonRelease
Definition GuiTypes.h:60
@ kButtonPress
Definition GuiTypes.h:60
@ kOtherEvent
Definition GuiTypes.h:64
@ kKeyRelease
Definition GuiTypes.h:60
@ kLeaveNotify
Definition GuiTypes.h:61
const Mask_t kButtonPressMask
Definition GuiTypes.h:161
@ kNotifyNormal
Definition GuiTypes.h:219
const Mask_t kExposureMask
Definition GuiTypes.h:165
Handle_t Window_t
Window handle.
Definition GuiTypes.h:29
const Mask_t kKeyReleaseMask
Definition GuiTypes.h:160
const Mask_t kAnyModifier
Definition GuiTypes.h:210
const Mask_t kKeyPressMask
Definition GuiTypes.h:159
const Mask_t kPointerMotionMask
Definition GuiTypes.h:163
const Mask_t kKeyShiftMask
Definition GuiTypes.h:195
@ kSunkenFrame
Definition GuiTypes.h:383
@ kDoubleBorder
Definition GuiTypes.h:385
@ kFixedWidth
Definition GuiTypes.h:387
@ kHorizontalFrame
Definition GuiTypes.h:382
@ kFixedSize
Definition GuiTypes.h:390
const Handle_t kNone
Definition GuiTypes.h:88
const Mask_t kLeaveWindowMask
Definition GuiTypes.h:168
const Mask_t kStructureNotifyMask
Definition GuiTypes.h:166
const Mask_t kButtonReleaseMask
Definition GuiTypes.h:162
@ kButton4
Definition GuiTypes.h:215
@ kButton2
Definition GuiTypes.h:214
@ kButton5
Definition GuiTypes.h:215
@ kButton3
Definition GuiTypes.h:214
@ kButton1
Definition GuiTypes.h:214
@ kAnyButton
Definition GuiTypes.h:214
R__EXTERN const char gHelpObjects[]
Definition HelpText.h:26
R__EXTERN const char gHelpPullDownMenus[]
Definition HelpText.h:24
R__EXTERN const char gHelpAbout[]
Definition HelpText.h:17
R__EXTERN const char gHelpGraphicsEditor[]
Definition HelpText.h:23
R__EXTERN const char gHelpCanvas[]
Definition HelpText.h:25
R__EXTERN const char gHelpBrowser[]
Definition HelpText.h:18
R__EXTERN const char gHelpPostscript[]
Definition HelpText.h:21
int main()
Definition Prototype.cxx:12
#define f(i)
Definition RSha256.hxx:104
#define c(i)
Definition RSha256.hxx:101
#define h(i)
Definition RSha256.hxx:106
#define e(i)
Definition RSha256.hxx:103
long Longptr_t
Definition RtypesCore.h:82
unsigned long ULongptr_t
Definition RtypesCore.h:83
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
constexpr Ssiz_t kNPOS
Definition RtypesCore.h:124
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:377
R__EXTERN TApplication * gApplication
R__EXTERN TEnv * gEnv
Definition TEnv.h:170
constexpr Int_t kFatal
Definition TError.h:49
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:185
Int_t gErrorIgnoreLevel
Error handling routines.
Definition TError.cxx:31
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:229
#define gClient
Definition TGClient.h:157
@ kFDOpen
@ kFDSave
@ kLHintsRight
Definition TGLayout.h:26
@ kLHintsExpandY
Definition TGLayout.h:31
@ kLHintsLeft
Definition TGLayout.h:24
@ kLHintsBottom
Definition TGLayout.h:29
@ kLHintsTop
Definition TGLayout.h:27
@ kLHintsExpandX
Definition TGLayout.h:30
winID h TVirtualViewer3D TVirtualGLPainter p
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 mask
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void SetIconPixmap
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize wid
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 id
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 win
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void SetWMPosition
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 Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t Atom_t typelist
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 height
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t button
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 mx
char name[80]
Definition TGX11.cxx:110
R__EXTERN void * gTQSender
Definition TQObject.h:46
#define gROOT
Definition TROOT.h:406
@ kFilePrint
@ kHelpOnCanvas
@ kFileSaveAs
@ kFileQuit
@ kHelpOnGraphicsEd
@ kFileNewCanvas
@ kHelpOnObjects
@ kHelpOnBrowser
@ kHelpOnMenus
@ kHelpOnPS
@ kHelpAbout
@ kFileOpen
static ToolBarData_t gToolBarData[]
static const char * gOpenTypes[]
ERootCanvasCommands
@ kOptionInterrupt
@ kToolLatex
@ kFitPanel
@ kToolsBuilder
@ kToolPLabel
@ kEditStyle
@ kOptionCanEdit
@ kOptionResizeOpaque
@ kEditClearCanvas
@ kToolPad
@ kFilePrint
@ kViewOpenGL
@ kEditRedo
@ kHelpOnCanvas
@ kToolDiamond
@ kToolCurlyLine
@ kViewFonts
@ kToolLine
@ kFileSaveAsPDF
@ kViewIconify
@ kFileCloseCanvas
@ kViewX3D
@ kFileSaveAs
@ kToolEllipse
@ kToolPsText
@ kToolModify
@ kFileSaveAsGIF
@ kFileQuit
@ kToolArrow
@ kToolArc
@ kToolsRecorder
@ kToolsBrowser
@ kOptionResizeCanvas
@ kToolPave
@ kHelpOnGraphicsEd
@ kFileNewCanvas
@ kOptionFitParams
@ kOptionRefresh
@ kHelpOnObjects
@ kEditCopy
@ kFileSaveAsEPS
@ kInspectRoot
@ kViewToolTips
@ kOptionMoveOpaque
@ kViewEditor
@ kHelpOnBrowser
@ kClassesTree
@ kToolPText
@ kViewToolbar
@ kOptionAutoExec
@ kHelpOnMenus
@ kEditUndo
@ kHelpOnPS
@ kFileSaveAsPNG
@ kViewMarkers
@ kEditClearPad
@ kToolCurlyArc
@ kEditCut
@ kFileSaveAsC
@ kViewColors
@ kToolGraph
@ kViewEventStatus
@ kFileSaveAsPS
@ kOptionStatistics
@ kFileSaveAsJPG
@ kOptionHistTitle
@ kFileSaveAsTEX
@ kHelpAbout
@ kToolCutG
@ kToolMarker
@ kFileSaveAsRoot
@ kFileOpen
@ kEditPaste
@ kOptionAutoResize
static const char * gSaveAsTypes[]
static ToolBarData_t gToolBarData1[]
static ToolBarData_t gToolBarData[]
static const char * gOpenTypes[]
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2467
char * StrDup(const char *str)
Duplicate the string str.
Definition TString.cxx:2535
R__EXTERN TStyle * gStyle
Definition TStyle.h:433
R__EXTERN TSystem * gSystem
Definition TSystem.h:560
#define gGLManager
Definition TVirtualGL.h:160
#define gPad
R__EXTERN Int_t(* gThreadXAR)(const char *xact, Int_t nb, void **ar, Int_t *iret)
#define gVirtualX
Definition TVirtualX.h:338
Int_t GET_MSG(Long_t val)
@ kCM_MENU
@ kC_COMMAND
@ kCM_BUTTON
Int_t GET_SUBMSG(Long_t val)
Bool_t ReturnFromRun() const
virtual void Terminate(Int_t status=0)
Terminate the application by call TSystem::Exit() unless application has been told to return from Run...
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket.
Definition TBufferFile.h:47
void * ReadObjectAny(const TClass *cast) override
Read object from I/O buffer.
@ kRead
Definition TBuffer.h:73
void SetReadMode()
Set buffer in read mode.
Definition TBuffer.cxx:302
ABC describing GUI independent main window (with menubar, scrollbars and a drawing area).
Definition TCanvasImp.h:30
TCanvas * Canvas() const
Definition TCanvasImp.h:58
TCanvas * fCanvas
Definition TCanvasImp.h:34
friend class TCanvas
Definition TCanvasImp.h:31
The Canvas class.
Definition TCanvas.h:23
UInt_t GetWindowHeight() const
Definition TCanvas.h:162
virtual void ToggleAutoExec()
Toggle pad auto execution of list of TExecs.
Definition TCanvas.cxx:2416
virtual void ToggleToolTips()
Toggle tooltip display.
Definition TCanvas.cxx:2458
void Clear(Option_t *option="") override
Remove all primitives from the canvas.
Definition TCanvas.cxx:734
virtual void ToggleEventStatus()
Toggle event statusbar.
Definition TCanvas.cxx:2425
void SetSupportGL(Bool_t support)
Definition TCanvas.h:229
TPad * Pick(Int_t px, Int_t py, TObjLink *&pickobj) override
Search for an object at pixel position px,py.
Definition TCanvas.h:183
virtual void Resize(Option_t *option="")
Recompute canvas parameters following a X11 Resize.
Definition TCanvas.cxx:1666
void SaveSource(const char *filename="", Option_t *option="")
Save primitives in this canvas as a C++ macro file.
Definition TCanvas.cxx:1820
void SetCanvasImp(TCanvasImp *i)
Definition TCanvas.h:205
virtual void HandleInput(EEventType button, Int_t x, Int_t y)
Handle Input Events.
Definition TCanvas.cxx:1232
TVirtualPad * cd(Int_t subpadnumber=0) override
Set current canvas & pad.
Definition TCanvas.cxx:716
Bool_t GetShowEditor() const
Definition TCanvas.h:150
Bool_t GetAutoExec() const
Definition TCanvas.h:152
virtual void ToggleEditor()
Toggle editor.
Definition TCanvas.cxx:2447
Bool_t GetShowToolTips() const
Definition TCanvas.h:151
void SetName(const char *name="") override
Set canvas name. In case name is an empty string, a default name is set.
Definition TCanvas.cxx:2049
void Paint(Option_t *option="") override
Paint canvas.
Definition TCanvas.cxx:1541
void Update() override
Update canvas pad buffers.
Definition TCanvas.cxx:2483
Bool_t OpaqueMoving() const override
Definition TCanvas.h:180
void Flush()
Flush canvas buffers.
Definition TCanvas.cxx:1143
void MoveOpaque(Int_t set=1)
Set option to move objects/pads in a canvas.
Definition TCanvas.cxx:1533
Bool_t UseGL() const
Definition TCanvas.h:228
void ResizeOpaque(Int_t set=1)
Set option to resize objects/pads in a canvas.
Definition TCanvas.cxx:1757
virtual void ToggleToolBar()
Toggle toolbar.
Definition TCanvas.cxx:2436
Bool_t OpaqueResizing() const override
Definition TCanvas.h:181
Draw inheritance tree and their relations for a list of classes.
Definition TClassTree.h:22
TMethod * GetMethodAllAny(const char *method)
Return pointer to method without looking at parameters.
Definition TClass.cxx:4384
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition TClass.cxx:2968
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Draw the ROOT Color Wheel.
Definition TColorWheel.h:23
void Draw(Option_t *option="") override
Paint the color wheel.
Drag and drop data container.
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:491
virtual void SetValue(const char *name, const char *value, EEnvLevel level=kEnvChange, const char *type=nullptr)
Set the value of a resource or create a new resource.
Definition TEnv.cxx:736
A ROOT file is composed of a header, followed by consecutive data records (TKey instances) with a wel...
Definition TFile.h:53
A frame containing two scrollbars (a horizontal and a vertical) and a viewport.
Definition TGCanvas.h:192
virtual void SetContainer(TGFrame *f)
Definition TGCanvas.h:222
virtual void SetVsbPosition(Int_t newPos)
Set position of vertical scrollbar.
virtual Int_t GetVsbPosition() const
Get position of vertical scrollbar.
TGViewPort * GetViewPort() const
Definition TGCanvas.h:217
const TGWindow * GetDefaultRoot() const
Returns the root (i.e.
Definition TGClient.cxx:234
const TGWindow * GetRoot() const
Returns current root (i.e.
Definition TGClient.cxx:224
UInt_t GetDisplayHeight() const
Get display height.
Definition TGClient.cxx:275
The base class for composite widgets (menu bars, list boxes, etc.).
Definition TGFrame.h:287
TGDimension GetDefaultSize() const override
std::cout << fWidth << "x" << fHeight << std::endl;
Definition TGFrame.h:316
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=nullptr)
Add frame to the composite frame using the specified layout hints.
Definition TGFrame.cxx:1117
Int_t MustCleanup() const override
Definition TGFrame.h:360
void MapSubwindows() override
Map all sub windows that are part of the composite frame.
Definition TGFrame.cxx:1164
void Layout() override
Layout the elements of the composite frame.
Definition TGFrame.cxx:1257
virtual void ShowFrame(TGFrame *f)
Show sub frame.
Definition TGFrame.cxx:1204
void SetCleanup(Int_t mode=kLocalCleanup) override
Turn on automatic cleanup of child frames in dtor.
Definition TGFrame.cxx:1072
void SetEditable(Bool_t on=kTRUE) override
Switch ON/OFF edit mode.
Definition TGFrame.cxx:948
void SetEditDisabled(UInt_t on=1) override
Set edit disable flag for this frame and subframes.
Definition TGFrame.cxx:1022
void ChangeOptions(UInt_t options) override
Change composite frame options. Options is an OR of the EFrameTypes.
Definition TGFrame.cxx:1043
virtual void HideFrame(TGFrame *f)
Hide sub frame.
Definition TGFrame.cxx:1190
A frame with handles that allow it to be undocked (i.e.
void DockContainer(Int_t del=kTRUE)
Dock container back to TGDockableFrame.
void AddFrame(TGFrame *f, TGLayoutHints *hints) override
Add frame to dockable frame container. Frame and hints are NOT adopted.
void SetWindowName(const char *name) override
Set window name so it appear as title of the undock window.
void EnableHide(Bool_t onoff)
Enable hiding.
Bool_t IsUndocked() const
This class creates a file selection dialog.
char * fFilename
selected file name
Int_t fFileTypeIdx
selected file type, index in fFileTypes
const char ** fFileTypes
file types used to filter selectable files
char * fIniDir
on input: initial directory, on output: new directory
Bool_t fOverwrite
if true overwrite the file with existing name on save
void SetIniDir(const char *inidir)
Set directory name.
void AddInput(UInt_t emask)
Add events specified in the emask to the events the frame should handle.
Definition TGFrame.cxx:339
void MoveResize(Int_t x, Int_t y, UInt_t w=0, UInt_t h=0) override
Move and/or resize the frame.
Definition TGFrame.cxx:629
virtual Bool_t HandleConfigureNotify(Event_t *event)
This event is generated when the frame is resized.
Definition TGFrame.cxx:443
void Resize(UInt_t w=0, UInt_t h=0) override
Resize the frame.
Definition TGFrame.cxx:605
void Move(Int_t x, Int_t y) override
Move frame.
Definition TGFrame.cxx:593
virtual void DeleteWindow()
Delete window.
Definition TGFrame.cxx:276
virtual UInt_t GetOptions() const
Definition TGFrame.h:197
UInt_t GetHeight() const
Definition TGFrame.h:225
virtual void SetWidth(UInt_t w)
Definition TGFrame.h:246
void SetDNDTarget(Bool_t onoff)
Definition TGFrame.h:270
UInt_t GetWidth() const
Definition TGFrame.h:224
virtual void SetHeight(UInt_t h)
Definition TGFrame.h:247
A horizontal 3D line is a line that typically separates a toolbar from the menubar.
Definition TG3DLine.h:18
This class describes layout hints used by the layout classes.
Definition TGLayout.h:50
Defines top level windows that interact with the system Window Manager.
Definition TGFrame.h:397
Atom_t * fDNDTypeList
handles DND types
Definition TGFrame.h:413
virtual void SendCloseMessage()
Send close message to self.
Definition TGFrame.cxx:1744
void SetClassHints(const char *className, const char *resourceName)
Set the windows class and resource name.
Definition TGFrame.cxx:1858
void SetIconName(const char *name)
Set window icon name. This is typically done via the window manager.
Definition TGFrame.cxx:1801
void SetWindowName(const char *name=nullptr) override
Set window name. This is typically done via the window manager.
Definition TGFrame.cxx:1788
const char * GetWindowName() const
Definition TGFrame.h:476
The TGMenu.h header contains all different menu classes.
Definition TGMenu.h:282
virtual void AddPopup(TGHotString *s, TGPopupMenu *menu, TGLayoutHints *l, TGPopupMenu *before=nullptr)
Add popup menu to menu bar.
Definition TGMenu.cxx:418
TGClient * fClient
Connection to display server.
Definition TGObject.h:25
Handle_t GetId() const
Definition TGObject.h:41
Handle_t fId
X11/Win32 Window identifier.
Definition TGObject.h:24
This class creates a popup menu object.
Definition TGMenu.h:110
virtual void AddLabel(TGHotString *s, const TGPicture *p=nullptr, TGMenuEntry *before=nullptr)
Add a menu label to the menu.
Definition TGMenu.cxx:1095
virtual Bool_t IsEntryChecked(Int_t id)
Return true if menu item is checked.
Definition TGMenu.cxx:1845
virtual void AddPopup(TGHotString *s, TGPopupMenu *popup, TGMenuEntry *before=nullptr, const TGPicture *p=nullptr)
Add a (cascading) popup menu to a popup menu.
Definition TGMenu.cxx:1152
virtual void CheckEntry(Int_t id)
Check a menu entry (i.e. add a check mark in front of it).
Definition TGMenu.cxx:1782
virtual void DisableEntry(Int_t id)
Disable entry (disabled entries appear in a sunken relieve).
Definition TGMenu.cxx:1724
virtual void UnCheckEntry(Int_t id)
Uncheck menu entry (i.e. remove check mark).
Definition TGMenu.cxx:1807
virtual void Associate(const TGWindow *w)
Definition TGMenu.h:206
virtual void AddSeparator(TGMenuEntry *before=nullptr)
Add a menu separator to the menu.
Definition TGMenu.cxx:1060
virtual void AddEntry(TGHotString *s, Int_t id, void *ud=nullptr, const TGPicture *p=nullptr, TGMenuEntry *before=nullptr)
Add a menu entry.
Definition TGMenu.cxx:990
Provides a StatusBar widget.
Definition TGStatusBar.h:21
virtual void SetText(TGString *text, Int_t partidx=0)
Set text in partition partidx in status bar.
virtual void SetParts(Int_t npart)
Divide the status bar in npart equal sized parts.
A tab widget contains a set of composite frames each with a little tab with a name (like a set of fol...
Definition TGTab.h:46
TGTabElement * GetTabTab(Int_t tabIndex) const
Return the tab element of tab with index tabIndex.
Definition TGTab.cxx:663
virtual Bool_t SetTab(Int_t tabIndex, Bool_t emit=kTRUE)
Brings the composite frame with the index tabIndex to the front and generate the following event if t...
Definition TGTab.cxx:558
TGCompositeFrame * GetTabContainer(Int_t tabIndex) const
Return container of tab with index tabIndex.
Definition TGTab.cxx:614
A toolbar is a composite frame that contains TGPictureButtons.
Definition TGToolBar.h:33
virtual TGButton * AddButton(const TGWindow *w, ToolBarData_t *button, Int_t spacing=0)
Add button to toolbar.
Definition TGToolBar.cxx:92
void Cleanup() override
Cleanup and delete all objects contained in this composite frame.
A tooltip can be a one or multiple lines help text that is displayed in a window when the mouse curso...
Definition TGToolTip.h:24
void Hide()
Hide tool tip window.
void SetPosition(Int_t x, Int_t y)
Set popup position within specified frame (as specified in the ctor).
void SetText(const char *new_text)
Set new tool tip text.
void Reset()
Reset tool tip popup delay timer.
A vertical 3D line is a line that can be used to separate groups of widgets.
Definition TG3DLine.h:33
ROOT GUI Window base class.
Definition TGWindow.h:23
virtual const TGWindow * GetMainFrame() const
Returns top level main frame.
Definition TGWindow.cxx:152
const TGWindow * fParent
Parent window.
Definition TGWindow.h:28
@ kEditEnable
allow edit of this window
Definition TGWindow.h:56
@ kEditDisable
disable edit of this window
Definition TGWindow.h:57
const TGWindow * GetParent() const
Definition TGWindow.h:83
virtual Bool_t IsMapped()
Returns kTRUE if window is mapped on screen, kFALSE otherwise.
Definition TGWindow.cxx:295
const char * GetName() const override
Return unique name, used in SavePrimitive methods.
Definition TGWindow.cxx:336
UInt_t fEditDisabled
flags used for "guibuilding"
Definition TGWindow.h:32
static TGuiBuilder * Instance()
return an instance of TGuiBuilder object
An abstract interface to image processing library.
Definition TImage.h:29
virtual void SetEditable(Bool_t=kTRUE)
Definition TImage.h:225
static TImage * Open(const char *file, EImageFileTypes type=kUnknown)
Open a specified image file.
Definition TImage.cxx:118
static TImage * Create()
Create an image.
Definition TImage.cxx:35
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
static void DisplayMarkerTypes()
Display the table of markers with their numbers.
Definition TMarker.cxx:103
Mother of all ROOT objects.
Definition TObject.h:41
virtual void Inspect() const
Dump contents of this object in a graphics canvas.
Definition TObject.cxx:546
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:439
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:207
static TClass * Class()
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Returns string containing info about the object at position (px,py).
Definition TObject.cxx:468
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 Draw(Option_t *option="")
Default Draw method for all objects.
Definition TObject.cxx:274
The most important graphics class in the ROOT system.
Definition TPad.h:28
Double_t GetAspectRatio() const override
Definition TPad.h:222
void Update() override
Update pad.
Definition TPad.cxx:2839
void Modified(Bool_t flag=true) override
Definition TPad.h:420
Bool_t HasFixedAspectRatio() const override
Definition TPad.h:268
virtual void SetGLDevice(Int_t dev)
Definition TPad.h:362
void SaveAs(const char *filename="", Option_t *option="") const override
Save the pad content in a file.
Definition TPad.cxx:5659
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
Longptr_t ExecPlugin(int nargs)
Int_t LoadPlugin()
Load the plugin library for this handler.
Bool_t Connect(const char *signal, const char *receiver_class, void *receiver, const char *slot)
Non-static method is used to connect from the signal of this object to the receiver slot.
Definition TQObject.cxx:869
Bool_t Disconnect(const char *signal=nullptr, void *receiver=nullptr, const char *slot=nullptr)
Disconnects signal of this object from slot of receiver.
static const TString & GetBinDir()
Get the binary directory in the installation. Static utility function.
Definition TROOT.cxx:2931
This class creates a ROOT object browser, constituted by three main tabs.
TGTab * GetTabLeft() const
void StartEmbedding(Int_t pos=kRight, Int_t subpos=-1) override
Start embedding external frame in the tab "pos" and tab element "subpos".
void StopEmbedding(const char *name=nullptr) override
TGFrame * GetActFrame() const
TGTab * GetTabRight() const
This class creates a main window with menubar, scrollbars and a drawing area.
Definition TRootCanvas.h:34
TGToolBar * fToolBar
icon button toolbar
Definition TRootCanvas.h:62
UInt_t GetCwidth() const
Return width of canvas container.
void AdjustSize()
Keep the same canvas size while docking/undocking toolbar.
Bool_t fAutoFit
when true canvas container keeps same size as canvas
Definition TRootCanvas.h:79
TGPopupMenu * fEditMenu
edit menu
Definition TRootCanvas.h:44
friend class TRootContainer
Definition TRootCanvas.h:36
void CreateEditor()
Create embedded editor.
Bool_t HasEditor() const override
Returns kTRUE if the editor is shown.
Bool_t HandleContainerKey(Event_t *ev)
Handle keyboard events in the canvas container.
UInt_t GetWindowGeometry(Int_t &x, Int_t &y, UInt_t &w, UInt_t &h) override
Gets the size and position of the window containing the canvas.
void Close() override
Called via TCanvasImp interface by TCanvas.
Bool_t HandleDNDDrop(TDNDData *data) override
Handle drop events.
void Iconify() override
void SetStatusText(const char *txt=nullptr, Int_t partidx=0) override
Set text in status bar.
TGLayoutHints * fMainFrameLayout
layout for main frame
Definition TRootCanvas.h:64
Bool_t HandleContainerButton(Event_t *ev)
Handle mouse button events in the canvas container.
Bool_t HandleContainerCrossing(Event_t *ev)
Handle enter/leave events. Only leave is activated at the moment.
UInt_t GetCheight() const
Return height of canvas container.
TGDockableFrame * fToolDock
dockable frame holding the toolbar
Definition TRootCanvas.h:71
void RaiseWindow() override
Put canvas window on top of the window stack.
void ShowEditor(Bool_t show=kTRUE) override
Show or hide side frame.
Bool_t ProcessMessage(Longptr_t msg, Longptr_t parm1, Longptr_t parm2) override
Handle menu and other command generated by the user.
void ReallyDelete() override
Really delete the canvas and this GUI.
void ShowMenuBar(Bool_t show=kTRUE) override
Show or hide menubar.
Atom_t HandleDNDEnter(Atom_t *typelist) override
Handle drag enter events.
void ShowStatusBar(Bool_t show=kTRUE) override
Show or hide statusbar.
TGHorizontal3DLine * fHorizontal1
toolbar separator
Definition TRootCanvas.h:67
TGLayoutHints * fEditorLayout
layout for editor frame
Definition TRootCanvas.h:59
TGPopupMenu * fToolsMenu
tools menu
Definition TRootCanvas.h:49
TGLayoutHints * fMenuBarItemLayout
layout hints for menu in menubar
Definition TRootCanvas.h:52
Int_t fCanvasID
index in fWindows array of TGX11
Definition TRootCanvas.h:78
const TGPicture * fIconPic
icon picture
Definition TRootCanvas.h:73
void SetCanvasSize(UInt_t w, UInt_t h) override
Set size of canvas container.
void SetWindowSize(UInt_t w, UInt_t h) override
Set size of canvas (units in pixels).
void PrintCanvas()
Print the canvas.
TRootCanvas(const TRootCanvas &)=delete
void ShowToolBar(Bool_t show=kTRUE) override
Show or hide toolbar.
Bool_t HasToolBar() const override
Returns kTRUE if the tool bar is shown.
void Activated(Int_t id)
Slot handling tab switching in the browser, to properly set the canvas and the model to the editor.
TGHorizontal3DLine * fToolBarSep
toolbar separator
Definition TRootCanvas.h:63
TGPopupMenu * fViewWithMenu
view with... cascade submenu
Definition TRootCanvas.h:47
TGPopupMenu * fEditClearMenu
clear cascade submenu
Definition TRootCanvas.h:45
void ShowToolTips(Bool_t show=kTRUE) override
Enable or disable tooltip info.
Bool_t HasToolTips() const override
Returns kTRUE if the tooltips are enabled.
TRootContainer * fCanvasContainer
container in canvas widget
Definition TRootCanvas.h:40
Bool_t fEmbedded
true if embedded in any other frame (e.g. in the browser)
Definition TRootCanvas.h:77
Bool_t HandleContainerDoubleClick(Event_t *ev)
Handle mouse button double click events in the canvas container.
TGLayoutHints * fHorizontal1Layout
layout hints for separator
Definition TRootCanvas.h:70
TGVertical3DLine * fVertical2
toolbar vertical separator
Definition TRootCanvas.h:66
TGLayoutHints * fMenuBarLayout
menubar layout hints
Definition TRootCanvas.h:51
void FitCanvas()
Fit canvas container to current window size.
Bool_t HandleContainerMotion(Event_t *ev)
Handle mouse motion event in the canvas container.
TGCanvas * fCanvasWindow
canvas widget
Definition TRootCanvas.h:39
TGLayoutHints * fMenuBarHelpLayout
layout hint for help menu in menubar
Definition TRootCanvas.h:53
TGPopupMenu * fViewMenu
view menu
Definition TRootCanvas.h:46
TGStatusBar * fStatusBar
statusbar widget
Definition TRootCanvas.h:55
TGPopupMenu * fOptionMenu
option menu
Definition TRootCanvas.h:48
TGLayoutHints * fDockLayout
layout hints for dockable frame widget
Definition TRootCanvas.h:72
TGPopupMenu * fHelpMenu
help menu
Definition TRootCanvas.h:50
void EventInfo(Int_t event, Int_t px, Int_t py, TObject *selected)
Display a tooltip with infos about the primitive below the cursor.
void CreateCanvas(const char *name)
Create the actual canvas.
TGLayoutHints * fVertical1Layout
layout hints for separator
Definition TRootCanvas.h:68
Bool_t HasStatusBar() const override
Returns kTRUE if the status bar is shown.
Bool_t HandleContainerConfigure(Event_t *ev)
Handle configure (i.e. resize) event.
Bool_t HasMenuBar() const override
Returns kTRUE if the menu bar is shown.
TGCompositeFrame * fMainFrame
main frame containing canvas and side frame
Definition TRootCanvas.h:60
Int_t InitWindow() override
Called by TCanvas ctor to get window indetifier.
TGLayoutHints * fVertical2Layout
layout hints for separator
Definition TRootCanvas.h:69
TVirtualPadEditor * fEditor
pointer to currently loaded pad editor
Definition TRootCanvas.h:76
TGMenuBar * fMenuBar
menubar
Definition TRootCanvas.h:41
void SetWindowPosition(Int_t x, Int_t y) override
Set canvas position (units in pixels).
Bool_t HandleContainerExpose(Event_t *ev)
Handle expose events.
TGLayoutHints * fCanvasLayout
layout for canvas widget
Definition TRootCanvas.h:54
TGLayoutHints * fToolBarLayout
layout for toolbar widget
Definition TRootCanvas.h:61
Bool_t HandleDNDLeave() override
Handle drag leave events.
TGCompositeFrame * fEditorFrame
side frame for current pad editor
Definition TRootCanvas.h:58
~TRootCanvas() override
Delete ROOT basic canvas.
TGToolTip * fToolTip
tooltip for object info
Definition TRootCanvas.h:74
TGPopupMenu * fFileMenu
file menu
Definition TRootCanvas.h:42
TGPopupMenu * fFileSaveMenu
save cascade submenu
Definition TRootCanvas.h:43
Atom_t HandleDNDPosition(Int_t x, Int_t y, Atom_t action, Int_t xroot, Int_t yroot) override
Handle dragging position events.
void SetWindowTitle(const char *newTitle) override
Change title on window.
void CloseWindow() override
In case window is closed via WM we get here.
Int_t fButton
currently pressed button
Definition TRootCanvas.h:80
TGLayoutHints * fStatusBarLayout
layout hints for statusbar
Definition TRootCanvas.h:56
TGVertical3DLine * fVertical1
toolbar vertical separator
Definition TRootCanvas.h:65
Bool_t HandleCrossing(Event_t *ev) override
void SetEditable(Bool_t) override
Switch ON/OFF edit mode.
Bool_t HandleDoubleClick(Event_t *ev) override
TRootContainer(TRootCanvas *c, Window_t id, const TGWindow *parent)
Create a canvas container.
Bool_t HandleMotion(Event_t *ev) override
Bool_t HandleKey(Event_t *ev) override
Bool_t HandleConfigureNotify(Event_t *ev) override
This event is generated when the frame is resized.
Bool_t HandleExpose(Event_t *ev) override
void SavePrimitive(std::ostream &out, Option_t *="") override
Save a canvas container as a C++ statement(s) on output stream out.
TRootCanvas * fCanvas
Bool_t HandleButton(Event_t *ev) override
Directly handle scroll mouse buttons (4 and 5), only pass buttons 1, 2 and 3 on to the TCanvas.
A TRootHelpDialog is used to display help text (or any text in a dialog window).
void SetText(const char *helpText)
Set help text from helpText buffer in TGTextView.
void Popup()
Show help dialog.
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:419
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition TString.cxx:2222
const char * Data() const
Definition TString.h:378
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:702
@ kLeading
Definition TString.h:278
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition TString.h:625
Bool_t IsNull() const
Definition TString.h:416
TString & Remove(Ssiz_t pos)
Definition TString.h:683
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
void SetOptTitle(Int_t tit=1)
Definition TStyle.h:332
void SetOptStat(Int_t stat=1)
The type of information printed in the histogram statistics box can be selected via the parameter mod...
Definition TStyle.cxx:1636
Int_t GetOptTitle() const
Definition TStyle.h:244
Int_t GetOptFit() const
Definition TStyle.h:242
void SetOptFit(Int_t fit=1)
The type of information about fit parameters printed in the histogram statistics box can be selected ...
Definition TStyle.cxx:1589
virtual Int_t Exec(const char *shellcmd)
Execute a command.
Definition TSystem.cxx:640
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
Definition TSystem.cxx:1842
virtual FILE * TempFileName(TString &base, const char *dir=nullptr)
Create a secure temporary file by appending a unique 6 letter string to base.
Definition TSystem.cxx:1484
virtual Bool_t ChangeDirectory(const char *path)
Change directory.
Definition TSystem.cxx:849
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition TSystem.cxx:424
virtual const char * WorkingDirectory()
Return working directory.
Definition TSystem.cxx:858
virtual Bool_t ProcessEvents()
Process pending events (GUI, timers, sockets).
Definition TSystem.cxx:403
virtual int Unlink(const char *name)
Unlink, i.e.
Definition TSystem.cxx:1368
virtual const char * TempDirectory() const
Return a user configured or systemwide directory to create temporary files in.
Definition TSystem.cxx:1469
static void SingleShot(Int_t milliSec, const char *receiver_class, void *receiver, const char *method)
This static function calls a slot after a given time interval.
Definition TTimer.cxx:258
This class represents a WWW compatible URL.
Definition TUrl.h:33
const char * GetFile() const
Definition TUrl.h:69
Abstract base class used by ROOT graphics editor.
virtual TCanvas * GetCanvas() const =0
static TVirtualPadEditor * LoadEditor()
Static function returning a pointer to a new pad editor.
virtual void Hide()
static TVirtualPadEditor * GetPadEditor(Bool_t load=kTRUE)
Returns the pad editor dialog. Static method.
virtual void SetGlobal(Bool_t)
virtual void Show()
static void Terminate()
Close the global pad editor. Static method.
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
virtual TVirtualPad * cd(Int_t subpadnumber=0)=0
virtual TCanvas * GetCanvas() const =0
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition TMath.h:693
Event structure.
Definition GuiTypes.h:174
EGEventType fType
of event (see EGEventType)
Definition GuiTypes.h:175
Int_t fCount
if non-zero, at least this many more exposes
Definition GuiTypes.h:183
UInt_t fState
key or button mask
Definition GuiTypes.h:181
UInt_t fCode
key or button code
Definition GuiTypes.h:180
const char * fPixmap
Definition TGToolBar.h:24
TMarker m
Definition textangle.C:8