Logo ROOT  
Reference Guide
TApplication.cxx
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Fons Rademakers 22/12/95
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/** \class TApplication
13\ingroup Base
14
15This class creates the ROOT Application Environment that interfaces
16to the windowing system eventloop and eventhandlers.
17This class must be instantiated exactly once in any given
18application. Normally the specific application class inherits from
19TApplication (see TRint).
20*/
21
22#include "RConfigure.h"
23#include "TApplication.h"
24#include "TException.h"
25#include "TGuiFactory.h"
26#include "TVirtualX.h"
27#include "TROOT.h"
28#include "TSystem.h"
29#include "TString.h"
30#include "TError.h"
31#include "TObjArray.h"
32#include "TObjString.h"
33#include "TTimer.h"
34#include "TInterpreter.h"
35#include "TStyle.h"
36#include "TVirtualPad.h"
37#include "TEnv.h"
38#include "TColor.h"
39#include "TPluginManager.h"
40#include "TClassTable.h"
41#include "TBrowser.h"
42#include "TUrl.h"
43#include "TVirtualMutex.h"
44#include "TClassEdit.h"
45#include "TMethod.h"
46#include "TDataMember.h"
47#include "TApplicationCommandLineOptionsHelp.h"
48#include "TPRegexp.h"
49#include <cstdlib>
50#include <iostream>
51#include <fstream>
52
56TList *TApplication::fgApplications = nullptr; // List of available applications
57
58////////////////////////////////////////////////////////////////////////////////
59
60class TIdleTimer : public TTimer {
61public:
63 Bool_t Notify() override;
64};
65
66////////////////////////////////////////////////////////////////////////////////
67/// Notify handler.
68
70{
72 Reset();
73 return kFALSE;
74}
75
76
78
80{
81 // Insure that the files, canvases and sockets are closed.
82
83 // If we get here, the tear down has started. We have no way to know what
84 // has or has not yet been done. In particular on Ubuntu, this was called
85 // after the function static in TSystem.cxx has been destructed. So we
86 // set gROOT in its end-of-life mode which prevents executing code, like
87 // autoloading libraries (!) that is pointless ...
88 if (gROOT) {
89 gROOT->SetBit(kInvalidObject);
90 gROOT->EndOfProcessCleanups();
91 }
92}
93
94////////////////////////////////////////////////////////////////////////////////
95/// Default ctor. Can be used by classes deriving from TApplication.
96
98 fArgc(0), fArgv(nullptr), fAppImp(nullptr), fIsRunning(kFALSE), fReturnFromRun(kFALSE),
99 fNoLog(kFALSE), fNoLogo(kFALSE), fQuit(kFALSE),
100 fFiles(nullptr), fIdleTimer(nullptr), fSigHandler(nullptr), fExitOnException(kDontExit),
101 fAppRemote(nullptr)
102{
104}
105
106////////////////////////////////////////////////////////////////////////////////
107/// Create an application environment. The application environment
108/// provides an interface to the graphics system and eventloop
109/// (be it X, Windows, macOS or BeOS). After creating the application
110/// object start the eventloop by calling its Run() method. The command
111/// line options recognized by TApplication are described in the GetOptions()
112/// method. The recognized options are removed from the argument array.
113/// The original list of argument options can be retrieved via the Argc()
114/// and Argv() methods. The appClassName "proofserv" is reserved for the
115/// PROOF system. The "options" and "numOptions" arguments are not used,
116/// except if you want to by-pass the argv processing by GetOptions()
117/// in which case you should specify numOptions<0. All options will
118/// still be available via the Argv() method for later use.
119
120TApplication::TApplication(const char *appClassName, Int_t *argc, char **argv,
121 void * /*options*/, Int_t numOptions) :
122 fArgc(0), fArgv(nullptr), fAppImp(nullptr), fIsRunning(kFALSE), fReturnFromRun(kFALSE),
123 fNoLog(kFALSE), fNoLogo(kFALSE), fQuit(kFALSE),
124 fFiles(nullptr), fIdleTimer(nullptr), fSigHandler(nullptr), fExitOnException(kDontExit),
125 fAppRemote(nullptr)
126{
128
129 // Create the list of applications the first time
130 if (!fgApplications)
131 fgApplications = new TList;
132
133 // Add the new TApplication early, so that the destructor of the
134 // default TApplication (if it is called in the block of code below)
135 // will not destroy the files, socket or TColor that have already been
136 // created.
137 fgApplications->Add(this);
138
140 // allow default TApplication to be replaced by a "real" TApplication
141 delete gApplication;
142 gApplication = nullptr;
143 gROOT->SetBatch(kFALSE);
145 }
146
147 if (gApplication) {
148 Error("TApplication", "only one instance of TApplication allowed");
149 fgApplications->Remove(this);
150 return;
151 }
152
153 if (!gROOT)
154 ::Fatal("TApplication::TApplication", "ROOT system not initialized");
155
156 if (!gSystem)
157 ::Fatal("TApplication::TApplication", "gSystem not initialized");
158
159 static Bool_t hasRegisterAtExit(kFALSE);
160 if (!hasRegisterAtExit) {
161 // If we are the first TApplication register the atexit)
163 hasRegisterAtExit = kTRUE;
164 }
165 gROOT->SetName(appClassName);
166
167 // copy command line arguments, can be later accessed via Argc() and Argv()
168 if (argc && *argc > 0) {
169 fArgc = *argc;
170 fArgv = (char **)new char*[fArgc];
171 }
172
173 for (int i = 0; i < fArgc; i++)
174 fArgv[i] = StrDup(argv[i]);
175
176 if (numOptions >= 0)
177 GetOptions(argc, argv);
178
179 if (fArgv)
181
182 // Tell TSystem the TApplication has been created
184
185 fAppImp = gGuiFactory->CreateApplicationImp(appClassName, argc, argv);
187
188 // Initialize the graphics environment
189 if (gClassTable->GetDict("TPad")) {
191 InitializeGraphics(gROOT->IsWebDisplay());
192 }
193
194 // Save current interpreter context
195 gInterpreter->SaveContext();
196 gInterpreter->SaveGlobalsContext();
197
198 // to allow user to interact with TCanvas's under WIN32
199 gROOT->SetLineHasBeenProcessed();
200
201 //Needs to be done last
202 gApplication = this;
203 gROOT->SetApplication(this);
204
205}
206
207////////////////////////////////////////////////////////////////////////////////
208/// TApplication dtor.
209
211{
212 for (int i = 0; i < fArgc; i++)
213 if (fArgv[i]) delete [] fArgv[i];
214 delete [] fArgv;
215
216 if (fgApplications)
217 fgApplications->Remove(this);
218
219 // Reduce the risk of the files or sockets being closed after the
220 // end of 'main' (or more exactly before the library start being
221 // unloaded).
222 if (fgApplications == nullptr || fgApplications->FirstLink() == nullptr ) {
224 }
225
226 // Now that all the canvases and files have been closed we can
227 // delete the implementation.
229}
230
231////////////////////////////////////////////////////////////////////////////////
232/// Static method. This method should be called from static library
233/// initializers if the library needs the low level graphics system.
234
236{
238}
239
240////////////////////////////////////////////////////////////////////////////////
241/// Initialize the graphics environment.
242/// If @param only_web is specified, only web-related part of graphics is loaded
243
245{
247 return;
248
249 if (!only_web) {
250 // Load the graphics related libraries
252
253 // Try to load TrueType font renderer. Only try to load if not in batch
254 // mode and Root.UseTTFonts is true and Root.TTFontPath exists. Abort silently
255 // if libttf or libGX11TTF are not found in $ROOTSYS/lib or $ROOTSYS/ttf/lib.
256 const char *ttpath = gEnv->GetValue("Root.TTFontPath",
258 char *ttfont = gSystem->Which(ttpath, "arialbd.ttf", kReadPermission);
259 // Check for use of DFSG - fonts
260 if (!ttfont)
261 ttfont = gSystem->Which(ttpath, "FreeSansBold.ttf", kReadPermission);
262
263 #if !defined(R__WIN32)
264 if (!gROOT->IsBatch() && !strcmp(gVirtualX->GetName(), "X11") &&
265 ttfont && gEnv->GetValue("Root.UseTTFonts", 1)) {
266 if (gClassTable->GetDict("TGX11TTF")) {
267 // in principle we should not have linked anything against libGX11TTF
268 // but with ACLiC this can happen, initialize TGX11TTF by hand
269 // (normally this is done by the static library initializer)
270 ProcessLine("TGX11TTF::Activate();");
271 } else {
273 if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualX", "x11ttf")))
274 if (h->LoadPlugin() == -1)
275 Info("InitializeGraphics", "no TTF support");
276 }
277 }
278 #endif
279 delete [] ttfont;
280 }
281
282 if (!only_web || !fAppImp) {
283 // Create WM dependent application environment
284 if (fAppImp)
285 delete fAppImp;
287 if (!fAppImp) {
288 MakeBatch();
290 }
291 }
292
293 // Create the canvas colors early so they are allocated before
294 // any color table expensive bitmaps get allocated in GUI routines (like
295 // creation of XPM bitmaps).
297
298 // Hook for further initializing the WM dependent application environment
299 Init();
300
301 // Set default screen factor (if not disabled in rc file)
302 if (!only_web && gEnv->GetValue("Canvas.UseScreenFactor", 1)) {
303 Int_t x, y;
304 UInt_t w, h;
305 if (gVirtualX) {
306 gVirtualX->GetGeometry(-1, x, y, w, h);
307 if (h > 0)
308 gStyle->SetScreenFactor(0.001 * h);
309 }
310 }
311}
312
313////////////////////////////////////////////////////////////////////////////////
314/// Clear list containing macro files passed as program arguments.
315/// This method is called from TRint::Run() to ensure that the macro
316/// files are only executed the first time Run() is called.
317
319{
320 if (fFiles) {
321 fFiles->Delete();
323 }
324}
325
326////////////////////////////////////////////////////////////////////////////////
327/// Return specified argument.
328
330{
331 if (fArgv) {
332 if (index >= fArgc) {
333 Error("Argv", "index (%d) >= number of arguments (%d)", index, fArgc);
334 return nullptr;
335 }
336 return fArgv[index];
337 }
338 return nullptr;
339}
340
341////////////////////////////////////////////////////////////////////////////////
342/// Get and handle command line options. Arguments handled are removed
343/// from the argument array. See CommandLineOptionsHelp.h for options.
344
345void TApplication::GetOptions(Int_t *argc, char **argv)
346{
347 static char null[1] = { "" };
348
349 fNoLog = kFALSE;
350 fQuit = kFALSE;
351 fFiles = nullptr;
352
353 if (!argc)
354 return;
355
356 int i, j;
357 TString pwd;
358
359 for (i = 1; i < *argc; i++) {
360 if (!strcmp(argv[i], "-?") || !strncmp(argv[i], "-h", 2) ||
361 !strncmp(argv[i], "--help", 6)) {
362 fprintf(stderr, kCommandLineOptionsHelp);
363 Terminate(0);
364 } else if (!strncmp(argv[i], "--version", 9)) {
365 fprintf(stderr, "ROOT Version: %s\n", gROOT->GetVersion());
366 fprintf(stderr, "Built for %s on %s\n",
368 gROOT->GetGitDate());
369
370 fprintf(stderr, "From %s@%s\n",
371 gROOT->GetGitBranch(),
372 gROOT->GetGitCommit());
373
374 Terminate(0);
375 } else if (!strcmp(argv[i], "-config")) {
376 fprintf(stderr, "ROOT ./configure options:\n%s\n", gROOT->GetConfigOptions());
377 Terminate(0);
378 } else if (!strcmp(argv[i], "-b")) {
379 MakeBatch();
380 argv[i] = null;
381 } else if (!strcmp(argv[i], "-n")) {
382 fNoLog = kTRUE;
383 argv[i] = null;
384 } else if (!strcmp(argv[i], "-t")) {
386 // EnableImplicitMT() only enables thread safety if IMT was configured;
387 // enable thread safety even with IMT off:
389 argv[i] = null;
390 } else if (!strcmp(argv[i], "-q")) {
391 fQuit = kTRUE;
392 argv[i] = null;
393 } else if (!strcmp(argv[i], "-l")) {
394 // used by front-end program to not display splash screen
395 fNoLogo = kTRUE;
396 argv[i] = null;
397 } else if (!strcmp(argv[i], "-x")) {
399 argv[i] = null;
400 } else if (!strcmp(argv[i], "-splash")) {
401 // used when started by front-end program to signal that
402 // splash screen can be popped down (TRint::PrintLogo())
403 argv[i] = null;
404 } else if (strncmp(argv[i], "--web", 5) == 0) {
405 // the web mode is requested
406 const char *opt = argv[i] + 5;
407 argv[i] = null;
408 gROOT->SetWebDisplay((*opt == '=') ? opt + 1 : "");
409 } else if (!strcmp(argv[i], "-e")) {
410 argv[i] = null;
411 ++i;
412
413 if ( i < *argc ) {
414 if (!fFiles) fFiles = new TObjArray;
415 TObjString *expr = new TObjString(argv[i]);
416 expr->SetBit(kExpression);
417 fFiles->Add(expr);
418 argv[i] = null;
419 } else {
420 Warning("GetOptions", "-e must be followed by an expression.");
421 }
422 } else if (!strcmp(argv[i], "--")) {
423 TObjString* macro = nullptr;
424 bool warnShown = false;
425
426 if (fFiles) {
427 for (auto f: *fFiles) {
428 TObjString *file = dynamic_cast<TObjString *>(f);
429 if (!file) {
430 if (!dynamic_cast<TNamed*>(f)) {
431 Error("GetOptions()", "Inconsistent file entry (not a TObjString)!");
432 if (f)
433 f->Dump();
434 } // else we did not find the file.
435 continue;
436 }
437
438 if (file->TestBit(kExpression))
439 continue;
440 if (file->String().EndsWith(".root"))
441 continue;
442 if (file->String().Contains('('))
443 continue;
444
445 if (macro && !warnShown && (warnShown = true))
446 Warning("GetOptions", "-- is used with several macros. "
447 "The arguments will be passed to the last one.");
448
449 macro = file;
450 }
451 }
452
453 if (macro) {
454 argv[i] = null;
455 ++i;
456 TString& str = macro->String();
457
458 str += '(';
459 for (; i < *argc; i++) {
460 str += argv[i];
461 str += ',';
462 argv[i] = null;
463 }
464 str.EndsWith(",") ? str[str.Length() - 1] = ')' : str += ')';
465 } else {
466 Warning("GetOptions", "no macro to pass arguments to was provided. "
467 "Everything after the -- will be ignored.");
468 for (; i < *argc; i++)
469 argv[i] = null;
470 }
471 } else if (argv[i][0] != '-' && argv[i][0] != '+') {
473 Long_t id, flags, modtime;
474 char *arg = strchr(argv[i], '(');
475 if (arg) *arg = '\0';
476 char *dir = gSystem->ExpandPathName(argv[i]);
477 // ROOT-9959: we do not continue if we could not expand the path
478 if (!dir) continue;
479 TUrl udir(dir, kTRUE);
480 // remove options and anchor to check the path
481 TString sfx = udir.GetFileAndOptions();
482 TString fln = udir.GetFile();
483 sfx.Replace(sfx.Index(fln), fln.Length(), "");
484 TString path = udir.GetFile();
485 if (strcmp(udir.GetProtocol(), "file")) {
486 path = udir.GetUrl();
487 path.Replace(path.Index(sfx), sfx.Length(), "");
488 }
489 // 'path' is the full URL without suffices (options and/or anchor)
490 if (arg) *arg = '(';
491 if (!arg && !gSystem->GetPathInfo(path.Data(), &id, &size, &flags, &modtime)) {
492 if ((flags & 2)) {
493 // if directory set it in fWorkDir
494 if (pwd == "") {
495 pwd = gSystem->WorkingDirectory();
496 fWorkDir = dir;
498 argv[i] = null;
499 } else if (!strcmp(gROOT->GetName(), "Rint")) {
500 Warning("GetOptions", "only one directory argument can be specified (%s)", dir);
501 }
502 } else if (size > 0) {
503 // if file add to list of files to be processed
504 if (!fFiles) fFiles = new TObjArray;
505 fFiles->Add(new TObjString(path.Data()));
506 argv[i] = null;
507 } else {
508 Warning("GetOptions", "file %s has size 0, skipping", dir);
509 }
510 } else {
511 if (TString(udir.GetFile()).EndsWith(".root")) {
512 if (!strcmp(udir.GetProtocol(), "file")) {
513 // file ending on .root but does not exist, likely a typo
514 // warn user if plain root...
515 if (!strcmp(gROOT->GetName(), "Rint"))
516 Warning("GetOptions", "file %s not found", dir);
517 } else {
518 // remote file, give it the benefit of the doubt and add it to list of files
519 if (!fFiles) fFiles = new TObjArray;
520 fFiles->Add(new TObjString(argv[i]));
521 argv[i] = null;
522 }
523 } else {
524 TString mode,fargs,io;
525 TString fname = gSystem->SplitAclicMode(dir,mode,fargs,io);
526 char *mac;
527 if (!fFiles) fFiles = new TObjArray;
528 if ((mac = gSystem->Which(TROOT::GetMacroPath(), fname,
529 kReadPermission))) {
530 // if file add to list of files to be processed
531 fFiles->Add(new TObjString(argv[i]));
532 argv[i] = null;
533 delete [] mac;
534 } else {
535 // if file add an invalid entry to list of files to be processed
536 fFiles->Add(new TNamed("NOT FOUND!", argv[i]));
537 // only warn if we're plain root,
538 // other progs might have their own params
539 if (!strcmp(gROOT->GetName(), "Rint"))
540 Warning("GetOptions", "macro %s not found", fname.Data());
541 }
542 }
543 }
544 delete [] dir;
545 }
546 // ignore unknown options
547 }
548
549 // go back to startup directory
550 if (pwd != "")
552
553 // remove handled arguments from argument array
554 j = 0;
555 for (i = 0; i < *argc; i++) {
556 if (strcmp(argv[i], "")) {
557 argv[j] = argv[i];
558 j++;
559 }
560 }
561
562 *argc = j;
563}
564
565////////////////////////////////////////////////////////////////////////////////
566/// Handle idle timeout. When this timer expires the registered idle command
567/// will be executed by this routine and a signal will be emitted.
568
570{
571 if (!fIdleCommand.IsNull())
573
574 Emit("HandleIdleTimer()");
575}
576
577////////////////////////////////////////////////////////////////////////////////
578/// Handle exceptions (kSigBus, kSigSegmentationViolation,
579/// kSigIllegalInstruction and kSigFloatingException) trapped in TSystem.
580/// Specific TApplication implementations may want something different here.
581
583{
584 if (TROOT::Initialized()) {
585 if (gException) {
586 gInterpreter->RewindDictionary();
587 gInterpreter->ClearFileBusy();
588 }
589 if (fExitOnException == kExit)
590 gSystem->Exit(128 + sig);
591 else if (fExitOnException == kAbort)
592 gSystem->Abort();
593 else
594 Throw(sig);
595 }
596 gSystem->Exit(128 + sig);
597}
598
599////////////////////////////////////////////////////////////////////////////////
600/// Set the exit on exception option. Setting this option determines what
601/// happens in HandleException() in case an exception (kSigBus,
602/// kSigSegmentationViolation, kSigIllegalInstruction or kSigFloatingException)
603/// is trapped. Choices are: kDontExit (default), kExit or kAbort.
604/// Returns the previous value.
605
607{
609 fExitOnException = opt;
610 return old;
611}
612
613/////////////////////////////////////////////////////////////////////////////////
614/// The function generates and executes a command that loads the Doxygen URL in
615/// a browser. It works for Mac, Windows and Linux. In the case of Linux, the
616/// function also checks if the DISPLAY is set. If it isn't, a warning message
617/// and the URL will be displayed on the terminal.
618///
619/// \param[in] url web page to be displayed in a browser
620
622{
623 // We check what operating system the user has.
624#ifdef R__MACOSX
625 // Command for opening a browser on Mac.
626 TString cMac("open ");
627 // We generate the full command and execute it.
628 cMac.Append(url);
629 gSystem->Exec(cMac);
630#elif defined(R__WIN32)
631 // Command for opening a browser on Windows.
632 TString cWindows("start ");
633 cWindows.Append(url);
634 gSystem->Exec(cWindows);
635#else
636 // Command for opening a browser in Linux.
637 TString cLinux("xdg-open ");
638 // For Linux we check if the DISPLAY is set.
639 if (gSystem->Getenv("DISPLAY")) {
640 // If the DISPLAY is set it will open the browser.
641 cLinux.Append(url);
642 gSystem->Exec(cLinux);
643 } else {
644 // Else the user will have a warning and the URL in the terminal.
645 Warning("OpenInBrowser", "The $DISPLAY is not set! Please open (e.g. Ctrl-click) %s\n", url.Data());
646 }
647#endif
648}
649
650namespace {
651enum EUrl { kURLforClass, kURLforNameSpace, kURLforStruct };
652////////////////////////////////////////////////////////////////////////////////
653/// The function generates a URL address for class or namespace (scopeName).
654/// This is the URL to the online reference guide, generated by Doxygen.
655/// With the enumeration "EUrl" we pick which case we need - the one for
656/// class (kURLforClass) or the one for namespace (kURLforNameSpace).
657///
658/// \param[in] scopeName the name of the class or the namespace
659/// \param[in] scopeType the enumerator for class or namespace
660
661static TString UrlGenerator(TString scopeName, EUrl scopeType)
662{
663 // We start the URL with a static part, the same for all scopes and members.
664 TString url = "https://root.cern/doc/";
665 // Then we check the ROOT version used.
666 TPRegexp re4(R"(.*/(v\d)-(\d\d)-00-patches)");
667 const char *branchName = gROOT->GetGitBranch();
668 TObjArray *objarr = re4.MatchS(branchName);
669 TString version;
670 // We extract the correct version name for the URL.
671 if (objarr && objarr->GetEntries() == 3) {
672 // We have a valid version of ROOT and we will extract the correct name for the URL.
673 version = ((TObjString *)objarr->At(1))->GetString() + ((TObjString *)objarr->At(2))->GetString();
674 } else {
675 // If it's not a supported version, we will go to "master" branch.
676 version = "master";
677 }
678 delete objarr;
679 url.Append(version);
680 url.Append("/");
681 // We will replace all "::" with "_1_1" and all "_" with "__" in the
682 // classes definitions, due to Doxygen syntax requirements.
683 scopeName.ReplaceAll("_", "__");
684 scopeName.ReplaceAll("::", "_1_1");
685 // We build the URL for the correct scope type and name.
686 if (scopeType == kURLforClass) {
687 url.Append("class");
688 } else if (scopeType == kURLforStruct) {
689 url.Append("struct");
690 } else {
691 url.Append("namespace");
692 }
693 url.Append(scopeName);
694 url.Append(".html");
695 return url;
696}
697} // namespace
698
699namespace {
700////////////////////////////////////////////////////////////////////////////////
701/// The function returns a TString with the arguments of a method from the
702/// scope (scopeName), but modified with respect to Doxygen syntax - spacing
703/// around special symbols and adding the missing scopes ("std::").
704/// "FormatMethodArgsForDoxygen" works for functions defined inside namespaces
705/// as well. We avoid looking up twice for the TFunction by passing "func".
706///
707/// \param[in] scopeName the name of the class/namespace/struct
708/// \param[in] func pointer to the method
709
710static TString FormatMethodArgsForDoxygen(const TString &scopeName, TFunction *func)
711{
712 // With "GetSignature" we get the arguments of the method and put them in a TString.
713 TString methodArguments = func->GetSignature();
714 // "methodArguments" is modified with respect of Doxygen requirements.
715 methodArguments.ReplaceAll(" = ", "=");
716 methodArguments.ReplaceAll("* ", " *");
717 methodArguments.ReplaceAll("*=", " *=");
718 methodArguments.ReplaceAll("*)", " *)");
719 methodArguments.ReplaceAll("*,", " *,");
720 methodArguments.ReplaceAll("*& ", " *&");
721 methodArguments.ReplaceAll("& ", " &");
722 // TODO: prepend "std::" to all stdlib classes!
723 methodArguments.ReplaceAll("ostream", "std::ostream");
724 methodArguments.ReplaceAll("istream", "std::istream");
725 methodArguments.ReplaceAll("map", "std::map");
726 methodArguments.ReplaceAll("vector", "std::vector");
727 // We need to replace the "currentClass::foo" with "foo" in the arguments.
728 // TODO: protect the global functions.
729 TString scopeNameRE("\\b");
730 scopeNameRE.Append(scopeName);
731 scopeNameRE.Append("::\\b");
732 TPRegexp argFix(scopeNameRE);
733 argFix.Substitute(methodArguments, "");
734 return methodArguments;
735}
736} // namespace
737
738namespace {
739////////////////////////////////////////////////////////////////////////////////
740/// The function checks if a member function of a scope is defined as inline.
741/// If so, it also checks if it is virtual. Then the return type of "func" is
742/// modified for the need of Doxygen and with respect to the function
743/// definition. We pass pointer to the method (func) to not re-do the
744/// TFunction lookup.
745///
746/// \param[in] scopeName the name of the class/namespace/struct
747/// \param[in] func pointer to the method
748
749static TString FormatReturnTypeForDoxygen(const TString &scopeName, TFunction *func)
750{
751 // We put the return type of "func" in a TString "returnType".
752 TString returnType = func->GetReturnTypeName();
753 // If the return type is a type nested in the current class, it will appear scoped (Class::Enumeration).
754 // Below we make sure to remove the current class, because the syntax of Doxygen requires it.
755 TString scopeNameRE("\\b");
756 scopeNameRE.Append(scopeName);
757 scopeNameRE.Append("::\\b");
758 TPRegexp returnFix(scopeNameRE);
759 returnFix.Substitute(returnType, "");
760 // We check is if the method is defined as inline.
761 if (func->ExtraProperty() & kIsInlined) {
762 // We check if the function is defined as virtual.
763 if (func->Property() & kIsVirtual) {
764 // If the function is virtual, we append "virtual" before the return type.
765 returnType.Prepend("virtual ");
766 }
767 returnType.ReplaceAll(" *", "*");
768 } else {
769 // If the function is not inline we only change the spacing in "returnType"
770 returnType.ReplaceAll("*", " *");
771 }
772 // In any case (with no respect to virtual/inline check) we need to change
773 // the return type as following.
774 // TODO: prepend "std::" to all stdlib classes!
775 returnType.ReplaceAll("istream", "std::istream");
776 returnType.ReplaceAll("ostream", "std::ostream");
777 returnType.ReplaceAll("map", "std::map");
778 returnType.ReplaceAll("vector", "std::vector");
779 returnType.ReplaceAll("&", " &");
780 return returnType;
781}
782} // namespace
783
784namespace {
785////////////////////////////////////////////////////////////////////////////////
786/// The function generates a URL for "dataMemberName" defined in "scopeName".
787/// It returns a TString with the URL used in the online reference guide,
788/// generated with Doxygen. For data members the URL consist of 2 parts -
789/// URL for "scopeName" and a part for "dataMemberName".
790/// For enumerator, the URL could be separated into 3 parts - URL for
791/// "scopeName", part for the enumeration and a part for the enumerator.
792///
793/// \param[in] scopeName the name of the class/namespace/struct
794/// \param[in] dataMemberName the name of the data member/enumerator
795/// \param[in] dataMember pointer to the data member/enumerator
796/// \param[in] scopeType enumerator to the scope type
797
798static TString
799GetUrlForDataMember(const TString &scopeName, const TString &dataMemberName, TDataMember *dataMember, EUrl scopeType)
800{
801 // We first check if the data member is not enumerator.
802 if (!dataMember->IsEnum()) {
803 // If we work with data members, we have to append a hashed with MD5 text, consisting of:
804 // "Type ClassName::DataMemberNameDataMemberName(arguments)".
805 // We first get the type of the data member.
806 TString md5DataMember(dataMember->GetFullTypeName());
807 md5DataMember.Append(" ");
808 // We append the scopeName and "::".
809 md5DataMember.Append(scopeName);
810 md5DataMember.Append("::");
811 // We append the dataMemberName twice.
812 md5DataMember.Append(dataMemberName);
813 md5DataMember.Append(dataMemberName);
814 // We call UrlGenerator for the scopeName.
815 TString urlForDataMember = UrlGenerator(scopeName, scopeType);
816 // Then we append "#a" and the hashed text.
817 urlForDataMember.Append("#a");
818 urlForDataMember.Append(md5DataMember.MD5());
819 return urlForDataMember;
820 }
821 // If the data member is enumerator, then we first have to check if the enumeration is anonymous.
822 // Doxygen requires different syntax for anonymous enumeration ("scopeName::@1@1").
823 // We create a TString with the name of the scope and the enumeration from which the enumerator is.
824 TString scopeEnumeration = dataMember->GetTrueTypeName();
825 TString md5EnumClass;
826 if (scopeEnumeration.Contains("(unnamed)")) {
827 // FIXME: need to investigate the numbering scheme.
828 md5EnumClass.Append(scopeName);
829 md5EnumClass.Append("::@1@1");
830 } else {
831 // If the enumeration is not anonymous we put "scopeName::Enumeration" in a TString,
832 // which will be hashed with MD5 later.
833 md5EnumClass.Append(scopeEnumeration);
834 // We extract the part after "::" (this is the enumerator name).
835 TString enumOnlyName = TClassEdit::GetUnqualifiedName(scopeEnumeration);
836 // The syntax is "Class::EnumeratorEnumerator
837 md5EnumClass.Append(enumOnlyName);
838 }
839 // The next part of the URL is hashed "@ scopeName::EnumeratorEnumerator".
840 TString md5Enumerator("@ ");
841 md5Enumerator.Append(scopeName);
842 md5Enumerator.Append("::");
843 md5Enumerator.Append(dataMemberName);
844 md5Enumerator.Append(dataMemberName);
845 // We make the URL for the "scopeName".
846 TString url = UrlGenerator(scopeName, scopeType);
847 // Then we have to append the hashed text for the enumerator.
848 url.Append("#a");
849 url.Append(md5EnumClass.MD5());
850 // We append "a" and then the next hashed text.
851 url.Append("a");
852 url.Append(md5Enumerator.MD5());
853 return url;
854}
855} // namespace
856
857namespace {
858////////////////////////////////////////////////////////////////////////////////
859/// The function generates URL for enumeration. The hashed text consist of:
860/// "Class::EnumerationEnumeration".
861///
862/// \param[in] scopeName the name of the class/namespace/struct
863/// \param[in] enumeration the name of the enumeration
864/// \param[in] scopeType enumerator for class/namespace/struct
865
866static TString GetUrlForEnumeration(TString scopeName, const TString &enumeration, EUrl scopeType)
867{
868 // The URL consists of URL for the "scopeName", "#a" and hashed as MD5 text.
869 // The text is "Class::EnumerationEnumeration.
870 TString md5Enumeration(scopeName);
871 md5Enumeration.Append("::");
872 md5Enumeration.Append(enumeration);
873 md5Enumeration.Append(enumeration);
874 // We make the URL for the scope "scopeName".
875 TString url(UrlGenerator(scopeName, scopeType));
876 // Then we have to append "#a" and the hashed text.
877 url.Append("#a");
878 url.Append(md5Enumeration.MD5());
879 return url;
880}
881} // namespace
882
883namespace {
884enum EMethodKind { kURLforMethod, kURLforStructor };
885////////////////////////////////////////////////////////////////////////////////
886/// The function generates URL for any member function (including Constructor/
887/// Destructor) of "scopeName". Doxygen first generates the URL for the scope.
888/// We do that with the help of "UrlGenerator". Then we append "#a" and a
889/// hashed with MD5 text. It consists of:
890/// "ReturnType ScopeName::MethodNameMethodName(Method arguments)".
891/// For constructor/destructor of a class, the return type is not appended.
892///
893/// \param[in] scopeName the name of the class/namespace/struct
894/// \param[in] methodName the name of the method from the scope
895/// \param[in] func pointer to the method
896/// \param[in] methodType enumerator for method or constructor
897/// \param[in] scopeType enumerator for class/namespace/struct
898
899static TString GetUrlForMethod(const TString &scopeName, const TString &methodName, TFunction *func,
900 EMethodKind methodType, EUrl scopeType)
901{
902 TString md5Text;
903 if (methodType == kURLforMethod) {
904 // In the case of method, we append the return type too.
905 // "FormatReturnTypeForDoxygen" modifies the return type with respect to Doxygen's requirement.
906 md5Text.Append((FormatReturnTypeForDoxygen(scopeName, func)));
907 if (scopeType == kURLforNameSpace) {
908 // We need to append "constexpr" if we work with constexpr functions in namespaces.
909 if (func->Property() & kIsConstexpr) {
910 md5Text.Prepend("constexpr ");
911 }
912 }
913 md5Text.Append(" ");
914 }
915 // We append ScopeName::MethodNameMethodName.
916 md5Text.Append(scopeName);
917 md5Text.Append("::");
918 md5Text.Append(methodName);
919 md5Text.Append(methodName);
920 // We use "FormatMethodArgsForDoxygen" to modify the arguments of Method with respect of Doxygen.
921 md5Text.Append(FormatMethodArgsForDoxygen(scopeName, func));
922 // We generate the URL for the class/namespace/struct.
923 TString url = UrlGenerator(scopeName, scopeType);
924 url.Append("#a");
925 // We append the hashed text.
926 url.Append(md5Text.MD5());
927 return url;
928}
929} // namespace
930
931
932////////////////////////////////////////////////////////////////////////////////
933/// It opens the online reference guide, generated with Doxygen, for the
934/// chosen scope (class/namespace/struct) or member (method/function/
935/// data member/enumeration/enumerator. If the user types incorrect value,
936/// it will return an error or warning.
937///
938/// \param[in] strippedClass the scope or scope::member
939
941{
942 // We check if the user is searching for a scope and if the scope exists.
943 if (TClass *clas = TClass::GetClass(strippedClass)) {
944 // We check what scope he is searching for (class/namespace/struct).
945 // Enumerators will switch between the possible cases.
946 EUrl scopeType;
947 if (clas->Property() & kIsNamespace) {
948 scopeType = kURLforNameSpace;
949 } else if (clas->Property() & kIsStruct) {
950 scopeType = kURLforStruct;
951 } else {
952 scopeType = kURLforClass;
953 }
954 // If the user search directly for a scope we open the URL for him with OpenInBrowser.
955 OpenInBrowser(UrlGenerator(strippedClass, scopeType));
956 return;
957 }
958 // Else we subtract the name of the method and remove it from the command.
959 TString memberName = TClassEdit::GetUnqualifiedName(strippedClass);
960 // Error out if "strippedClass" is un-scoped (and it's not a class, see `TClass::GetClass(strippedClass)` above).
961 // TODO: Global functions.
962 if (strippedClass == memberName) {
963 Error("OpenReferenceGuideFor", "Unknown entity \"%s\" - global variables / functions not supported yet!",
964 strippedClass.Data());
965 return;
966 }
967 // Else we remove the member name to be left with the scope.
968 TString scopeName = strippedClass(0, strippedClass.Length() - memberName.Length() - 2);
969 // We check if the scope exists in ROOT.
970 TClass *cl = TClass::GetClass(scopeName);
971 if (!cl) {
972 // That's a member of something ROOT doesn't know.
973 Warning("OpenReferenceGuideFor", "\"%s\" does not exist in ROOT!", scopeName.Data());
974 return;
975 }
976 // We have enumerators for the three available cases - class, namespace and struct.
977 EUrl scopeType;
978 if (cl->Property() & kIsNamespace) {
979 scopeType = kURLforNameSpace;
980 } else if (cl->Property() & kIsStruct) {
981 scopeType = kURLforStruct;
982 } else {
983 scopeType = kURLforClass;
984 }
985 // If the user wants to search for a method, we take its name (memberName) and
986 // modify it - we delete everything starting at the first "(" so the user won't have to
987 // do it by hand when they use Tab.
988 int bracket = memberName.First("(");
989 if (bracket > 0) {
990 memberName.Remove(bracket);
991 }
992 // We check if "memberName" is a member function of "cl" or any of its base classes.
993 if (TFunction *func = cl->GetMethodAllAny(memberName)) {
994 // If so we find the name of the class that it belongs to.
995 TString baseClName = ((TMethod *)func)->GetClass()->GetName();
996 // We define an enumerator to distinguish between structor and method.
997 EMethodKind methodType;
998 // We check if "memberName" is a constructor.
999 if (baseClName == memberName) {
1000 methodType = kURLforStructor;
1001 // We check if "memberName" is a destructor.
1002 } else if (memberName[0] == '~') {
1003 methodType = kURLforStructor;
1004 // We check if "memberName" is a method.
1005 } else {
1006 methodType = kURLforMethod;
1007 }
1008 // We call "GetUrlForMethod" for the correct class and scope.
1009 OpenInBrowser(GetUrlForMethod(baseClName, memberName, func, methodType, scopeType));
1010 return;
1011 }
1012 // We check if "memberName" is an enumeration.
1013 if (cl->GetListOfEnums()->FindObject(memberName)) {
1014 // If so with OpenInBrowser we open the URL generated with GetUrlForEnumeration
1015 // with respect to the "scopeType".
1016 OpenInBrowser(GetUrlForEnumeration(scopeName, memberName, scopeType));
1017 return;
1018 }
1019
1020 // We check if "memberName" is enumerator defined in one the base classes of "scopeName".
1021 if (auto enumerator = (TDataMember *)cl->GetListOfAllPublicDataMembers()->FindObject(memberName)) {
1022 // We find the actual scope (might be in a base) and open the URL in a browser.
1023 TString baseClName = ((TMethod *)enumerator->GetClass())->GetName();
1024 OpenInBrowser(GetUrlForDataMember(baseClName, memberName, enumerator, scopeType));
1025 return;
1026 }
1027
1028 // Warning message will appear if the user types the function name incorrectly
1029 // or the function is not a member function of "cl" or any of its base classes.
1030 Warning("Help", "cannot find \"%s\" as member of %s or its base classes! Check %s\n", memberName.Data(),
1031 scopeName.Data(), UrlGenerator(scopeName, scopeType).Data());
1032}
1033
1034////////////////////////////////////////////////////////////////////////////////
1035/// The function lists useful commands (".help") or opens the online reference
1036/// guide, generated with Doxygen (".help scope" or ".help scope::member").
1037/// \note You can use ".?" as the short version of ".help"
1038/// \param[in] line command from the command line
1039
1040void TApplication::Help(const char *line)
1041{
1042 // We first check if the user wants to print the help on the interpreter.
1043 TString strippedCommand = TString(line).Strip(TString::kBoth);
1044 // If the user chooses ".help" or ".?".
1045 if ((strippedCommand == ".help") || (strippedCommand == ".?")) {
1046 gInterpreter->ProcessLine(line);
1047 Printf("\n ROOT special commands.");
1048 Printf(" ==============================================================================");
1049 Printf(" .L <filename>[flags]: load the given file with optional flags like\n"
1050 " + to compile or ++ to force recompile.\n"
1051 " Type .? TSystem::CompileMacro for a list of all flags.");
1052 Printf(" .(x|X) <filename>[flags](args) :\n"
1053 " same as .L <filename>[flags] and runs then a function\n"
1054 " with signature: ret_type filename(args).");
1055 Printf(" .credits : show credits");
1056 Printf(" .demo : launch GUI demo");
1057 Printf(" .help Class::Member : open reference guide for that class member (or .?).\n"
1058 " Specifying '::Member' is optional.");
1059 Printf(" .help edit : show line editing shortcuts (or .?)");
1060 Printf(" .license : show license");
1061 Printf(" .ls : list contents of current TDirectory");
1062 Printf(" .pwd : show current TDirectory, pad and style");
1063 Printf(" .quit (or .exit) : quit ROOT (long form of .q)");
1064 Printf(" .R [user@]host[:dir] [-l user] [-d dbg] [script] :\n"
1065 " launch process in a remote host");
1066 Printf(" .qqq : quit ROOT - mandatory");
1067 Printf(" .qqqqq : exit process immediately");
1068 Printf(" .qqqqqqq : abort process");
1069 Printf(" .which [file] : show path of macro file");
1070 Printf(" .![OS_command] : execute OS-specific shell command");
1071 Printf(" .!root -? : print ROOT usage (CLI options)");
1072 return;
1073 } else {
1074 // If the user wants to use the extended ".help scopeName" command to access
1075 // the online reference guide, we first check if the command starts correctly.
1076 if ((!strippedCommand.BeginsWith(".help ")) && (!strippedCommand.BeginsWith(".? "))) {
1077 Error("Help", "Unknown command!");
1078 return;
1079 }
1080 // We remove the command ".help" or ".?" from the TString.
1081 if (strippedCommand.BeginsWith(".? ")) {
1082 strippedCommand.Remove(0, 3);
1083 } else {
1084 strippedCommand.Remove(0, 5);
1085 }
1086 // We strip the command line after removing ".help" or ".?".
1087 strippedCommand = strippedCommand.Strip(TString::kBoth);
1088
1089 if (strippedCommand == "edit") {
1090 Printf("\n ROOT terminal keyboard shortcuts (GNU-readline style).");
1091 #ifdef R__MACOSX
1092 #define FOOTNOTE " *"
1093 Printf("* Some of these commands might be intercepted by macOS predefined system shortcuts.");
1094 // https://apple.stackexchange.com/questions/18043/how-can-i-make-ctrlright-left-arrow-stop-changing-desktops-in-lion
1095 #else
1096 #define FOOTNOTE ""
1097 #endif
1098 Printf(" ==============================================================================");
1099 Printf(" Arrow_Left : move cursor left [Ctrl+B]");
1100 Printf(" Arrow_Right : move cursor right [Ctrl+F] [Ctrl+G]");
1101 #ifdef R__MACOSX
1102 Printf(" Fn+Arrow_Left : move cursor to beginning of line [Ctrl+A]");
1103 #else
1104 Printf(" Home : move cursor to beginning of line [Ctrl+A]");
1105 #endif
1106 #ifdef R__MACOSX
1107 Printf(" Fn+Arrow_Right : move cursor to end of line [Ctrl+E]");
1108 #else
1109 Printf(" End : move cursor to end of line [Ctrl+E]");
1110 #endif
1111 Printf(" Ctrl+Arrow_Left : jump to previous word [Esc,B] [Alt,B]" FOOTNOTE);
1112 Printf(" Ctrl+Arrow_Right : jump to next word [Esc,F] [Alt,F]" FOOTNOTE);
1113
1114 Printf(" Backspace : delete previous character [Ctrl+H]");
1115 Printf(" Del : delete next character [Ctrl+D]");
1116 Printf(" Esc,Backspace : delete previous word [Ctrl+W] [Esc,Ctrl+H] [Alt+Backspace] [Esc,Del] [Esc,Ctrl+Del]" FOOTNOTE);// Del is 0x7F on macOS
1117 Printf(" Ctrl+Del : delete next word [Esc,D] [Alt,D]" FOOTNOTE);
1118 Printf(" Ctrl+U : cut all characters between cursor and start of line");
1119 Printf(" Ctrl+K : cut all characters between cursor and end of line");
1120
1121 Printf(" Ctrl+T : transpose characters");
1122 Printf(" Esc,C : character to upper and jump to next word");
1123 Printf(" Esc,L : word to lower case and jump to its end");
1124 Printf(" Esc,U : word to upper case and jump to its end");
1125 Printf(" Ctrl+Shift+C : copy clipboard content");
1126 Printf(" Ctrl+Shift+V : paste clipboard content [Ctrl+Y] [Alt+Y]");
1127 #ifdef R__MACOSX
1128 Printf(" Fn+Enter : toggle overwrite mode");
1129 #else
1130 Printf(" Ins : toggle overwrite mode");
1131 #endif
1132
1133 Printf(" Ctrl+_ : undo last keypress action");
1134 Printf(" Tab : autocomplete command or print suggestions [Ctrl+I] [Esc,Tab]");
1135 Printf(" Enter : execute command [Ctrl+J] [Ctrl+M]");
1136 Printf(" Ctrl+L : clear prompt screen");
1137 Printf(" Ctrl+D : quit ROOT (if empty line)");
1138 Printf(" Ctrl+C : send kSigInt interrupt signal");
1139 Printf(" Ctrl+Z : send kSigStop pause job signal");
1140
1141 Printf(" Arrow_Down : navigate downwards in command history [Ctrl+N]");
1142 Printf(" Arrow_Up : navigate upwards in command history [Ctrl+P]");
1143 Printf(" Ctrl+R ; Ctrl+S : search command in your history by typing a string.\n"
1144 " Use Backspace if you mistyped (but not arrows).\n"
1145 " Press Ctrl+R (Ctrl+S) repeateadly to navigate matches in reverse (forward) order");
1146 Printf(" Arrow_Right : after Ctrl+R (Ctrl+S), select current match of the history search\n"
1147 " [Ctrl+O] [Enter] [Ctrl+J] [Ctrl+M] [Arrow_Left] [Esc,Esc].\n"
1148 " Use Ctrl+F or Ctrl+G to cancel search and revert original line");
1149
1150 return;
1151 }
1152 // We call the function what handles the extended ".help scopeName" command.
1153 OpenReferenceGuideFor(strippedCommand);
1154 }
1155}
1156
1157/// Load shared libs necessary for graphics. These libraries are only
1158/// loaded when gROOT->IsBatch() is kFALSE.
1159
1161{
1162 if (gROOT->IsBatch())
1163 return;
1164
1165 if (auto h = gROOT->GetPluginManager()->FindHandler("TVirtualPad"))
1166 if (h->LoadPlugin() == -1)
1167 return;
1168
1169 TString name;
1170 TString title1 = "ROOT interface to ";
1171 TString nativex, title;
1172
1173#ifdef R__WIN32
1174 nativex = "win32gdk";
1175 name = "Win32gdk";
1176 title = title1 + "Win32gdk";
1177#elif defined(R__HAS_COCOA)
1178 nativex = "quartz";
1179 name = "quartz";
1180 title = title1 + "Quartz";
1181#else
1182 nativex = "x11";
1183 name = "X11";
1184 title = title1 + "X11";
1185#endif
1186
1187 TString guiBackend = gEnv->GetValue("Gui.Backend", "native");
1188 guiBackend.ToLower();
1189 if (guiBackend == "native") {
1190 guiBackend = nativex;
1191 } else {
1192 name = guiBackend;
1193 title = title1 + guiBackend;
1194 }
1195
1196 if (auto h = gROOT->GetPluginManager()->FindHandler("TVirtualX", guiBackend)) {
1197 if (h->LoadPlugin() == -1) {
1198 gROOT->SetBatch(kTRUE);
1199 return;
1200 }
1201 gVirtualX = (TVirtualX *) h->ExecPlugin(2, name.Data(), title.Data());
1203 }
1204
1205 TString guiFactory = gEnv->GetValue("Gui.Factory", "native");
1206 guiFactory.ToLower();
1207 if (guiFactory == "native")
1208 guiFactory = "root";
1209
1210 if (auto h = gROOT->GetPluginManager()->FindHandler("TGuiFactory", guiFactory)) {
1211 if (h->LoadPlugin() == -1) {
1212 gROOT->SetBatch(kTRUE);
1213 return;
1214 }
1215 gGuiFactory = (TGuiFactory *) h->ExecPlugin(0);
1216 }
1217}
1218
1219////////////////////////////////////////////////////////////////////////////////
1220/// Switch to batch mode.
1221
1223{
1224 gROOT->SetBatch();
1227#ifndef R__WIN32
1228 if (gVirtualX != gGXBatch) delete gVirtualX;
1229#endif
1231}
1232
1233////////////////////////////////////////////////////////////////////////////////
1234/// Parse the content of a line starting with ".R" (already stripped-off)
1235/// The format is
1236/// ~~~ {.cpp}
1237/// [user@]host[:dir] [-l user] [-d dbg] [script]
1238/// ~~~
1239/// The variable 'dir' is the remote directory to be used as working dir.
1240/// The username can be specified in two ways, "-l" having the priority
1241/// (as in ssh).
1242/// A 'dbg' value > 0 gives increasing verbosity.
1243/// The last argument 'script' allows to specify an alternative script to
1244/// be executed remotely to startup the session.
1245
1247 TString &hostdir, TString &user,
1248 Int_t &dbg, TString &script)
1249{
1250 if (!ln || strlen(ln) <= 0)
1251 return 0;
1252
1253 Int_t rc = 0;
1254 Bool_t isHostDir = kTRUE;
1255 Bool_t isScript = kFALSE;
1256 Bool_t isUser = kFALSE;
1257 Bool_t isDbg = kFALSE;
1258
1259 TString line(ln);
1260 TString tkn;
1261 Int_t from = 0;
1262 while (line.Tokenize(tkn, from, " ")) {
1263 if (tkn == "-l") {
1264 // Next is a user name
1265 isUser = kTRUE;
1266 } else if (tkn == "-d") {
1267 isDbg = kTRUE;
1268 } else if (tkn == "-close") {
1269 rc = 1;
1270 } else if (tkn.BeginsWith("-")) {
1271 ::Warning("TApplication::ParseRemoteLine","unknown option: %s", tkn.Data());
1272 } else {
1273 if (isUser) {
1274 user = tkn;
1275 isUser = kFALSE;
1276 } else if (isDbg) {
1277 dbg = tkn.Atoi();
1278 isDbg = kFALSE;
1279 } else if (isHostDir) {
1280 hostdir = tkn;
1281 hostdir.ReplaceAll(":","/");
1282 isHostDir = kFALSE;
1283 isScript = kTRUE;
1284 } else if (isScript) {
1285 // Add everything left
1286 script = tkn;
1287 script.Insert(0, "\"");
1288 script += "\"";
1289 // isScript = kFALSE; // [clang-tidy] never read
1290 break;
1291 }
1292 }
1293 }
1294
1295 // Done
1296 return rc;
1297}
1298
1299////////////////////////////////////////////////////////////////////////////////
1300/// Process the content of a line starting with ".R" (already stripped-off)
1301/// The format is
1302/// ~~~ {.cpp}
1303/// [user@]host[:dir] [-l user] [-d dbg] [script] | [host] -close
1304/// ~~~
1305/// The variable 'dir' is the remote directory to be used as working dir.
1306/// The username can be specified in two ways, "-l" having the priority
1307/// (as in ssh).
1308/// A 'dbg' value > 0 gives increasing verbosity.
1309/// The last argument 'script' allows to specify an alternative script to
1310/// be executed remotely to startup the session.
1311
1313{
1314 if (!line) return 0;
1315
1316 if (!strncmp(line, "-?", 2) || !strncmp(line, "-h", 2) ||
1317 !strncmp(line, "--help", 6)) {
1318 Info("ProcessRemote", "remote session help:");
1319 Printf(".R [user@]host[:dir] [-l user] [-d dbg] [[<]script] | [host] -close");
1320 Printf("Create a ROOT session on the specified remote host.");
1321 Printf("The variable \"dir\" is the remote directory to be used as working dir.");
1322 Printf("The username can be specified in two ways, \"-l\" having the priority");
1323 Printf("(as in ssh). A \"dbg\" value > 0 gives increasing verbosity.");
1324 Printf("The last argument \"script\" allows to specify an alternative script to");
1325 Printf("be executed remotely to startup the session, \"roots\" being");
1326 Printf("the default. If the script is preceded by a \"<\" the script will be");
1327 Printf("sourced, after which \"roots\" is executed. The sourced script can be ");
1328 Printf("used to change the PATH and other variables, allowing an alternative");
1329 Printf("\"roots\" script to be found.");
1330 Printf("To close down a session do \".R host -close\".");
1331 Printf("To switch between sessions do \".R host\", to switch to the local");
1332 Printf("session do \".R\".");
1333 Printf("To list all open sessions do \"gApplication->GetApplications()->Print()\".");
1334 return 0;
1335 }
1336
1337 TString hostdir, user, script;
1338 Int_t dbg = 0;
1339 Int_t rc = ParseRemoteLine(line, hostdir, user, dbg, script);
1340 if (hostdir.Length() <= 0) {
1341 // Close the remote application if required
1342 if (rc == 1) {
1344 delete fAppRemote;
1345 }
1346 // Return to local run
1347 fAppRemote = nullptr;
1348 // Done
1349 return 1;
1350 } else if (rc == 1) {
1351 // close an existing remote application
1352 TApplication *ap = TApplication::Open(hostdir, 0, nullptr);
1353 if (ap) {
1355 delete ap;
1356 }
1357 }
1358 // Attach or start a remote application
1359 if (user.Length() > 0)
1360 hostdir.Insert(0,Form("%s@", user.Data()));
1361 const char *sc = (script.Length() > 0) ? script.Data() : nullptr;
1362 TApplication *ap = TApplication::Open(hostdir, dbg, sc);
1363 if (ap) {
1364 fAppRemote = ap;
1365 }
1366
1367 // Done
1368 return 1;
1369}
1370
1371namespace {
1372 static int PrintFile(const char* filename) {
1373 TString sFileName(filename);
1374 gSystem->ExpandPathName(sFileName);
1375 if (gSystem->AccessPathName(sFileName)) {
1376 Error("ProcessLine()", "Cannot find file %s", filename);
1377 return 1;
1378 }
1379 std::ifstream instr(sFileName);
1380 TString content;
1381 content.ReadFile(instr);
1382 Printf("%s", content.Data());
1383 return 0;
1384 }
1385 } // namespace
1386
1387////////////////////////////////////////////////////////////////////////////////
1388/// Process a single command line, either a C++ statement or an interpreter
1389/// command starting with a ".".
1390/// Return the return value of the command cast to a long.
1391
1393{
1394 if (!line || !*line) return 0;
1395
1396 // If we are asked to go remote do it
1397 if (!strncmp(line, ".R", 2)) {
1398 Int_t n = 2;
1399 while (*(line+n) == ' ')
1400 n++;
1401 return ProcessRemote(line+n, err);
1402 }
1403
1404 // Redirect, if requested
1407 return fAppRemote->ProcessLine(line, err);
1408 }
1409
1410 if (!strncasecmp(line, ".qqqqqqq", 7)) {
1411 gSystem->Abort();
1412 } else if (!strncasecmp(line, ".qqqqq", 5)) {
1413 Info("ProcessLine", "Bye... (try '.qqqqqqq' if still running)");
1414 gSystem->Exit(1);
1415 } else if (!strncasecmp(line, ".exit", 4) || !strncasecmp(line, ".quit", 2)) {
1416 Terminate(0);
1417 return 0;
1418 }
1419
1420 if (!strncmp(line, ".?", 2) || !strncmp(line, ".help", 5)) {
1421 Help(line);
1422 return 1;
1423 }
1424
1425 if (!strncmp(line, ".demo", 5)) {
1426 if (gROOT->IsBatch()) {
1427 Error("ProcessLine", "Cannot show demos in batch mode!");
1428 return 1;
1429 }
1430 ProcessLine(".x " + TROOT::GetTutorialDir() + "/demos.C");
1431 return 0;
1432 }
1433
1434 if (!strncmp(line, ".license", 8)) {
1435 return PrintFile(TROOT::GetDocDir() + "/LICENSE");
1436 }
1437
1438 if (!strncmp(line, ".credits", 8)) {
1439 TString credits = TROOT::GetDocDir() + "/CREDITS";
1440 if (gSystem->AccessPathName(credits, kReadPermission))
1441 credits = TROOT::GetDocDir() + "/README/CREDITS";
1442 return PrintFile(credits);
1443 }
1444
1445 if (!strncmp(line, ".pwd", 4)) {
1446 if (gDirectory)
1447 Printf("Current directory: %s", gDirectory->GetPath());
1448 if (gPad)
1449 Printf("Current pad: %s", gPad->GetName());
1450 if (gStyle)
1451 Printf("Current style: %s", gStyle->GetName());
1452 return 1;
1453 }
1454
1455 if (!strncmp(line, ".ls", 3)) {
1456 const char *opt = nullptr;
1457 if (line[3]) opt = &line[3];
1458 if (gDirectory) gDirectory->ls(opt);
1459 return 1;
1460 }
1461
1462 if (!strncmp(line, ".which", 6)) {
1463 char *fn = Strip(line+7);
1464 char *s = strtok(fn, "+("); // this method does not need to be reentrant
1466 if (!mac)
1467 Printf("No macro %s in path %s", s, TROOT::GetMacroPath());
1468 else
1469 Printf("%s", mac);
1470 delete [] fn;
1471 delete [] mac;
1472 return mac ? 1 : 0;
1473 }
1474
1475 if (!strncmp(line, ".L", 2) || !strncmp(line, ".U", 2)) {
1476 TString aclicMode, arguments, io;
1477 TString fname = gSystem->SplitAclicMode(line+3, aclicMode, arguments, io);
1478
1479 char *mac = gSystem->Which(TROOT::GetMacroPath(), fname, kReadPermission);
1480 if (arguments.Length())
1481 Warning("ProcessLine", "argument(s) \"%s\" ignored with .%c", arguments.Data(), line[1]);
1482 Longptr_t retval = 0;
1483 if (!mac) {
1484 Error("ProcessLine", "macro %s not found in path %s", fname.Data(), TROOT::GetMacroPath());
1485 } else {
1486 TString cmd(line + 1);
1487 Ssiz_t posSpace = cmd.Index(' ');
1488 if (posSpace == kNPOS)
1489 cmd.Remove(1);
1490 else
1491 cmd.Remove(posSpace);
1492 auto tempbuf = TString::Format(".%s %s%s%s", cmd.Data(), mac, aclicMode.Data(), io.Data());
1493 delete[] mac;
1494 if (sync)
1495 retval = gInterpreter->ProcessLineSynch(tempbuf.Data(), (TInterpreter::EErrorCode *)err);
1496 else
1497 retval = gInterpreter->ProcessLine(tempbuf.Data(), (TInterpreter::EErrorCode *)err);
1498 }
1499
1500 InitializeGraphics(gROOT->IsWebDisplay());
1501
1502 return retval;
1503 }
1504
1505 if (!strncmp(line, ".X", 2) || !strncmp(line, ".x", 2)) {
1506 return ProcessFile(line+3, err, line[2] == 'k');
1507 }
1508
1509 if (!strcmp(line, ".reset")) {
1510 // Do nothing, .reset disabled in Cling because too many side effects
1511 Printf("*** .reset not allowed, please use gROOT->Reset() ***");
1512 return 0;
1513
1514#if 0
1515 // delete the ROOT dictionary since CINT will destroy all objects
1516 // referenced by the dictionary classes (TClass et. al.)
1517 gROOT->GetListOfClasses()->Delete();
1518 // fall through
1519#endif
1520 }
1521
1522 if (sync)
1523 return gInterpreter->ProcessLineSynch(line, (TInterpreter::EErrorCode*)err);
1524 else
1525 return gInterpreter->ProcessLine(line, (TInterpreter::EErrorCode*)err);
1526}
1527
1528////////////////////////////////////////////////////////////////////////////////
1529/// Process a file containing a C++ macro.
1530
1532{
1533 return ExecuteFile(file, error, keep);
1534}
1535
1536////////////////////////////////////////////////////////////////////////////////
1537/// Execute a file containing a C++ macro (static method). Can be used
1538/// while TApplication is not yet created.
1539
1541{
1542 static const Int_t kBufSize = 1024;
1543
1544 if (!file || !*file) return 0;
1545
1546 TString aclicMode;
1547 TString arguments;
1548 TString io;
1549 TString fname = gSystem->SplitAclicMode(file, aclicMode, arguments, io);
1550
1551 char *exnam = gSystem->Which(TROOT::GetMacroPath(), fname, kReadPermission);
1552 if (!exnam) {
1553 ::Error("TApplication::ExecuteFile", "macro %s not found in path %s", fname.Data(),
1555 delete [] exnam;
1556 if (error)
1558 return 0;
1559 }
1560
1561 ::std::ifstream macro(exnam, std::ios::in);
1562 if (!macro.good()) {
1563 ::Error("TApplication::ExecuteFile", "%s no such file", exnam);
1564 if (error)
1566 delete [] exnam;
1567 return 0;
1568 }
1569
1570 char currentline[kBufSize];
1571 char dummyline[kBufSize];
1572 int tempfile = 0;
1573 int comment = 0;
1574 int ifndefc = 0;
1575 int ifdef = 0;
1576 char *s = nullptr;
1577 Bool_t execute = kFALSE;
1578 Longptr_t retval = 0;
1579
1580 while (1) {
1581 bool res = (bool)macro.getline(currentline, kBufSize);
1582 if (macro.eof()) break;
1583 if (!res) {
1584 // Probably only read kBufSize, let's ignore the remainder of
1585 // the line.
1586 macro.clear();
1587 while (!macro.getline(dummyline, kBufSize) && !macro.eof()) {
1588 macro.clear();
1589 }
1590 }
1591 s = currentline;
1592 while (s && (*s == ' ' || *s == '\t')) s++; // strip-off leading blanks
1593
1594 // very simple minded pre-processor parsing, only works in case macro file
1595 // starts with "#ifndef __CINT__". In that case everything till next
1596 // "#else" or "#endif" will be skipped.
1597 if (*s == '#') {
1598 char *cs = Compress(currentline);
1599 if (strstr(cs, "#ifndef__CINT__") ||
1600 strstr(cs, "#if!defined(__CINT__)"))
1601 ifndefc = 1;
1602 else if (ifndefc && (strstr(cs, "#ifdef") || strstr(cs, "#ifndef") ||
1603 strstr(cs, "#ifdefined") || strstr(cs, "#if!defined")))
1604 ifdef++;
1605 else if (ifndefc && strstr(cs, "#endif")) {
1606 if (ifdef)
1607 ifdef--;
1608 else
1609 ifndefc = 0;
1610 } else if (ifndefc && !ifdef && strstr(cs, "#else"))
1611 ifndefc = 0;
1612 delete [] cs;
1613 }
1614 if (!*s || *s == '#' || ifndefc || !strncmp(s, "//", 2)) continue;
1615
1616 if (!comment && (!strncmp(s, ".X", 2) || !strncmp(s, ".x", 2))) {
1617 retval = ExecuteFile(s+3);
1618 execute = kTRUE;
1619 continue;
1620 }
1621
1622 if (!strncmp(s, "/*", 2)) comment = 1;
1623 if (comment) {
1624 // handle slightly more complex cases like: /* */ /*
1625again:
1626 s = strstr(s, "*/");
1627 if (s) {
1628 comment = 0;
1629 s += 2;
1630
1631 while (s && (*s == ' ' || *s == '\t')) s++; // strip-off leading blanks
1632 if (!*s) continue;
1633 if (!strncmp(s, "//", 2)) continue;
1634 if (!strncmp(s, "/*", 2)) {
1635 comment = 1;
1636 goto again;
1637 }
1638 }
1639 }
1640 if (!comment && *s == '{') tempfile = 1;
1641 if (!comment) break;
1642 }
1643 macro.close();
1644
1645 if (!execute) {
1646 TString exname = exnam;
1647 if (!tempfile) {
1648 // We have a script that does NOT contain an unnamed macro,
1649 // so we can call the script compiler on it.
1650 exname += aclicMode;
1651 }
1652 exname += arguments;
1653 exname += io;
1654
1655 TString tempbuf;
1656 if (tempfile) {
1657 tempbuf.Form(".x %s", exname.Data());
1658 } else {
1659 tempbuf.Form(".X%s %s", keep ? "k" : " ", exname.Data());
1660 }
1661 retval = gInterpreter->ProcessLineSynch(tempbuf,(TInterpreter::EErrorCode*)error);
1662 }
1663
1664 delete [] exnam;
1665 return retval;
1666}
1667
1668////////////////////////////////////////////////////////////////////////////////
1669/// Main application eventloop. Calls system dependent eventloop via gSystem.
1670
1672{
1673 SetReturnFromRun(retrn);
1674
1675 fIsRunning = kTRUE;
1676
1677 gSystem->Run();
1679}
1680
1681////////////////////////////////////////////////////////////////////////////////
1682/// Set the command to be executed after the system has been idle for
1683/// idleTimeInSec seconds. Normally called via TROOT::Idle(...).
1684
1685void TApplication::SetIdleTimer(UInt_t idleTimeInSec, const char *command)
1686{
1688 fIdleCommand = command;
1689 fIdleTimer = new TIdleTimer(idleTimeInSec*1000);
1691}
1692
1693////////////////////////////////////////////////////////////////////////////////
1694/// Remove idle timer. Normally called via TROOT::Idle(0).
1695
1697{
1698 if (fIdleTimer) {
1699 // timers are removed from the gSystem timer list by their dtor
1701 }
1702}
1703
1704////////////////////////////////////////////////////////////////////////////////
1705/// Called when system starts idleing.
1706
1708{
1709 if (fIdleTimer) {
1710 fIdleTimer->Reset();
1712 }
1713}
1714
1715////////////////////////////////////////////////////////////////////////////////
1716/// Called when system stops idleing.
1717
1719{
1720 if (fIdleTimer)
1722}
1723
1724////////////////////////////////////////////////////////////////////////////////
1725/// What to do when tab is pressed. Re-implemented by TRint.
1726/// See TTabCom::Hook() for meaning of return values.
1727
1728Int_t TApplication::TabCompletionHook(char* /*buf*/, int* /*pLoc*/, std::ostream& /*out*/)
1729{
1730 return -1;
1731}
1732
1733
1734////////////////////////////////////////////////////////////////////////////////
1735/// Terminate the application by call TSystem::Exit() unless application has
1736/// been told to return from Run(), by a call to SetReturnFromRun().
1737
1739{
1740 Emit("Terminate(Int_t)", status);
1741
1742 if (fReturnFromRun)
1743 gSystem->ExitLoop();
1744 else {
1745 gSystem->Exit(status);
1746 }
1747}
1748
1749////////////////////////////////////////////////////////////////////////////////
1750/// Emit signal when a line has been processed.
1751
1753{
1754 Emit("LineProcessed(const char*)", line);
1755}
1756
1757////////////////////////////////////////////////////////////////////////////////
1758/// Emit signal when console keyboard key was pressed.
1759
1761{
1762 Emit("KeyPressed(Int_t)", key);
1763}
1764
1765////////////////////////////////////////////////////////////////////////////////
1766/// Emit signal when return key was pressed.
1767
1769{
1770 Emit("ReturnPressed(char*)", text);
1771}
1772
1773////////////////////////////////////////////////////////////////////////////////
1774/// Set console echo mode:
1775///
1776/// - mode = kTRUE - echo input symbols
1777/// - mode = kFALSE - noecho input symbols
1778
1780{
1781}
1782
1783////////////////////////////////////////////////////////////////////////////////
1784/// Static function used to create a default application environment.
1785
1787{
1789 // gApplication is set at the end of 'new TApplication.
1790 if (!gApplication) {
1791 char *a = StrDup("RootApp");
1792 char *b = StrDup("-b");
1793 char *argv[2];
1794 Int_t argc = 2;
1795 argv[0] = a;
1796 argv[1] = b;
1797 new TApplication("RootApp", &argc, argv, nullptr, 0);
1798 if (gDebug > 0)
1799 Printf("<TApplication::CreateApplication>: "
1800 "created default TApplication");
1801 delete [] a; delete [] b;
1803 }
1804}
1805
1806////////////////////////////////////////////////////////////////////////////////
1807/// Static function used to attach to an existing remote application
1808/// or to start one.
1809
1811 Int_t debug, const char *script)
1812{
1813 TApplication *ap = nullptr;
1814 TUrl nu(url);
1815 Int_t nnew = 0;
1816
1817 // Look among the existing ones
1818 if (fgApplications) {
1819 TIter nxa(fgApplications);
1820 while ((ap = (TApplication *) nxa())) {
1821 TString apn(ap->ApplicationName());
1822 if (apn == url) {
1823 // Found matching application
1824 return ap;
1825 } else {
1826 // Check if same machine and user
1827 TUrl au(apn);
1828 if (strlen(au.GetUser()) > 0 && strlen(nu.GetUser()) > 0 &&
1829 !strcmp(au.GetUser(), nu.GetUser())) {
1830 if (!strncmp(au.GetHost(), nu.GetHost(), strlen(nu.GetHost())))
1831 // New session on a known machine
1832 nnew++;
1833 }
1834 }
1835 }
1836 } else {
1837 ::Error("TApplication::Open", "list of applications undefined - protocol error");
1838 return ap;
1839 }
1840
1841 // If new session on a known machine pass the number as option
1842 if (nnew > 0) {
1843 nnew++;
1844 nu.SetOptions(TString::Format("%d", nnew).Data());
1845 }
1846
1847 // Instantiate the TApplication object to be run
1848 TPluginHandler *h = nullptr;
1849 if ((h = gROOT->GetPluginManager()->FindHandler("TApplication","remote"))) {
1850 if (h->LoadPlugin() == 0) {
1851 ap = (TApplication *) h->ExecPlugin(3, nu.GetUrl(), debug, script);
1852 } else {
1853 ::Error("TApplication::Open", "failed to load plugin for TApplicationRemote");
1854 }
1855 } else {
1856 ::Error("TApplication::Open", "failed to find plugin for TApplicationRemote");
1857 }
1858
1859 // Add to the list
1860 if (ap && !(ap->TestBit(kInvalidObject))) {
1861 fgApplications->Add(ap);
1862 gROOT->GetListOfBrowsables()->Add(ap, ap->ApplicationName());
1863 TIter next(gROOT->GetListOfBrowsers());
1864 TBrowser *b;
1865 while ((b = (TBrowser*) next()))
1866 b->Add(ap, ap->ApplicationName());
1867 gROOT->RefreshBrowsers();
1868 } else {
1869 SafeDelete(ap);
1870 ::Error("TApplication::Open",
1871 "TApplicationRemote for %s could not be instantiated", url);
1872 }
1873
1874 // Done
1875 return ap;
1876}
1877
1878////////////////////////////////////////////////////////////////////////////////
1879/// Static function used to close a remote application
1880
1882{
1883 if (app) {
1884 app->Terminate(0);
1885 fgApplications->Remove(app);
1886 gROOT->GetListOfBrowsables()->RecursiveRemove(app);
1887 TIter next(gROOT->GetListOfBrowsers());
1888 TBrowser *b;
1889 while ((b = (TBrowser*) next()))
1890 b->RecursiveRemove(app);
1891 gROOT->RefreshBrowsers();
1892 }
1893}
1894
1895////////////////////////////////////////////////////////////////////////////////
1896/// Show available sessions
1897
1899{
1900 if (fgApplications) {
1901 TIter nxa(fgApplications);
1902 TApplication *a = nullptr;
1903 while ((a = (TApplication *) nxa())) {
1904 a->Print(opt);
1905 }
1906 } else {
1907 Print(opt);
1908 }
1909}
1910
1911////////////////////////////////////////////////////////////////////////////////
1912/// Static method returning the list of available applications
1913
1915{
1916 return fgApplications;
1917}
#define SafeDelete(p)
Definition: RConfig.hxx:537
#define f(i)
Definition: RSha256.hxx:104
#define h(i)
Definition: RSha256.hxx:106
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition: RtypesCore.h:63
const Ssiz_t kNPOS
Definition: RtypesCore.h:124
int Int_t
Definition: RtypesCore.h:45
long Longptr_t
Definition: RtypesCore.h:82
const Bool_t kFALSE
Definition: RtypesCore.h:101
long Long_t
Definition: RtypesCore.h:54
long long Long64_t
Definition: RtypesCore.h:80
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
static void CallEndOfProcessCleanups()
#define FOOTNOTE
TApplication * gApplication
R__EXTERN TClassTable * gClassTable
Definition: TClassTable.h:95
@ kIsInlined
Definition: TDictionary.h:131
@ kIsConstexpr
Definition: TDictionary.h:93
@ kIsStruct
Definition: TDictionary.h:66
@ kIsVirtual
Definition: TDictionary.h:72
@ kIsNamespace
Definition: TDictionary.h:95
#define gDirectory
Definition: TDirectory.h:384
R__EXTERN TEnv * gEnv
Definition: TEnv.h:170
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:188
R__EXTERN ExceptionContext_t * gException
Definition: TException.h:74
R__EXTERN void Throw(int code)
If an exception context has been set (using the TRY and RETRY macros) jump back to where it was set.
Definition: TException.cxx:27
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 WindowAttributes_t Float_t Float_t Float_t b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
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 mode
Option_t Option_t TPoint TPoint const char text
char name[80]
Definition: TGX11.cxx:110
R__EXTERN TGuiFactory * gBatchGuiFactory
Definition: TGuiFactory.h:67
R__EXTERN TGuiFactory * gGuiFactory
Definition: TGuiFactory.h:66
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:46
#define gInterpreter
Definition: TInterpreter.h:564
@ kInvalidObject
Definition: TObject.h:376
Int_t gDebug
Definition: TROOT.cxx:585
R__EXTERN TVirtualMutex * gROOTMutex
Definition: TROOT.h:63
#define gROOT
Definition: TROOT.h:405
char * Compress(const char *str)
Remove all blanks from the string str.
Definition: TString.cxx:2551
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition: TString.cxx:2468
char * Strip(const char *str, char c=' ')
Strip leading and trailing c (blanks by default) from a string.
Definition: TString.cxx:2500
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition: TString.cxx:2482
char * StrDup(const char *str)
Duplicate the string str.
Definition: TString.cxx:2536
R__EXTERN TStyle * gStyle
Definition: TStyle.h:414
@ kReadPermission
Definition: TSystem.h:47
R__EXTERN TSystem * gSystem
Definition: TSystem.h:560
#define R__LOCKGUARD(mutex)
#define gPad
Definition: TVirtualPad.h:302
#define gVirtualX
Definition: TVirtualX.h:338
R__EXTERN TVirtualX * gGXBatch
Definition: TVirtualX.h:341
This class creates the ROOT Application Environment that interfaces to the windowing system eventloop...
Definition: TApplication.h:39
EExitOnException ExitOnException(EExitOnException opt=kExit)
Set the exit on exception option.
virtual void KeyPressed(Int_t key)
Emit signal when console keyboard key was pressed.
virtual Longptr_t ProcessLine(const char *line, Bool_t sync=kFALSE, Int_t *error=nullptr)
Process a single command line, either a C++ statement or an interpreter command starting with a "....
static TList * fgApplications
Definition: TApplication.h:82
static void Close(TApplication *app)
Static function used to close a remote application.
virtual void SetEchoMode(Bool_t mode)
Set console echo mode:
virtual void Help(const char *line)
The function lists useful commands (".help") or opens the online reference guide, generated with Doxy...
virtual void LineProcessed(const char *line)
Emit signal when a line has been processed.
void ClearInputFiles()
Clear list containing macro files passed as program arguments.
TApplicationImp * fAppImp
Definition: TApplication.h:60
static Longptr_t ExecuteFile(const char *file, Int_t *error=nullptr, Bool_t keep=kFALSE)
Execute a file containing a C++ macro (static method).
void InitializeGraphics(Bool_t only_web=kFALSE)
Initialize the graphics environment.
virtual void Open()
Definition: TApplication.h:127
virtual void LoadGraphicsLibs()
Load shared libs necessary for graphics.
virtual void StopIdleing()
Called when system stops idleing.
virtual void StartIdleing()
Called when system starts idleing.
virtual void Run(Bool_t retrn=kFALSE)
Main application eventloop. Calls system dependent eventloop via gSystem.
virtual ~TApplication()
TApplication dtor.
void OpenReferenceGuideFor(const TString &strippedClass)
It opens the online reference guide, generated with Doxygen, for the chosen scope (class/namespace/st...
virtual void HandleException(Int_t sig)
Handle exceptions (kSigBus, kSigSegmentationViolation, kSigIllegalInstruction and kSigFloatingExcepti...
virtual void MakeBatch()
Switch to batch mode.
Bool_t fReturnFromRun
Definition: TApplication.h:62
virtual void Init()
Definition: TApplication.h:112
TString fIdleCommand
Definition: TApplication.h:68
char ** Argv() const
Definition: TApplication.h:136
static Bool_t fgGraphNeeded
Definition: TApplication.h:73
virtual void Terminate(Int_t status=0)
Terminate the application by call TSystem::Exit() unless application has been told to return from Run...
void OpenInBrowser(const TString &url)
The function generates and executes a command that loads the Doxygen URL in a browser.
virtual const char * ApplicationName() const
Definition: TApplication.h:123
void SetReturnFromRun(Bool_t ret)
Definition: TApplication.h:149
Bool_t fQuit
Definition: TApplication.h:65
virtual Int_t TabCompletionHook(char *buf, int *pLoc, std::ostream &out)
What to do when tab is pressed.
EExitOnException fExitOnException
Definition: TApplication.h:71
TObjArray * fFiles
Definition: TApplication.h:66
const char * GetIdleCommand() const
Definition: TApplication.h:118
TApplication()
Default ctor. Can be used by classes deriving from TApplication.
virtual Longptr_t ProcessFile(const char *file, Int_t *error=nullptr, Bool_t keep=kFALSE)
Process a file containing a C++ macro.
TString fWorkDir
Definition: TApplication.h:67
virtual void ReturnPressed(char *text)
Emit signal when return key was pressed.
static Bool_t fgGraphInit
Definition: TApplication.h:74
virtual void RemoveIdleTimer()
Remove idle timer. Normally called via TROOT::Idle(0).
virtual void SetIdleTimer(UInt_t idleTimeInSec, const char *command)
Set the command to be executed after the system has been idle for idleTimeInSec seconds.
static void CreateApplication()
Static function used to create a default application environment.
virtual void GetOptions(Int_t *argc, char **argv)
Get and handle command line options.
static TList * GetApplications()
Static method returning the list of available applications.
std::atomic< bool > fIsRunning
Window system specific application implementation.
Definition: TApplication.h:61
static void NeedGraphicsLibs()
Static method.
static Int_t ParseRemoteLine(const char *ln, TString &hostdir, TString &user, Int_t &dbg, TString &script)
Parse the content of a line starting with ".R" (already stripped-off) The format is.
TTimer * fIdleTimer
Definition: TApplication.h:69
void ls(Option_t *option="") const override
Show available sessions.
Bool_t fNoLog
Definition: TApplication.h:63
Bool_t fNoLogo
Definition: TApplication.h:64
virtual void HandleIdleTimer()
Handle idle timeout.
virtual Longptr_t ProcessRemote(const char *line, Int_t *error=nullptr)
Process the content of a line starting with ".R" (already stripped-off) The format is.
TApplication * fAppRemote
Definition: TApplication.h:80
char ** fArgv
Definition: TApplication.h:59
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
static DictFuncPtr_t GetDict(const char *cname)
Given the class name returns the Dictionary() function of a class (uses hash of name).
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:81
TList * GetListOfAllPublicDataMembers(Bool_t load=kTRUE)
Returns a list of all public data members of this class and its base classes.
Definition: TClass.cxx:3851
TList * GetListOfEnums(Bool_t load=kTRUE)
Return a list containing the TEnums of a class.
Definition: TClass.cxx:3675
Long_t Property() const override
Returns the properties of the TClass as a bit field stored as a Long_t value.
Definition: TClass.cxx:6075
TMethod * GetMethodAllAny(const char *method)
Return pointer to method without looking at parameters.
Definition: TClass.cxx:4373
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
static void InitializeColors()
Initialize colors used by the TCanvas based graphics (via TColor objects).
Definition: TColor.cxx:1143
All ROOT classes may have RTTI (run time type identification) support added.
Definition: TDataMember.h:31
const char * GetTrueTypeName() const
Get full type description of data member, e,g.: "class TDirectory*".
Bool_t IsEnum() const
Return true if data member is an enum.
const char * GetFullTypeName() const
Get full type description of data member, e,g.: "class TDirectory*".
void Print(Option_t *option="") const override
Dump this ellipse with its attributes.
Definition: TEllipse.cxx:578
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition: TEnv.cxx:491
Global functions class (global functions are obtained from CINT).
Definition: TFunction.h:30
Long_t Property() const override
Get property description word. For meaning of bits see EProperty.
Definition: TFunction.cxx:184
const char * GetSignature()
Return signature of function.
Definition: TFunction.cxx:116
Long_t ExtraProperty() const
Get property description word. For meaning of bits see EProperty.
Definition: TFunction.cxx:192
const char * GetReturnTypeName() const
Get full type description of function return type, e,g.: "class TDirectory*".
Definition: TFunction.cxx:141
This ABC is a factory for GUI components.
Definition: TGuiFactory.h:42
virtual TApplicationImp * CreateApplicationImp(const char *classname, int *argc, char **argv)
Create a batch version of TApplicationImp.
Definition: TGuiFactory.cxx:50
TIdleTimer(Long_t ms)
Bool_t Notify() override
Notify handler.
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
virtual TObjLink * FirstLink() const
Definition: TList.h:102
Each ROOT class (see TClass) has a linked list of methods.
Definition: TMethod.h:38
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
const char * GetName() const override
Returns name of object.
Definition: TNamed.h:47
An array of TObjects.
Definition: TObjArray.h:31
Int_t GetEntries() const override
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:523
void Delete(Option_t *option="") override
Remove all objects from the array AND delete all heap based objects.
Definition: TObjArray.cxx:356
TObject * At(Int_t idx) const override
Definition: TObjArray.h:164
void Add(TObject *obj) override
Definition: TObjArray.h:68
Collectable string class.
Definition: TObjString.h:28
TString & String()
Definition: TObjString.h:48
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 void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:955
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:774
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:969
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:997
virtual void Print(Option_t *option="") const
This method must be overridden when a class wants to print itself.
Definition: TObject.cxx:630
void ResetBit(UInt_t f)
Definition: TObject.h:200
@ kInvalidObject
if object ctor succeeded but object should not be used
Definition: TObject.h:72
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:943
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
static const char * GetMacroPath()
Get macro search path. Static utility function.
Definition: TROOT.cxx:2714
static void ShutDown()
Shut down ROOT.
Definition: TROOT.cxx:3053
static const TString & GetTTFFontDir()
Get the fonts directory in the installation. Static utility function.
Definition: TROOT.cxx:3106
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2834
static const TString & GetTutorialDir()
Get the tutorials directory in the installation. Static utility function.
Definition: TROOT.cxx:3032
static const TString & GetDocDir()
Get the documentation directory in the installation. Static utility function.
Definition: TROOT.cxx:2995
Basic string class.
Definition: TString.h:136
Ssiz_t Length() const
Definition: TString.h:410
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1171
TString & Insert(Ssiz_t pos, const char *s)
Definition: TString.h:650
Int_t Atoi() const
Return integer value of string.
Definition: TString.cxx:1967
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition: TString.cxx:2223
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition: TString.cxx:1152
TString & Replace(Ssiz_t pos, Ssiz_t n, const char *s)
Definition: TString.h:683
Ssiz_t First(char c) const
Find first occurrence of a character c.
Definition: TString.cxx:532
const char * Data() const
Definition: TString.h:369
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:693
TString MD5() const
Return the MD5 digest for this string, in a string representation.
Definition: TString.cxx:934
@ kBoth
Definition: TString.h:267
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition: TString.h:616
TString & Prepend(const char *cs)
Definition: TString.h:662
Bool_t IsNull() const
Definition: TString.h:407
std::istream & ReadFile(std::istream &str)
Replace string with the contents of strm, stopping at an EOF.
Definition: Stringio.cxx:28
TString & Remove(Ssiz_t pos)
Definition: TString.h:674
TString & Append(const char *cs)
Definition: TString.h:565
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:2357
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2335
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:625
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition: TString.h:640
void SetScreenFactor(Float_t factor=1)
Definition: TStyle.h:304
virtual void NotifyApplicationCreated()
Hook to tell TSystem that the TApplication object has been created.
Definition: TSystem.cxx:314
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition: TSystem.cxx:1277
virtual const char * Getenv(const char *env)
Get environment variable.
Definition: TSystem.cxx:1666
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form:
Definition: TSystem.cxx:4251
virtual Int_t Exec(const char *shellcmd)
Execute a command.
Definition: TSystem.cxx:656
int GetPathInfo(const char *path, Long_t *id, Long_t *size, Long_t *flags, Long_t *modtime)
Get info about a file: id, size, flags, modification time.
Definition: TSystem.cxx:1401
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:1299
virtual void Run()
System event loop.
Definition: TSystem.cxx:346
virtual void ExitLoop()
Exit from event loop.
Definition: TSystem.cxx:395
virtual Bool_t ChangeDirectory(const char *path)
Change directory.
Definition: TSystem.cxx:865
virtual void AddTimer(TTimer *t)
Add timer to list of system timers.
Definition: TSystem.cxx:474
virtual void Exit(int code, Bool_t mode=kTRUE)
Exit the application.
Definition: TSystem.cxx:719
virtual const char * WorkingDirectory()
Return working directory.
Definition: TSystem.cxx:874
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition: TSystem.cxx:1549
virtual void SetProgname(const char *name)
Set the application name (from command line, argv[0]) and copy it in gProgName.
Definition: TSystem.cxx:225
virtual const char * GetBuildArch() const
Return the build architecture.
Definition: TSystem.cxx:3868
virtual void Abort(int code=0)
Abort the application.
Definition: TSystem.cxx:728
virtual TTimer * RemoveTimer(TTimer *t)
Remove timer from list of system timers.
Definition: TSystem.cxx:484
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
void Reset()
Reset the timer.
Definition: TTimer.cxx:159
This class represents a WWW compatible URL.
Definition: TUrl.h:33
const char * GetUrl(Bool_t withDeflt=kFALSE) const
Return full URL.
Definition: TUrl.cxx:390
const char * GetFileAndOptions() const
Return the file and its options (the string specified behind the ?).
Definition: TUrl.cxx:504
const char * GetFile() const
Definition: TUrl.h:69
const char * GetUser() const
Definition: TUrl.h:65
const char * GetHost() const
Definition: TUrl.h:67
void SetOptions(const char *opt)
Definition: TUrl.h:87
const char * GetProtocol() const
Definition: TUrl.h:64
Semi-Abstract base class defining a generic interface to the underlying, low level,...
Definition: TVirtualX.h:46
TLine * line
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
static const std::string comment("comment")
void EnableImplicitMT(UInt_t numthreads=0)
Enable ROOT's implicit multi-threading for all objects and methods that provide an internal paralleli...
Definition: TROOT.cxx:527
void EnableThreadSafety()
Enable support for multi-threading within the ROOT code in particular, enables the global mutex to ma...
Definition: TROOT.cxx:493
const char * GetUnqualifiedName(const char *name)
Return the start of the unqualified name include in 'original'.
Definition: TClassEdit.cxx:942
static constexpr double s
static constexpr double ms
null_t< F > null()
Definition: file.py:1
TArc a
Definition: textangle.C:12