Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TGFileBrowser.cxx
Go to the documentation of this file.
1// @(#)root/gui:$Id$
2// Author: Bertrand Bellenot 26/09/2007
3
4/*************************************************************************
5 * Copyright (C) 1995-2007, 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#include "TROOT.h"
13#include "TSystem.h"
14#include "TApplication.h"
15#include "TGClient.h"
16#include "TGListTree.h"
17#include "TGLayout.h"
18#include "TGComboBox.h"
19#include "TContextMenu.h"
20#include "TGTextEntry.h"
21#include "TGTab.h"
22#include "TGLabel.h"
23#include "TSystemDirectory.h"
24#include "TGMimeTypes.h"
25#include "TClass.h"
26#include "TQClass.h"
27#include "TObjString.h"
28#include "TObjArray.h"
29#include "TInterpreter.h"
30#include "TRegexp.h"
31#include "TEnv.h"
32#include "TImage.h"
33#include "TBrowser.h"
34#include "TRemoteObject.h"
35#include "TKey.h"
36#include "TKeyMapFile.h"
37#include "TVirtualPad.h"
38#include "Getline.h"
39#include "snprintf.h"
40#include <ctime>
41#include <cstring>
42#include <cstdlib>
43
44#include "TGFileBrowser.h"
45#include "TRootBrowser.h"
46#include "TGInputDialog.h"
47
48#include "TVirtualPadEditor.h"
49#include "TGedEditor.h"
50#include "TBaseClass.h"
51#include "TVirtualX.h"
52
53#include "RConfigure.h"
54
55#ifdef WIN32
56const char rootdir[] = "\\";
57#else
58const char rootdir[] = "/";
59#endif
60
61const char *filters[] = {
62 "",
63 "*.*",
64 "*.[C|c|h]*",
65 "*.root",
66 "*.txt"
67};
68
69
70/** \class TCursorSwitcher
71 \ingroup guiwidgets
72
73Helper class used to change the cursor in a method and restore the
74original one when going out of the method scope.
75
76*/
77
78
79///////////////////////////////////////////////////////////////////////////////
81private:
84public:
86 if (w1) gVirtualX->SetCursor(w1->GetId(), gVirtualX->CreateCursor(kWatch));
87 if (w2) gVirtualX->SetCursor(w2->GetId(), gVirtualX->CreateCursor(kWatch));
88 }
90 if (fW1) gVirtualX->SetCursor(fW1->GetId(), gVirtualX->CreateCursor(kPointer));
91 if (fW2) gVirtualX->SetCursor(fW2->GetId(), gVirtualX->CreateCursor(kPointer));
92 }
93};
94
95
96/** \class TGFileBrowser
97 \ingroup guiwidgets
98
99System file browser, used as TRootBrowser plug-in.
100This class is the real core of the ROOT browser.
101
102*/
103
104
105
106////////////////////////////////////////////////////////////////////////////////
107/// TGFileBrowser constructor.
108
110 : TGMainFrame(p, w, h), TBrowserImp(b), fNewBrowser(0)
111{
112 if (p && p != gClient->GetDefaultRoot())
113 fNewBrowser = (TRootBrowser *)p->GetMainFrame();
114 if (fNewBrowser)
117 Resize(w, h);
118 if (fBrowser) Show();
119}
120
121////////////////////////////////////////////////////////////////////////////////
122/// Create the actual file browser.
123
125{
126 fCachedPic = 0;
128
129 fTopFrame = new TGHorizontalFrame(this, 100, 30);
132 dropt_entry->SetToolTipText("Object Draw Option", 300);
133 fDrawOption->Resize(80, 20);
135 lb->Resize(lb->GetWidth(), 120);
136 Int_t dropt = 1;
137 fDrawOption->AddEntry("", dropt++);
138 fDrawOption->AddEntry("box", dropt++);
139 fDrawOption->AddEntry("colz", dropt++);
140 fDrawOption->AddEntry("lego", dropt++);
141 fDrawOption->AddEntry("lego1", dropt++);
142 fDrawOption->AddEntry("lego2", dropt++);
143 fDrawOption->AddEntry("same", dropt++);
144 fDrawOption->AddEntry("surf", dropt++);
145 fDrawOption->AddEntry("surf1", dropt++);
146 fDrawOption->AddEntry("surf2", dropt++);
147 fDrawOption->AddEntry("surf3", dropt++);
148 fDrawOption->AddEntry("surf4", dropt++);
149 fDrawOption->AddEntry("surf5", dropt++);
150 fDrawOption->AddEntry("text", dropt++);
152 kLHintsRight, 2, 2, 2, 2));
153 fTopFrame->AddFrame(new TGLabel(fTopFrame, "Draw Option:"),
155 5, 2, 2, 2));
156
157 fSortButton = new TGPictureButton(fTopFrame, "bld_sortup.png");
158 fSortButton->SetStyle(gClient->GetStyle());
159 fSortButton->SetToolTipText("Sort Alphabetically\n(Current folder only)");
161 kLHintsLeft, 2, 2, 2, 2));
162 fSortButton->Connect("Clicked()", "TGFileBrowser", this, "ToggleSort()");
163
164 fFilterButton = new TGPictureButton(fTopFrame, "filter.png");
165 fFilterButton->SetStyle(gClient->GetStyle());
166 fFilterButton->SetToolTipText("Filter Content");
168 kLHintsLeft, 2, 2, 2, 2));
169 fFilterButton->Connect("Clicked()", "TGFileBrowser", this, "RequestFilter()");
170
171 fRefreshButton = new TGPictureButton(fTopFrame, "refresh.png");
172 fRefreshButton->SetStyle(gClient->GetStyle());
173 fRefreshButton->SetToolTipText("Refresh Current Folder");
175 kLHintsLeft, 2, 5, 2, 2));
176 fRefreshButton->Connect("Clicked()", "TGFileBrowser", this, "Refresh()");
177
179 kLHintsExpandX, 2, 2, 2, 2));
180 fCanvas = new TGCanvas(this, 100, 100);
184 fListTree->Connect("DoubleClicked(TGListTreeItem *, Int_t)",
185 "TGFileBrowser", this, "DoubleClicked(TGListTreeItem *, Int_t)");
186 fListTree->Connect("Clicked(TGListTreeItem *, Int_t, Int_t, Int_t)",
187 "TGFileBrowser", this, "Clicked(TGListTreeItem *, Int_t, Int_t, Int_t)");
188 fListTree->Connect("Checked(TObject*, Bool_t)", "TGFileBrowser",
189 this, "Checked(TObject*, Bool_t)");
190
191 fRootIcon = gClient->GetPicture("rootdb_t.xpm");
192 fFileIcon = gClient->GetPicture("doc_t.xpm");
193
194 fBotFrame = new TGHorizontalFrame(this, 100, 30);
195 fBotFrame->AddFrame(new TGLabel(fBotFrame, "Filter: "),
197 2, 2, 2, 2));
198 fFileType = new TGComboBox(fBotFrame, " All Files (*.*)");
199 Int_t ftype = 1;
200 fFileType->AddEntry(" All Files (*.*)", ftype++);
201 fFileType->AddEntry(" C/C++ Files (*.c;*.cxx;*.h;...)", ftype++);
202 fFileType->AddEntry(" ROOT Files (*.root)", ftype++);
203 fFileType->AddEntry(" Text Files (*.txt)", ftype++);
204 fFileType->Resize(200, 20);
206 kLHintsExpandX, 2, 2, 2, 2));
207 fFileType->Connect("Selected(Int_t)", "TGFileBrowser", this,
208 "ApplyFilter(Int_t)");
209 fFileType->GetTextEntry()->Connect("ReturnPressed()", "TGFileBrowser",
210 this, "ApplyFilter(Int_t = -1)");
212 kLHintsExpandX, 2, 2, 2, 2));
213
214 fContextMenu = new TContextMenu("FileBrowserContextMenu");
215 fFilter = nullptr;
216 fGroupSize = 1000;
217 fListLevel = 0;
218 fCurrentDir = 0;
219 fRootDir = 0;
220 fDir = nullptr;
221 fFile = nullptr;
222 fNKeys = 0;
223 fCnt = 0;
224 fFilterStr = "*";
225
226 TString gv = gEnv->GetValue("Browser.GroupView", "1000");
227 Int_t igv = atoi(gv.Data());
228 if (igv > 10)
229 fGroupSize = igv;
230
231 if (gEnv->GetValue("Browser.ShowHidden", 0))
233 else
235
237
238 if (TClass::GetClass("TGHtmlBrowser"))
239 TQObject::Connect("TGHtmlBrowser", "Clicked(char*)",
240 "TGFileBrowser", this, "Selected(char*)");
241
242 TQObject::Connect("TPad", "Modified()",
243 "TGFileBrowser", this, "PadModified()");
244
245 fListLevel = 0;
248 MapWindow();
249}
250
251////////////////////////////////////////////////////////////////////////////////
252/// Destructor.
253
255{
256 if (TClass::GetClass("TGHtmlBrowser"))
257 TQObject::Disconnect("TGHtmlBrowser", "Clicked(char*)");
258 TQObject::Disconnect("TPad", "Modified()");
259
260 delete fContextMenu;
261 delete fListTree;
262 delete fFilter;
263 delete fDir;
264 delete fFile;
266 if (fCachedPic && (fCachedPic != fFileIcon))
269 Cleanup();
270}
271
272////////////////////////////////////////////////////////////////////////////////
273/// Helper function checking if a class has a graphic properties editor.
274
276{
277 TBaseClass *base;
278 TList* bcl = cl->GetListOfBases();
279 TIter next(bcl);
280 while ((base = (TBaseClass*) next())) {
281 cl = base->GetClassPointer();
282 if (cl && TClass::GetClass(Form("%sEditor", cl->GetName())))
283 return kTRUE;
284 if (cl && IsObjectEditable(cl))
285 return kTRUE;
286 }
287 return kFALSE;
288}
289
290////////////////////////////////////////////////////////////////////////////////
291/// Format the tooltip information, based on the object passed in argument.
292
293static const char *FormatToolTip(TObject *obj, Int_t maxlen=0)
294{
295 static TString infos;
296 if (!obj) {
297 infos.Clear();
298 return 0;
299 }
300 infos = obj->GetName();
301 if (obj->GetTitle()) {
302 infos += "\n";
303 infos += obj->GetTitle();
304 }
305 if (maxlen > 0 && infos.Length() > maxlen) {
306 infos.Remove(maxlen - 3);
307 infos += "...";
308 }
309 TString objinfo = obj->GetObjectInfo(1, 1);
310 if (!objinfo.IsNull() && !objinfo.BeginsWith("x=")) {
311 Long64_t bsize, fsize, objsize;
312 objsize = objinfo.Atoll();
313 if (objsize > 0) {
314 infos += "\n";
315 bsize = fsize = objsize;
316 if (fsize > 1024) {
317 fsize /= 1024;
318 if (fsize > 1024) {
319 // 3.7MB is more informative than just 3MB
320 infos += TString::Format("Size: %lld.%lldM", fsize/1024,
321 (fsize%1024)/103);
322 } else {
323 infos += TString::Format("Size: %lld.%lldK", bsize/1024,
324 (bsize%1024)/103);
325 }
326 } else {
327 infos += TString::Format("Size: %lld bytes", bsize);
328 }
329 }
330 }
331 return infos.Data();
332}
333
334/**************************************************************************/
335// TBrowserImp virtuals
336/**************************************************************************/
337
338////////////////////////////////////////////////////////////////////////////////
339/// Add items to the browser. This function has to be called
340/// by the Browse() member function of objects when they are
341/// called by a browser. If check < 0 (default) no check box is drawn,
342/// if 0 then unchecked checkbox is added, if 1 checked checkbox is added.
343
344void TGFileBrowser::Add(TObject *obj, const char *name, Int_t check)
345{
346 if (fListLevel && !strcmp(fListLevel->GetText(), "Classes") &&
348 !strcmp(fListLevel->GetParent()->GetText(), "root")) {
349 // Browsing list of root classes...
350 }
351 else {
352 if (obj && obj->InheritsFrom("TApplication"))
353 fListLevel = 0;
354 if (obj && obj->InheritsFrom("TSystemDirectory"))
355 return;
356 }
357 if (fListLevel) {
358 TString oname = "";
359 if (name)
360 oname = name;
361 else if (obj)
362 oname = obj->GetName();
363 // check if the current item is filtered
364 auto it = fFilteredItems.find(fListLevel);
365 if (it != fFilteredItems.end()) {
366 // check if the item (object) name match the filter
367 const char *filter = it->second.c_str();
368 TRegexp re(filter, kTRUE);
369 // if not, simply return, so no item will be added
370 if (oname.Index(re) == kNPOS) return;
371 }
372 }
373 const TGPicture *pic = nullptr;
374 if (obj && obj->InheritsFrom("TKey") && (obj->IsA() != TClass::Class()))
375 AddKey(fListLevel, obj, name);
376 else if (obj) {
377 GetObjPicture(&pic, obj);
378 if (!name) name = obj->GetName();
379 if (check > -1) {
382 pic, pic, kTRUE);
383 if ((pic != fFileIcon) && (pic != fCachedPic))
387 }
388 }
389 else {
390 // special case for remote object
392 if (obj->InheritsFrom("TRemoteObject"))
393 isRemote = kTRUE;
394 else if (fListLevel) {
395 // check also if one of its parents is a remote object
397 while (top->GetParent()) {
398 TObject *tobj = (TObject *) top->GetUserData();
399 if (tobj && (tobj->InheritsFrom("TRemoteObject") ||
400 tobj->InheritsFrom("TApplicationRemote"))) {
401 isRemote = kTRUE;
402 break;
403 }
404 top = top->GetParent();
405 }
406 }
407 if (isRemote) {
409 if (!strcmp(robj->GetClassName(), "TKey")) {
410 AddKey(fListLevel, obj, name);
411 }
412 else {
414 // add the remote object only if not already in the list
415 if (!fShowHidden && fname.BeginsWith("."))
416 return;
417 AddRemoteFile(obj);
418 }
419 }
420 else {
423 if ((pic != fFileIcon) && (pic != fCachedPic))
425 if (item && obj && obj->InheritsFrom("TObject"))
426 item->SetDNDSource(kTRUE);
428 }
429 }
430 }
431 }
432}
433
434////////////////////////////////////////////////////////////////////////////////
435/// Add remote file in list tree.
436
438{
440 Int_t type;
442 const TGPicture *spic;
443 TGPicture *pic;
444
446
448
449 robj->GetFileStat(&sbuf);
450 is_link = sbuf.fIsLink;
451 type = sbuf.fMode;
452 filename = robj->GetName();
453 if (R_ISDIR(type) || fFilter == 0 ||
454 (fFilter && filename.Index(*fFilter) != kNPOS)) {
455
457
458 pic = (TGPicture*)spic; pic->AddReference();
459
463 }
464}
465
466////////////////////////////////////////////////////////////////////////////////
467/// Browse object. This, in turn, will trigger the calling of
468/// TBrowser::Add() which will fill the IconBox and the tree.
469/// Emits signal "BrowseObj(TObject*)".
470
472{
473 if (fNewBrowser)
475 if (obj != gROOT) {
477 fListLevel = 0;
478 Add(obj);
481 if (obj->IsFolder())
485 }
486 }
487 if (fBrowser) obj->Browse(fBrowser);
488 if (obj == gROOT) {
489 TList *volumes = gSystem->GetVolumes("all");
490 TList *curvol = gSystem->GetVolumes("cur");
491 if (volumes && curvol) {
492 const char *curdrive;
493 TNamed *named = (TNamed *)curvol->At(0);
494 if (named)
495 curdrive = named->GetName();
496 else
497 curdrive = "C:";
498 TIter next(volumes);
499 TNamed *drive;
500 while ((drive = (TNamed *)next())) {
501 AddFSDirectory(TString::Format("%s\\", drive->GetName()), drive->GetTitle(),
502 (strcmp(drive->GetName(), curdrive) == 0) ?
503 "SetRootDir" : "Add");
504 }
505 delete volumes;
506 delete curvol;
507 }
508 else {
509 AddFSDirectory("/");
510 }
512 if (gROOT->GetListOfFiles() && !gROOT->GetListOfFiles()->IsEmpty())
513 Selected(0);
514 }
515}
516
517////////////////////////////////////////////////////////////////////////////////
518/// Emits signal when double clicking on icon.
519
521{
522 if (fNewBrowser)
523 fNewBrowser->Checked(obj, checked);
524}
525
526////////////////////////////////////////////////////////////////////////////////
527/// returns drawing option
528
530{
531 return fDrawOption->GetTextEntry()->GetText();
532}
533
534////////////////////////////////////////////////////////////////////////////////
535/// Determine the file picture for the given file type.
536
538 Bool_t is_link, const char *name)
539{
540 static TString cached_ext;
541 static const TGPicture *cached_spic = 0;
542 const char *ext = name ? strrchr(name, '.') : 0;
543 TString sname = name ? name : " ";
544 *pic = 0;
545
546 if (ext && cached_spic && (cached_ext == ext)) {
547 *pic = cached_spic;
548 return;
549 }
550
551 if (R_ISREG(file_type)) {
552 *pic = gClient->GetMimeTypeList()->GetIcon(name, kTRUE);
553
554 if (*pic) {
555 if (ext) {
556 cached_ext = ext;
557 cached_spic = *pic;
558 return;
559 }
560 }
561 } else {
562 *pic = 0;
563 }
564
565 if (*pic == 0) {
566 *pic = gClient->GetPicture("doc_t.xpm");
567
568 if (R_ISREG(file_type) && (file_type) & kS_IXUSR) {
569 *pic = gClient->GetPicture("app_t.xpm");
570 }
571 if (R_ISDIR(file_type)) {
572 *pic = gClient->GetPicture("folder_t.xpm");
573 }
574 if(sname.EndsWith(".root")) {
575 *pic = gClient->GetPicture("rootdb_t.xpm");
576 }
577
578 }
579 if (is_link) {
580 *pic = gClient->GetPicture("slink_t.xpm");
581 }
582
583 cached_spic = 0;
584 cached_ext = "";
585}
586
587////////////////////////////////////////////////////////////////////////////////
588/// Recursively remove object.
589
591{
592 TGListTreeItem *itm = nullptr, *item = nullptr;
593 if (obj->InheritsFrom("TFile")) {
594 itm = fListTree->FindChildByData(0, gROOT->GetListOfFiles());
595 if (itm)
597 if (item) {
598 // if the item to be deleted has a filter,
599 // delete its entry in the map
600 if (CheckFiltered(item))
601 fFilteredItems.erase(item);
603 }
604 itm = fRootDir ? fRootDir->GetFirstChild() : nullptr;
605 while (itm) {
607 if (item) {
609 item->SetUserData(0);
610 }
611 itm = itm->GetNextSibling();
612 }
613 }
614 if (!obj->InheritsFrom("TFile") && fRootDir) {
616 // if the item to be deleted has a filter, delete its entry in the map
617 if (item && CheckFiltered(item))
618 fFilteredItems.erase(item);
620 }
621 //fListTree->ClearViewPort();
622}
623
624////////////////////////////////////////////////////////////////////////////////
625/// Refresh content of the list tree.
626
628{
629 TTimer::SingleShot(200, "TGFileBrowser", this, "Update()");
630 return; // disable refresh for the time being...
631 // coverity[unreachable]
633 static UInt_t prev = 0;
634 UInt_t curr = gROOT->GetListOfBrowsables()->GetSize();
635 if (!prev) prev = curr;
636
637 if (prev != curr) { // refresh gROOT
639 fListLevel = 0;
641 fListLevel = sav;
642 prev = curr;
643 }
644}
645
646////////////////////////////////////////////////////////////////////////////////
647/// Update content of the list tree.
648
650{
651 Long64_t size = 0;
652 Long_t id = 0, flags = 0, modtime = 0;
653 char path[1024];
655 if (!item) item = fRootDir;
656 if (!item) return;
657 //fListTree->DeleteChildren(item);
658 TGListTreeItem *curr = fListTree->GetSelected(); // GetCurrent() ??
659 if (curr) {
660 TObject *obj = (TObject *) curr->GetUserData();
661 if (obj && ROOT::Detail::HasBeenDeleted(obj)) {
662 // if the item to be deleted has a filter,
663 // delete its entry in the map
664 if (CheckFiltered(curr))
665 fFilteredItems.erase(curr);
667 curr = 0;
668 obj = 0;
669 }
670 else if (obj && !ROOT::Detail::HasBeenDeleted(obj) &&
671 obj->InheritsFrom("TObjString") && curr->GetParent()) {
672 fListTree->GetPathnameFromItem(curr->GetParent(), path);
673 if (strlen(path) > 1) {
674 TString dirpath = FullPathName(curr->GetParent());
675 Int_t res = gSystem->GetPathInfo(dirpath.Data(), &id, &size,
676 &flags, &modtime);
677 if ((res == 0) && (flags & 2)) {
679 if (gSystem->AccessPathName(fullpath.Data())) {
680 // if the item to be deleted has a filter,
681 // delete its entry in the map
682 if (CheckFiltered(curr))
683 fFilteredItems.erase(curr);
685 curr = 0;
686 obj = 0;
687 }
688 }
689 }
690 }
691 }
693 flags = id = size = modtime = 0;
694 if (gSystem->GetPathInfo(actpath.Data(), &id, &size, &flags, &modtime) == 0) {
695 Int_t isdir = (Int_t)flags & 2;
696
698 if (isdir) {
699 TGListTreeItem *del = 0, *itm = item->GetFirstChild();
700 while (itm) {
702 if (strlen(path) > 1) {
704 if (gSystem->AccessPathName(recpath.Data())) {
705 del = itm;
706 itm = itm->GetNextSibling();
707 // if the item to be deleted has a filter,
708 // delete its entry in the map
709 if (CheckFiltered(del))
710 fFilteredItems.erase(del);
712 }
713 }
714 if (del)
715 del = 0;
716 else
717 itm = itm->GetNextSibling();
718 }
719 }
720 }
723 fListLevel = sav;
725}
726
727/**************************************************************************/
728// Other
729/**************************************************************************/
730
731////////////////////////////////////////////////////////////////////////////////
732/// Add file system directory in the list tree.
733
734void TGFileBrowser::AddFSDirectory(const char *entry, const char *path,
735 Option_t *opt)
736{
737 TGListTreeItem *item = 0;
738 if ((opt == 0) || (!opt[0])) {
739 if (fRootDir == 0 && !fListTree->FindChildByName(0, rootdir))
741 return;
742 }
743 if (strstr(opt, "SetRootDir")) {
746 }
747 else if (strstr(opt, "Add")) {
748 // MT: i give up! wanted to place entries for selected
749 // directories like home, pwd, alice-macros.
750 // TGListTreeItem *lti = fListTree->AddItem(0, entry);
751 //
754 }
755 if (item && path) {
756 TString infos = path;
757 item->SetTipText(path);
758 TGPicture *pic = 0;
759 if (infos.Contains("Removable"))
760 pic = (TGPicture *)gClient->GetPicture("fdisk_t.xpm");
761 else if (infos.Contains("Local"))
762 pic = (TGPicture *)gClient->GetPicture("hdisk_t.xpm");
763 else if (infos.Contains("CD"))
764 pic = (TGPicture *)gClient->GetPicture("cdrom_t.xpm");
765 else if (infos.Contains("Network"))
766 pic = (TGPicture *)gClient->GetPicture("netdisk_t.xpm");
767 if (pic)
768 item->SetPictures(pic, pic);
769 }
770}
771
772////////////////////////////////////////////////////////////////////////////////
773/// display content of ROOT file
774
776{
777 // Int_t from, to;
779 static TGListTreeItem *olditem = itm;
780 static TGListTreeItem *item = itm;
781 const TGPicture *pic;
782
783 if (itm == 0) return;
784
785 if ((fCnt == 0) || (olditem != itm)) {
786 olditem = item = itm;
787 }
788 if (!name) name = obj->GetName();
789 if (fNKeys > fGroupSize) {
790 where = itm->GetFirstChild();
791 while (where) {
792 if (fListTree->FindItemByObj(where, obj))
793 return;
794 where = where->GetNextSibling();
795 }
796 }
797 if ((fNKeys > fGroupSize) && (fCnt % fGroupSize == 0)) {
798 if (item != itm) {
799 TString newname = TString::Format("%s-%s", item->GetText(), name);
800 item->Rename(newname.Data());
801 }
803 item->SetDNDSource(kTRUE);
804 }
805 if ((fCnt > fGroupSize) && (fCnt >= fNKeys-1)) {
806 TString newname = TString::Format("%s-%s", item->GetText(), name);
807 item->Rename(newname.Data());
808 }
809 GetObjPicture(&pic, obj);
812 if (pic && (pic != fFileIcon) && (pic != fCachedPic))
814 it->SetDNDSource(kTRUE);
815 it->SetTipText(FormatToolTip(obj, 32));
816 }
817 fCnt++;
818}
819
820////////////////////////////////////////////////////////////////////////////////
821/// Apply filter selected in combo box to the file tree view.
822
824{
825 // Long64_t size;
826 // Long_t fid, flags, modtime;
827
828 if (fFilter)
829 delete fFilter;
830 fFilter = nullptr;
831 if ((id > 1) && (id < 5))
832 fFilter = new TRegexp(filters[id], kTRUE);
833 else if ((id < 0) || (id > 4)) {
835 if (lbe) {
836 const char *text = lbe->GetTitle();
837 fFilter = new TRegexp(text, kTRUE);
838 }
839 }
841 if (!item)
842 item = fRootDir;
843 if (!item) return;
846 //fListTree->AdjustPosition(item);
848}
849
850////////////////////////////////////////////////////////////////////////////////
851/// Make object associated with item the current directory.
852
854{
855 if (item) {
856 TGListTreeItem *i = item;
857 while (i) {
858 TObject *obj = (TObject*) i->GetUserData();
859 if ((obj) && obj->InheritsFrom("TDirectory")) {
860 ((TDirectory *)obj)->cd();
861 break;
862 }
863 i = i->GetParent();
864 }
865 }
866}
867
868////////////////////////////////////////////////////////////////////////////////
869/// Check if the current list tree item points to a remote object.
870
872{
873 if (!item) return;
874 TObject *obj = (TObject *) item->GetUserData();
875 if (obj) {
876 if (obj->InheritsFrom("TApplicationRemote")) {
877 if (!gApplication->GetAppRemote()) {
878 gROOT->ProcessLine(TString::Format(".R %s", item->GetText()));
879 if (gApplication->GetAppRemote()) {
880 Getlinem(kInit, TString::Format("\n%s:root [0]",
882 }
883 }
884 }
885 if (item->GetParent() && item->GetParent()->GetUserData() &&
886 ((TObject *)item->GetParent()->GetUserData())->InheritsFrom("TApplicationRemote")) {
887 // switch to remote session
888 if (!gApplication->GetAppRemote()) {
889 gROOT->ProcessLine(TString::Format(".R %s", item->GetParent()->GetText()));
890 if (gApplication->GetAppRemote()) {
891 Getlinem(kInit, TString::Format("\n%s:root [0]",
893 }
894 }
895 else if (!strcmp(item->GetText(), "ROOT Files")) {
896 // update list of files opened in the remote session
898 gApplication->ProcessLine("((TApplicationServer *)gApplication)->BrowseFile(0);");
899 }
900 }
901 else {
902 // check if the listtree item is from a local session or
903 // from a remote session, then switch to the session it belongs to
904 TGListTreeItem *top = item;
905 while (top->GetParent()) {
906 top = top->GetParent();
907 }
908 TObject *topobj = (TObject *) top->GetUserData();
909 if (topobj && topobj->InheritsFrom("TApplicationRemote")) {
910 // it belongs to a remote session
911 if (!gApplication->GetAppRemote()) {
912 // switch to remote session if not already in
913 gROOT->ProcessLine(TString::Format(".R %s", top->GetText()));
914 if (gApplication->GetAppRemote()) {
915 Getlinem(kInit, TString::Format("\n%s:root [0]",
917 }
918 }
919 }
920 else if (gApplication->GetAppRemote()) {
921 // switch back to local session if not already in
923 Getlinem(kInit, "\nroot [0]");
924 }
925 }
926 }
927 else if (gApplication->GetAppRemote()) {
928 // switch back to local session if not already in
930 Getlinem(kInit, "\nroot [0]");
931 }
932}
933
934////////////////////////////////////////////////////////////////////////////////
935/// Check if there is a filter active on the children of the list tree item.
936/// If the but argument is true, the "filter" button state is set accordingly,
937/// and its tooltip will show the filter used.
938
940{
941 Bool_t found = kFALSE;
942 TString filter;
943 // if there is no filter (the map is empty) then just return
944 if (fFilteredItems.empty())
945 return kFALSE;
946 auto it = fFilteredItems.find(item);
947 if (it != fFilteredItems.end()) {
948 // if the item is in the map, take the filter regexp string
949 filter = it->second.c_str();
950 fFilterStr = filter;
951 found = kTRUE;
952 }
953 if (but) {
954 // if the but argument is true, change the button state
955 // to reflect the filtering state
957 if (found) {
958 // format the tooltip to display the regexp used as filter
959 filter.Prepend("Showing only \'");
960 filter += "\'";
962 }
963 else {
964 // reset the tooltip text
965 fFilterButton->SetToolTipText("Filter Content...");
966 }
967 }
968 return found;
969}
970
971////////////////////////////////////////////////////////////////////////////////
972/// Check if the list tree item children are alphabetically sorted.
973/// If the but argument is true, the "sort" button state is set accordingly.
974
976{
977 Bool_t found = kFALSE;
978 TGListTreeItem *i, *itm;
979 if (item->GetFirstChild())
980 itm = item;
981 else
982 itm = item->GetParent();
983 for (sLTI_i p=fSortedItems.begin(); p!=fSortedItems.end(); ++p) {
984 i = (TGListTreeItem *)(*p);
985 if (itm == i) {
986 found = kTRUE;
987 break;
988 }
989 }
991 return found;
992}
993
994////////////////////////////////////////////////////////////////////////////////
995/// Process mouse clicks in TGListTree.
996
998{
999 char path[1024];
1000 Long64_t size = 0;
1001 Long_t id = 0, flags = 0, modtime = 0;
1002 fListLevel = item;
1003 if (!item) return;
1007 TObject *selected = 0;
1009 TObject *obj = (TObject *) item->GetUserData();
1010 if (obj && (!obj->InheritsFrom("TObjString") ||
1011 gSystem->AccessPathName(fullpath.Data()))) {
1012 if (obj->InheritsFrom("TKey") && (obj->IsA() != TClass::Class())) {
1013 Chdir(item);
1014 const char *clname = ((TKey *)obj)->GetClassName();
1015 if (clname && strcmp(clname, "TGeoManager")) {
1017 TString name = ((TKey *)obj)->GetName();
1018 name += ";";
1019 name += ((TKey *)obj)->GetCycle();
1020 void *add = gDirectory->FindObjectAny((char *) name.Data());
1021 if (add && cl->IsTObject()) {
1022 obj = (TObject*)add;
1023 // don't change the user data, to avoid deletion of the
1024 // list tree item by RecursiveRemove()
1025 // it is better to read the object each time anyway,
1026 // as it may have changed in the file
1027 if (obj->InheritsFrom("TDirectory") || obj->InheritsFrom("TList"))
1028 item->SetUserData(obj);
1029 }
1030 }
1031 }
1032 if (obj->InheritsFrom("TLeaf") ||
1033 obj->InheritsFrom("TBranch")) {
1034 Chdir(item);
1035 }
1036 if (btn == kButton3)
1037 fContextMenu->Popup(x, y, obj, fBrowser);
1038 selected = obj;
1039 }
1040 else {
1042 if (strlen(path) > 3) {
1043 if (gSystem->GetPathInfo(fullpath.Data(), &id, &size, &flags, &modtime) == 0) {
1044 if (flags & 2) {
1045 fCurrentDir = item;
1046 if (btn == kButton3) {
1047 if (fDir) delete fDir;
1048 fDir = new TSystemDirectory(item->GetText(), fullpath.Data());
1050 }
1051 }
1052 else {
1053 fCurrentDir = item->GetParent();
1054 if (btn == kButton3) {
1055 if (fFile) delete fFile;
1056 fFile = new TSystemFile(item->GetText(), fullpath.Data());
1058 }
1059 }
1060 }
1061 }
1062 }
1064 if (selected && (selected->IsA() != TClass::Class())) {
1065 if (selected->InheritsFrom("TLeaf"))
1066 selected = (TObject *)gROOT->ProcessLine(TString::Format("((TLeaf *)0x%zx)->GetBranch()->GetTree();", (size_t)selected));
1067 if (selected->InheritsFrom("TBranch"))
1068 selected = (TObject *)gROOT->ProcessLine(TString::Format("((TBranch *)0x%zx)->GetTree();", (size_t)selected));
1069 if (selected->InheritsFrom("TTree")) {
1070 // if a tree not attached to any directory (e.g. in a TFolder)
1071 // then attach it to the current directory (gDirectory)
1072 TDirectory *tdir = (TDirectory *)gROOT->ProcessLine(TString::Format("((TTree *)0x%zx)->GetDirectory();", (size_t)selected));
1073 if (!tdir) {
1074 gROOT->ProcessLine(TString::Format("((TTree *)0x%zx)->SetDirectory(gDirectory);", (size_t)selected));
1075 }
1076 }
1077 }
1078 if (selected && gPad && IsObjectEditable(selected->IsA())) {
1080 if (ved) {
1081 TGedEditor *ged = (TGedEditor *)ved;
1082 ged->SetModel(gPad, selected, kButton1Down);
1083 }
1084 }
1085}
1086
1087////////////////////////////////////////////////////////////////////////////////
1088/// returns an absolute path
1089
1091{
1092 TGListTreeItem *parent, *itm = item;
1093 TString dirname = itm->GetText();
1094
1095 while ((parent=itm->GetParent())) {
1096 char *s = gSystem->ConcatFileName(parent->GetText(), dirname);
1097 dirname = s;
1098 delete [] s;
1099 itm = parent;
1100 }
1102#ifdef R__WIN32
1103 // only handle .lnk files on Windows
1104 while (dirname.Contains(".lnk")) {
1105 Ssiz_t idx = dirname.Index(".lnk") + 4;
1107 resolved.Remove(idx);
1109 dirname = resolved.Append(dirname.Remove(0, idx));
1110 }
1111#endif
1112 return dirname;
1113}
1114
1115////////////////////////////////////////////////////////////////////////////////
1116/// returns the directory path
1117
1119{
1122
1123#ifdef WIN32
1124 char winDrive[256];
1125 char winDir[256];
1126 char winName[256];
1127 char winExt[256];
1130#else
1132#endif
1133 return dirname;
1134}
1135
1136////////////////////////////////////////////////////////////////////////////////
1137/// Returns true if given a text file
1138/// Uses the specification given on p86 of the Camel book
1139/// - Text files have no NULLs in the first block
1140/// - and less than 30% of characters with high bit set
1141
1142static Bool_t IsTextFile(const char *candidate)
1143{
1144 Int_t i;
1145 Int_t nchars;
1146 Int_t weirdcount = 0;
1147 char buffer[512];
1148 FILE *infile;
1149 FileStat_t buf;
1150
1151 if (gSystem->GetPathInfo(candidate, buf) || !(buf.fMode & kS_IFREG))
1152 return kFALSE;
1153
1154 infile = fopen(candidate, "r");
1155 if (infile) {
1156 // Read a block
1157 nchars = fread(buffer, 1, 512, infile);
1158 fclose (infile);
1159 // Examine the block
1160 for (i = 0; i < nchars; i++) {
1161 if (buffer[i] & 128)
1162 weirdcount++;
1163 if (buffer[i] == '\0')
1164 // No NULLs in text files
1165 return kFALSE;
1166 }
1167 if ((nchars > 0) && ((weirdcount * 100 / nchars) > 30))
1168 return kFALSE;
1169 } else {
1170 // Couldn't open it. Not a text file then
1171 return kFALSE;
1172 }
1173 return kTRUE;
1174}
1175
1176////////////////////////////////////////////////////////////////////////////////
1177/// Create a symlink (shortcut on Windows) icon by merging the picture
1178/// passed as argument and the slink_t.xpm icon (small arrow)
1179
1180static const TGPicture *MakeLinkPic(const TGPicture *pic)
1181{
1182 const TGPicture *merged;
1183 TImage *img1, *img2;
1184 if (pic) {
1185 img1 = TImage::Create();
1186 if (img1 == 0) return pic;
1187 img1->SetImage(((const TGPicture *)pic)->GetPicture(),
1188 ((const TGPicture *)pic)->GetMask());
1189 img2 = TImage::Open("slink_t.xpm");
1190 if (img2) img1->Merge(img2);
1191 TString lnk_name = ((const TGPicture *)pic)->GetName();
1192 lnk_name.Prepend("lnk_");
1193 merged = gClient->GetPicturePool()->GetPicture(lnk_name.Data(),
1194 img1->GetPixmap(), img1->GetMask());
1195 if (img2) delete img2;
1196 delete img1;
1197 return merged;
1198 }
1199 return pic;
1200}
1201
1202////////////////////////////////////////////////////////////////////////////////
1203/// Process double clicks in TGListTree.
1204
1206{
1207 const TGPicture *pic=0;
1212 Long64_t size;
1213 Long_t id, flags, modtime;
1214 char action[512];
1215 TString act;
1217 if (!gSystem->GetPathInfo(item->GetText(), sbuf) && sbuf.fIsLink) {
1218 is_link = kTRUE;
1219 fullpath = item->GetText();
1221 }
1222
1223 if (fNewBrowser)
1226 fListLevel = item;
1230 TGListTreeItem *pitem = item->GetParent();
1231 TObject *obj = (TObject *) item->GetUserData();
1232 if (obj && !obj->InheritsFrom("TSystemFile")) {
1233 TString ext = obj->GetName();
1234 if (obj->InheritsFrom("TDirectory") && (obj->IsA() != TClass::Class())) {
1235 if (((TDirectory *)obj)->GetListOfKeys())
1236 fNKeys = ((TDirectory *)obj)->GetListOfKeys()->GetEntries();
1237 else
1238 fNKeys = 0;
1239 }
1240 else if (obj->InheritsFrom("TKey") && (obj->IsA() != TClass::Class())) {
1241 Chdir(item);
1242 const char *clname = ((TKey *)obj)->GetClassName();
1243 if (clname) {
1245 TString name = ((TKey *)obj)->GetName();
1246 name += ";";
1247 name += ((TKey *)obj)->GetCycle();
1248 void *add = gDirectory->FindObjectAny((char *) name.Data());
1249 if (add && cl->IsTObject()) {
1250 obj = (TObject*)add;
1251 // don't change the user data, to avoid deletion of the
1252 // list tree item by RecursiveRemove()
1253 // it is better to read the object each time anyway,
1254 // as it may have changed in the file
1255 if (obj->InheritsFrom("TDirectory") || obj->InheritsFrom("TList"))
1256 item->SetUserData(obj);
1257 }
1258 }
1259 }
1260 else if (obj->InheritsFrom("TLeaf") || obj->InheritsFrom("TBranch")) {
1261 Chdir(item);
1262 }
1263 else if (obj->InheritsFrom("TRemoteObject")) {
1264 // the real object is a TKey
1266 if (!strcmp(robj->GetClassName(), "TKey")) {
1267 TGListTreeItem *parent = item;
1269 // find the TFile remote object containing the TKey
1270 while ( probj && strcmp(probj->GetClassName(), "TFile")) {
1271 parent = parent->GetParent();
1272 probj = (TRemoteObject *)parent->GetUserData();
1273 }
1274 if (probj && !strcmp(probj->GetClassName(), "TFile")) {
1275 // remotely browse file (remotely call TFile::cd())
1278 TString::Format("((TApplicationServer *)gApplication)->BrowseFile(\"%s\");",
1279 probj->GetName()));
1280 gSystem->Sleep(250);
1281 }
1282 }
1283 if (gClient->GetMimeTypeList()->GetAction(obj->GetName(), action)) {
1284 act = action;
1285 act.ReplaceAll("%s", obj->GetName());
1286 if ((act[0] != '!') && (strcmp(pitem->GetText(), "ROOT Files"))) {
1287 // special case for remote object: remote process
1289 gApplication->ProcessLine(act.Data());
1290 }
1291 }
1292 if ((ext.EndsWith(".root")) && (strcmp(pitem->GetText(), "ROOT Files"))) {
1294 gApplication->ProcessLine("((TApplicationServer *)gApplication)->BrowseFile(0);");
1295 }
1296 }
1297 if (!obj->InheritsFrom("TObjString") ||
1298 gSystem->AccessPathName(fullpath.Data())) {
1300 fDblClick = kTRUE;
1301 if (gClient->GetMimeTypeList()->GetAction(obj->IsA()->GetName(), action)) {
1302 act = action;
1303 if (fBrowser && act.Contains("->Browse()")) obj->Browse(fBrowser);
1304 else if (act.Contains("->Draw()")) obj->Draw(GetDrawOption());
1305 else {
1306 if (act.Contains("%s")) act.ReplaceAll("%s", obj->GetName());
1307 else act.Prepend(obj->GetName());
1308 gInterpreter->SaveGlobalsContext();
1309 if (act[0] == '!') {
1310 act.Remove(0, 1);
1311 gSystem->Exec(act.Data());
1312 } else {
1313 // special case for remote object: remote process
1314 if (obj->InheritsFrom("TRemoteObject"))
1316 gApplication->ProcessLine(act.Data());
1317 }
1318 }
1319 }
1320 else if (obj->InheritsFrom("TCanvas") && fNewBrowser &&
1323 // avoid potential crash when drawing a canvas with the same name
1324 // than a canvas already embedded in one of the browser's tab
1325 obj->DrawClone();
1326 } else if (fBrowser && !obj->InheritsFrom("TFormula"))
1327 obj->Browse(fBrowser);
1328 fDblClick = kFALSE;
1329 fNKeys = 0;
1330 fCnt = 0;
1332 if (gPad) gPad->Update();
1333 return;
1334 }
1335 }
1336 flags = id = size = modtime = 0;
1337 if (gSystem->GetPathInfo(fullpath.Data(), &id, &size, &flags, &modtime) != 0)
1338 return;
1339 Int_t isdir = (Int_t)flags & 2;
1340
1342 if (isdir) {
1343 fCurrentDir = item;
1344 //fListTree->DeleteChildren(item);
1345 TSystemDirectory dir(item->GetText(),FullPathName(item));
1346 TList *files = dir.GetListOfFiles();
1347 if (files) {
1348 files->Sort();
1349 TIter next(files);
1350 TSystemFile *file;
1352 // directories first
1353 //fListTree->DeleteChildren(item);
1354 while ((file=(TSystemFile*)next())) {
1355 fname = file->GetName();
1356 if (file->IsDirectory()) {
1357 if (!fShowHidden && fname.BeginsWith("."))
1358 continue;
1359 if ((fname!="..") && (fname!=".")) { // skip it
1362 if (!gSystem->GetPathInfo(fname, sbuf) &&
1363 sbuf.fIsLink) {
1364 // change the pictures if it is a symlink
1365 // (shortcut on Windows)
1366 const TGPicture *opened = 0, *l_opened = 0;
1367 const TGPicture *closed = 0, *l_closed = 0;
1368 opened = fClient->GetPicture("ofolder_t.xpm");
1370 closed = fClient->GetPicture("folder_t.xpm");
1372 if (l_opened && l_closed)
1373 itm->SetPictures(l_opened, l_closed);
1378 }
1379 // uncomment line below to set directories as
1380 // DND targets
1381 //itm->SetDNDTarget(kTRUE);
1382 itm->SetUserData(0);
1383 }
1384 }
1385 }
1386 }
1387 // then files...
1388 TIter nextf(files);
1389 while ((file=(TSystemFile*)nextf())) {
1390 fname = pname = file->GetName();
1391 if (!file->IsDirectory() && (fFilter == 0 ||
1392 (fFilter && fname.Index(*fFilter) != kNPOS))) {
1393 if (!fShowHidden && fname.BeginsWith("."))
1394 continue;
1395 size = modtime = 0;
1396 if (gSystem->GetPathInfo(fname, sbuf) == 0) {
1397 size = sbuf.fSize;
1398 modtime = sbuf.fMtime;
1399 }
1400 if (sbuf.fIsLink && pname.EndsWith(".lnk"))
1401 pname.Remove(pname.Length()-4);
1402 pic = gClient->GetMimeTypeList()->GetIcon(pname, kTRUE);
1403 if (!pic)
1404 pic = fFileIcon;
1405 if (sbuf.fIsLink)
1406 pic = MakeLinkPic(pic);
1409 if (pic != fFileIcon)
1411 if (sbuf.fIsLink) {
1412 TString fullname = file->GetName();
1413 gSystem->ExpandPathName(fullname);
1414 itm->SetUserData(new TObjString(TString::Format("file://%s\r\n",fullname.Data())), kTRUE);
1415 } else {
1416 itm->SetUserData(new TObjString(TString::Format("file://%s/%s\r\n",
1417 gSystem->UnixPathName(file->GetTitle()),
1418 file->GetName())), kTRUE);
1419 }
1420 itm->SetDNDSource(kTRUE);
1421 if (size && modtime) {
1422 char *tiptext = FormatFileInfo(fname.Data(), size, modtime);
1423 itm->SetTipText(tiptext);
1424 delete [] tiptext;
1425 }
1426 }
1427 }
1428 }
1429 files->Delete();
1430 delete files;
1431 }
1432 }
1433 else {
1434 TString lnkname = item->GetText();
1435 if (is_link && lnkname.EndsWith(".lnk"))
1436 lnkname.Remove(lnkname.Length()-4);
1437 fCurrentDir = item->GetParent();
1438 TSystemFile f(lnkname.Data(), fullpath.Data());
1439 TString fname = f.GetName();
1440 if (fname.EndsWith(".root")) {
1441 TDirectory *rfile = 0;
1443 rfile = (TDirectory *)gROOT->GetListOfFiles()->FindObject(obj);
1444 if (!rfile) {
1445 rfile = (TDirectory *)gROOT->ProcessLine(TString::Format("new TFile(\"%s\")",fname.Data()));
1446 }
1447 if (rfile) {
1448 // replace actual user data (TObjString) by the TDirectory...
1449 if (item->GetUserData()) {
1450 // first delete the data to avoid memory leaks
1451 TObject *obj2 = static_cast<TObject *>(item->GetUserData());
1452 // only delete TObjString as they are the only objects
1453 // created who have to be deleted
1454 TObjString *ostr = dynamic_cast<TObjString *>(obj2);
1455 if (ostr) delete ostr;
1456 }
1457 item->SetUserData(rfile);
1458 fNKeys = rfile->GetListOfKeys()->GetEntries();
1459 fCnt = 0;
1460 if (fBrowser) rfile->Browse(fBrowser);
1461 fNKeys = 0;
1462 fCnt = 0;
1463 }
1464 }
1465 else if (fname.EndsWith(".png")) {
1469 }
1470 else if (IsTextFile(fullpath.Data())) {
1472 if (fNewBrowser) {
1473 TGFrameElement *fe = 0;
1475 TGCompositeFrame *frame = tabRight->GetCurrentContainer();
1476 if (frame)
1477 fe = (TGFrameElement *)frame->GetList()->First();
1478 if (fe) {
1480 TString fullname = f.GetTitle();
1481 fullname.ReplaceAll("\\", "\\\\");
1482 if (embed->InheritsFrom("TGTextEditor")) {
1483 gROOT->ProcessLine(TString::Format("((TGTextEditor *)0x%zx)->LoadFile(\"%s\");",
1484 (size_t)embed, fullname.Data()));
1485 }
1486 else if (embed->InheritsFrom("TGTextEdit")) {
1487 gROOT->ProcessLine(TString::Format("((TGTextEdit *)0x%zx)->LoadFile(\"%s\");",
1488 (size_t)embed, fullname.Data()));
1489 }
1490 else {
1492 }
1493 }
1494 else {
1496 }
1497 }
1499 }
1500 else {
1504 }
1505 }
1506 //gSystem->ChangeDirectory(savdir.Data());
1508}
1509
1510////////////////////////////////////////////////////////////////////////////////
1511/// Execute default action for selected object (action is specified
1512/// in the $HOME/.root.mimes or $ROOTSYS/etc/root.mimes file.
1513
1515{
1516 char action[512];
1517 TString act;
1518 TString ext = obj->GetName();
1520
1521 if (gClient->GetMimeTypeList()->GetAction(obj->GetName(), action)) {
1522 act = action;
1523 act.ReplaceAll("%s", obj->GetName());
1524 gInterpreter->SaveGlobalsContext();
1525
1526 if (act[0] == '!') {
1527 act.Remove(0, 1);
1528 gSystem->Exec(act.Data());
1529 return 0;
1530 } else {
1531 // special case for remote object: remote process
1532 if (obj->InheritsFrom("TRemoteObject"))
1534
1535 const Long_t res = gApplication->ProcessLine(act.Data());
1536#ifdef R__HAS_COCOA
1537 if (act.Contains(".x") || act.Contains(".X")) {
1538 if (gPad) gPad->Update();
1539 }
1540#endif
1541 return res;
1542 }
1543 }
1544 return 0;
1545}
1546
1547////////////////////////////////////////////////////////////////////////////////
1548/// Format file information to be displayed in the tooltip.
1549
1551{
1552 Long64_t fsize, bsize;
1554 infos += "\n";
1555
1556 fsize = bsize = size;
1557 if (fsize > 1024) {
1558 fsize /= 1024;
1559 if (fsize > 1024) {
1560 // 3.7MB is more informative than just 3MB
1561 infos += TString::Format("Size: %lld.%lldM", fsize/1024, (fsize%1024)/103);
1562 } else {
1563 infos += TString::Format("Size: %lld.%lldK", bsize/1024, (bsize%1024)/103);
1564 }
1565 } else {
1566 infos += TString::Format("Size: %lld", bsize);
1567 }
1568 struct tm *newtime;
1569 time_t loctime = (time_t) modtime;
1571 if (newtime) {
1572 infos += "\n";
1573 infos += TString::Format("%d-%02d-%02d %02d:%02d",
1574 newtime->tm_year + 1900,
1575 newtime->tm_mon+1, newtime->tm_mday,
1576 newtime->tm_hour, newtime->tm_min);
1577 }
1578 return StrDup(infos.Data());
1579}
1580
1581////////////////////////////////////////////////////////////////////////////////
1582/// Retrieve icons associated with class "name". Association is made
1583/// via the user's ~/.root.mimes file or via $ROOTSYS/etc/root.mimes.
1584
1586{
1587 const char *clname = 0;
1588 TClass *objClass = 0;
1589 static TImage *im = 0;
1590 if (!im) {
1591 im = TImage::Create();
1592 }
1593
1594 if (obj->IsA() == TClass::Class()) {
1595 objClass = obj->IsA();
1596 if (objClass)
1597 clname = objClass->GetName();
1598 }
1599 else if (obj->InheritsFrom("TKey")) {
1600 clname = ((TKey *)obj)->GetClassName();
1601 }
1602 else if (obj->InheritsFrom("TKeyMapFile")) {
1603 clname = ((TKeyMapFile *)obj)->GetTitle();
1604 }
1605 else if (obj->InheritsFrom("TRemoteObject")) {
1606 // special case for remote object: get real object class
1608 if (!strcmp(robj->GetClassName(), "TKey"))
1609 clname = robj->GetKeyClassName();
1610 else
1611 clname = robj->GetClassName();
1612 }
1613 else {
1614 objClass = obj->IsA();
1615 if (objClass)
1616 clname = objClass->GetName();
1617 }
1618 if (!clname) {
1619 clname = "Unknown";
1620 }
1621 const char *name = obj->GetIconName() ? obj->GetIconName() : clname;
1623 Bool_t xpm = xpm_magic == "/* ";
1624 const char *iconname = xpm ? obj->GetName() : name;
1625
1626 if (obj->IsA()->InheritsFrom("TGeoVolume")) {
1627 iconname = obj->GetIconName() ? obj->GetIconName() : obj->IsA()->GetName();
1628 }
1629
1630 if (fCachedPicName == iconname) {
1631 *pic = fCachedPic;
1632 return;
1633 }
1634 *pic = gClient->GetMimeTypeList()->GetIcon(iconname, kTRUE);
1635 if (!(*pic) && xpm) {
1636 if (im && im->SetImageBuffer((char**)&name, TImage::kXpm)) {
1637 im->Scale(im->GetWidth()/4, im->GetHeight()/4);
1638 *pic = gClient->GetPicturePool()->GetPicture(iconname, im->GetPixmap(),
1639 im->GetMask());
1640 }
1641 gClient->GetMimeTypeList()->AddType("[thumbnail]", iconname, iconname, iconname, "->Browse()");
1642 return;
1643 }
1644 if (fCachedPic && (fCachedPic != fFileIcon))
1646 if (*pic == 0) {
1647 if (!obj->IsFolder())
1648 *pic = fFileIcon;
1649 }
1650 fCachedPic = *pic;
1651 fCachedPicName = iconname;
1652}
1653
1654////////////////////////////////////////////////////////////////////////////////
1655/// Go to the directory "path" and open all the parent list tree items.
1656
1657void TGFileBrowser::GotoDir(const char *path)
1658{
1660 ULong_t id;
1664 item = fRootDir;
1665 if (item == 0) return;
1667 TObjArray *tokens = sPath.Tokenize("/");
1668 if (tokens->IsEmpty()) {
1670 DoubleClicked(item, 1);
1671 delete tokens;
1674 return;
1675 }
1676 // if the Browser.ExpandDirectories option is set to "no", then don't
1677 // expand the parent directory tree (for example on nfs)
1678 TString str = gEnv->GetValue("Browser.ExpandDirectories", "yes");
1679 str.ToLower();
1680 expand = (str == "yes") ? kTRUE : kFALSE;
1681 TString first = ((TObjString*)tokens->At(0))->GetName();
1682 // always prevent expanding the parent directory tree on afs
1683 if (first == "afs")
1684 expand = kFALSE;
1685 // check also AFS_SUPER_MAGIC, NFS_SUPER_MAGIC, FUSE_SUPER_MAGIC,
1686 // CIFS_MAGIC_NUMBER and SMB_SUPER_MAGIC
1687 if (!gSystem->GetFsInfo(path, (Long_t *)&id, &bsize, &blocks, &bfree))
1688 if (id == 0x5346414f || id == 0x6969 || id == 0x65735546 || id == 0xff534d42 || id == 0x517b)
1689 expand = kFALSE;
1690 if (first.Length() == 2 && first.EndsWith(":")) {
1691 TList *curvol = gSystem->GetVolumes("cur");
1692 if (curvol) {
1693 TNamed *drive = (TNamed *)curvol->At(0);
1694 if (first == drive->GetName()) {
1695 TString infos = drive->GetTitle();
1696 if (infos.Contains("Network"))
1697 expand = kFALSE;
1698 }
1699 delete curvol;
1700 }
1701 }
1702 for (Int_t i = 0; i < tokens->GetEntriesFast(); ++i) {
1703 TString token = ((TObjString*)tokens->At(i))->GetName();
1704 if (token.Length() == 2 && token.EndsWith(":")) {
1705 token.Append("\\");
1706 itm = fListTree->FindChildByName(0, token);
1707 if (itm) {
1708 item = itm;
1710 if (expand)
1711 DoubleClicked(item, 1);
1712 }
1713 continue;
1714 }
1715 itm = fListTree->FindChildByName(item, token);
1716 if (itm) {
1717 item = itm;
1719 if (expand)
1720 DoubleClicked(item, 1);
1721 }
1722 else {
1723 itm = fListTree->AddItem(item, token);
1724 item = itm;
1726 if (expand)
1727 DoubleClicked(item, 1);
1728 }
1729 }
1731 DoubleClicked(item, 1);
1732 delete tokens;
1735}
1736
1737////////////////////////////////////////////////////////////////////////////////
1738/// Slot used to switch to the tab containing the current pad/canvas (gPad)
1739/// used e.g. when drawing a histogram by double-clicking on its list tree
1740/// item in a root file.
1741
1743{
1744 if (fDblClick && fNewBrowser) {
1745 Int_t i;
1747 for (i=0;i<tabRight->GetNumberOfTabs();++i) {
1748 TGFrameElement *fe = 0;
1750 TGCompositeFrame *frame = tabRight->GetTabContainer(i);
1751 if (frame)
1752 fe = (TGFrameElement *)frame->GetList()->First();
1753 if (fe)
1754 embed = (TGCompositeFrame *)fe->fFrame;
1755 if (embed && embed->InheritsFrom("TRootCanvas")) {
1756 ULongptr_t canvas = gROOT->ProcessLine(TString::Format("((TRootCanvas *)0x%zx)->Canvas();",
1757 (size_t)embed));
1758 if ((canvas) && (canvas == (ULongptr_t)gPad ||
1759 canvas == (ULongptr_t)gPad->GetCanvas())) {
1760 tabRight->SetTab(i, kTRUE);
1761 break;
1762 }
1763 }
1764 }
1765 }
1766}
1767
1768////////////////////////////////////////////////////////////////////////////////
1769/// Open a dialog box asking for a string to be used as filter (regexp), and
1770/// add an entry in the map of filtered entries. Entering "*" or empty string
1771/// ("") will disable filtering on the current list tree item.
1772
1774{
1775 char filter[1024];
1776 if (!fListLevel)
1777 return;
1778 // initialize with previous (active) filter string
1779 snprintf(filter, sizeof(filter), "%s", fFilterStr.Data());
1780 new TGInputDialog(gClient->GetRoot(), this,
1781 "Enter filter expression:\n(empty string \"\" or \"*\" to remove filter)",
1782 filter, filter);
1783 // if user pressed cancel, update the status of the current list tree
1784 // item and return
1785 if ((filter[0] == 0) && (filter[1] == 0)) {
1787 return;
1788 }
1789 else if (((filter[0] == 0) && (filter[1] == 1)) || !strcmp(filter, "*")) {
1790 // if user entered "*" or "", just disable filtering for the current
1791 // list tree item
1794 } else {
1795 // if user entered a string different from "*", use it to create an
1796 // entry in the filter map
1797 fFilterStr = filter;
1799 // if there is already a filter on this item, delete it
1802 // insert a new entry for the current list tree item
1803 fFilteredItems.emplace(fListLevel, filter);
1804 }
1805 // finally update the list tree
1810}
1811
1812////////////////////////////////////////////////////////////////////////////////
1813/// A ROOT File has been selected in TGHtmlBrowser.
1814
1816{
1817 TGListTreeItem *itm = fListTree->FindChildByData(0, gROOT->GetListOfFiles());
1818 if (itm) {
1820 fListLevel = itm;
1823 BrowseObj(gROOT->GetListOfFiles());
1826 }
1827}
1828
1829////////////////////////////////////////////////////////////////////////////////
1830/// Toggle the sort mode and set the "sort button" state accordingly.
1831
1833{
1834 if (!fListLevel) return;
1837 if (!fListLevel->GetFirstChild()) {
1840 }
1841 if (!item)
1842 return;
1844 if (!is_sorted) {
1845 //alphabetical sorting
1847 fSortedItems.push_back(item);
1849 } else {
1851 DoubleClicked(item, 1);
1852 fSortedItems.remove(item);
1854 gClient->NeedRedraw(fListTree, kTRUE);
1855 gClient->HandleInput();
1856 if (itemname.Length() > 0) {
1858 if (itm) {
1860 Clicked(itm, 1, 0, 0);
1861 itm->SetActive(kTRUE);
1864 }
1865 }
1866 }
1869}
1870
1871
@ kButton1Down
Definition Buttons.h:17
@ kWatch
Definition GuiTypes.h:375
@ kPointer
Definition GuiTypes.h:375
@ kHorizontalFrame
Definition GuiTypes.h:382
@ kButton3
Definition GuiTypes.h:214
#define b(i)
Definition RSha256.hxx:100
#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
Boolean (0=false, 1=true) (bool)
Definition RtypesCore.h:77
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
unsigned long ULong_t
Unsigned long integer 4 bytes (unsigned long). Size depends on architecture.
Definition RtypesCore.h:69
long Long_t
Signed long integer 4 bytes (long). Size depends on architecture.
Definition RtypesCore.h:68
unsigned long ULongptr_t
Unsigned integer large enough to hold a pointer (platform-dependent)
Definition RtypesCore.h:90
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
constexpr Ssiz_t kNPOS
The equivalent of std::string::npos for the ROOT class TString.
Definition RtypesCore.h:131
long long Long64_t
Portable signed long integer 8 bytes.
Definition RtypesCore.h:83
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
const char Option_t
Option string (const char)
Definition RtypesCore.h:80
R__EXTERN TApplication * gApplication
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define gDirectory
Definition TDirectory.h:385
R__EXTERN TEnv * gEnv
Definition TEnv.h:170
@ kButtonUp
Definition TGButton.h:53
@ kButtonEngaged
Definition TGButton.h:55
#define gClient
Definition TGClient.h:157
const char * filters[]
static Bool_t IsObjectEditable(TClass *cl)
Helper function checking if a class has a graphic properties editor.
static const TGPicture * MakeLinkPic(const TGPicture *pic)
Create a symlink (shortcut on Windows) icon by merging the picture passed as argument and the slink_t...
static const char * FormatToolTip(TObject *obj, Int_t maxlen=0)
Format the tooltip information, based on the object passed in argument.
const char rootdir[]
static Bool_t IsTextFile(const char *candidate)
Returns true if given a text file Uses the specification given on p86 of the Camel book.
@ kDeepCleanup
Definition TGFrame.h:42
@ kLHintsRight
Definition TGLayout.h:26
@ kLHintsExpandY
Definition TGLayout.h:31
@ kLHintsLeft
Definition TGLayout.h:24
@ kLHintsCenterY
Definition TGLayout.h:28
@ 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 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 Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t del
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 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 type
Option_t Option_t TPoint TPoint const char text
char name[80]
Definition TGX11.cxx:110
#define gInterpreter
#define gROOT
Definition TROOT.h:411
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2495
char * StrDup(const char *str)
Duplicate the string str.
Definition TString.cxx:2563
Bool_t R_ISREG(Int_t mode)
Definition TSystem.h:126
Bool_t R_ISDIR(Int_t mode)
Definition TSystem.h:123
R__EXTERN TSystem * gSystem
Definition TSystem.h:572
@ kS_IXUSR
Definition TSystem.h:112
@ kS_IFREG
Definition TSystem.h:101
#define gPad
#define gVirtualX
Definition TVirtualX.h:337
#define snprintf
Definition civetweb.c:1579
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 "....
TApplication * GetAppRemote() const
virtual const char * ApplicationName() const
Each class (see TClass) has a linked list of its base class(es).
Definition TBaseClass.h:33
TClass * GetClassPointer(Bool_t load=kTRUE)
Get pointer to the base class TClass.
ABC describing GUI independent browser implementation protocol.
Definition TBrowserImp.h:29
TBrowser * fBrowser
TBrowser associated with this implementation.
Definition TBrowserImp.h:32
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
void SetDrawOption(Option_t *option="") override
Set drawing option for object.
Definition TBrowser.h:106
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84
static TClass * Class()
TList * GetListOfBases()
Return list containing the TBaseClass(es) of a class.
Definition TClass.cxx:3663
Bool_t IsTObject() const
Return kTRUE is the class inherits from TObject.
Definition TClass.cxx:5980
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:2973
This class provides an interface to context sensitive popup menus.
virtual void Popup(Int_t x, Int_t y, TObject *obj, TVirtualPad *c=nullptr, TVirtualPad *p=nullptr)
Popup context menu at given location in canvas c and pad p for selected object.
Helper class used to change the cursor in a method and restore the original one when going out of the...
TCursorSwitcher(TGWindow *w1, TGWindow *w2)
Describe directory structure in memory.
Definition TDirectory.h:45
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:490
virtual void SetToolTipText(const char *text, Long_t delayms=400)
Set tool tip text associated with this button.
Definition TGButton.cxx:439
virtual void SetStyle(UInt_t newstyle)
Set the button style (modern or classic).
Definition TGButton.cxx:265
virtual void SetState(EButtonState state, Bool_t emit=kFALSE)
Set button state.
Definition TGButton.cxx:229
A frame containing two scrollbars (a horizontal and a vertical) and a viewport.
Definition TGCanvas.h:192
const TGPicture * GetPicture(const char *name)
Get picture from the picture pool.
Definition TGClient.cxx:288
void FreePicture(const TGPicture *pic)
Free picture resource.
Definition TGClient.cxx:316
A combobox (also known as a drop down listbox) allows the selection of one item out of a list of item...
Definition TGComboBox.h:47
virtual TGLBEntry * GetSelectedEntry() const
Definition TGComboBox.h:115
virtual TGTextEntry * GetTextEntry() const
Definition TGComboBox.h:111
virtual void AddEntry(TGString *s, Int_t id)
Definition TGComboBox.h:86
virtual TGListBox * GetListBox() const
Definition TGComboBox.h:110
The base class for composite widgets (menu bars, list boxes, etc.).
Definition TGFrame.h:289
TGDimension GetDefaultSize() const override
std::cout << fWidth << "x" << fHeight << std::endl;
Definition TGFrame.h:318
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=nullptr)
Add frame to the composite frame using the specified layout hints.
Definition TGFrame.cxx:1109
virtual TList * GetList() const
Definition TGFrame.h:312
virtual void Cleanup()
Cleanup and delete all objects contained in this composite frame.
Definition TGFrame.cxx:959
void MapSubwindows() override
Map all sub windows that are part of the composite frame.
Definition TGFrame.cxx:1156
void SetCleanup(Int_t mode=kLocalCleanup) override
Turn on automatic cleanup of child frames in dtor.
Definition TGFrame.cxx:1064
virtual void ClearViewPort()
Clear view port and redraw full content.
Definition TGCanvas.cxx:888
TGListTreeItem * fRootDir
Root (list tree) directory.
Int_t fGroupSize
total number of items when icon box switched to "global view" mode
Bool_t CheckFiltered(TGListTreeItem *item, Bool_t but=kFALSE)
Check if there is a filter active on the children of the list tree item.
TString DirName(TGListTreeItem *item)
returns the directory path
TSystemFile * fFile
Actual (selected) system file.
TGHorizontalFrame * fBotFrame
Bottom horizontal frame.
void GetObjPicture(const TGPicture **pic, TObject *obj)
Retrieve icons associated with class "name".
TGListTree * fListTree
Main list tree.
void AddKey(TGListTreeItem *itm, TObject *obj, const char *name=nullptr)
display content of ROOT file
TGFileBrowser(const TGWindow *p, TBrowser *b=nullptr, UInt_t w=200, UInt_t h=400)
TGFileBrowser constructor.
void CreateBrowser()
Create the actual file browser.
Bool_t fShowHidden
kTRUE to display hidden files
Bool_t fDblClick
kTRUE if user double-clicked on a list tree item
TGListTreeItem * fCurrentDir
Current (list tree) directory.
Bool_t CheckSorted(TGListTreeItem *item, Bool_t but=kFALSE)
Check if the list tree item children are alphabetically sorted.
void Clicked(TGListTreeItem *item, Int_t btn, Int_t x, Int_t y)
Process mouse clicks in TGListTree.
void DoubleClicked(TGListTreeItem *item, Int_t btn)
Process double clicks in TGListTree.
void BrowseObj(TObject *obj) override
Browse object.
void ApplyFilter(Int_t id)
Apply filter selected in combo box to the file tree view.
TGPictureButton * fFilterButton
"Filter" button
void PadModified()
Slot used to switch to the tab containing the current pad/canvas (gPad) used e.g.
void GotoDir(const char *path)
Go to the directory "path" and open all the parent list tree items.
void RecursiveRemove(TObject *obj) override
Recursively remove object.
void ToggleSort()
Toggle the sort mode and set the "sort button" state accordingly.
TGListTreeItem * fListLevel
Current list tree level.
void AddRemoteFile(TObject *obj)
Add remote file in list tree.
TString fFilterStr
Filter expression string.
TRegexp * fFilter
Regular expression used to filter files.
void GetFilePictures(const TGPicture **pic, Int_t file_type, Bool_t is_link, const char *name)
Determine the file picture for the given file type.
TSystemDirectory * fDir
Actual (selected) system directory.
Long_t fCnt
Counters for keys inside a Root file.
void Add(TObject *obj, const char *name=nullptr, Int_t check=-1) override
Add items to the browser.
sLTI_t fSortedItems
List of sorted list-tree items.
~TGFileBrowser() override
Destructor.
const TGPicture * fCachedPic
Cached picture.
void RequestFilter()
Open a dialog box asking for a string to be used as filter (regexp), and add an entry in the map of f...
TGComboBox * fFileType
File type combobox.
TGCanvas * fCanvas
Canvas for the list tree.
TContextMenu * fContextMenu
pointer to context menu
TRootBrowser * fNewBrowser
Pointer back to the Browser.
char * FormatFileInfo(const char *fname, Long64_t size, Long_t modtime)
Format file information to be displayed in the tooltip.
TString FullPathName(TGListTreeItem *item)
returns an absolute path
TGPictureButton * fSortButton
"Sort" button
TGComboBox * fDrawOption
Draw options combobox.
void Checked(TObject *obj, Bool_t check)
Emits signal when double clicking on icon.
const TGPicture * fFileIcon
System files icon.
Option_t * GetDrawOption() const override
returns drawing option
TGPictureButton * fRefreshButton
"Refresh" button
void CheckRemote(TGListTreeItem *item)
Check if the current list tree item points to a remote object.
void Update()
Update content of the list tree.
const TGPicture * fRootIcon
Root files icon.
void Selected(char *)
A ROOT File has been selected in TGHtmlBrowser.
void Show() override
void AddFSDirectory(const char *entry, const char *path=nullptr, Option_t *opt="")
Add file system directory in the list tree.
void Refresh(Bool_t force=kFALSE) override
Refresh content of the list tree.
TString fCachedPicName
Cached picture name.
mFiltered_t fFilteredItems
List of filtered list-tree items.
Long_t XXExecuteDefaultAction(TObject *obj)
Execute default action for selected object (action is specified in the $HOME/.root....
void Chdir(TGListTreeItem *item)
Make object associated with item the current directory.
sLTI_t::iterator sLTI_i
TGHorizontalFrame * fTopFrame
Top horizontal frame.
void Resize(UInt_t w=0, UInt_t h=0) override
Resize the frame.
Definition TGFrame.cxx:597
void MapWindow() override
map window
Definition TGFrame.h:206
A composite frame that layout their children in horizontal way.
Definition TGFrame.h:387
Input Dialog Widget.
This class handles GUI labels.
Definition TGLabel.h:24
This class describes layout hints used by the layout classes.
Definition TGLayout.h:50
A listbox is a box, possibly with scrollbar, containing entries.
Definition TGListBox.h:221
TGListTreeItem * GetFirstChild() const
Definition TGListTree.h:61
virtual const char * GetText() const =0
TGListTreeItem * GetParent() const
Definition TGListTree.h:60
virtual void SetTipText(const char *)
Definition TGListTree.h:79
void SetDNDSource(Bool_t onoff)
Definition TGListTree.h:110
virtual void * GetUserData() const =0
A list tree is a widget that can contain a number of items arranged in a tree structure.
Definition TGListTree.h:197
TGListTreeItem * FindItemByObj(TGListTreeItem *item, void *ptr)
Find item with fUserData == ptr.
void ClearHighlighted()
Un highlight items.
void AddItem(TGListTreeItem *parent, TGListTreeItem *item)
Add given item to list tree.
Int_t DeleteChildren(TGListTreeItem *item)
Delete children of item from list.
void CheckItem(TGListTreeItem *item, Bool_t check=kTRUE)
Set check button state for the node 'item'.
void OpenItem(TGListTreeItem *item)
Open item in list tree (i.e. show child items).
TGListTreeItem * GetSelected() const
Definition TGListTree.h:384
Int_t RecursiveDeleteItem(TGListTreeItem *item, void *userData)
Delete item with fUserData == ptr.
Int_t DeleteItem(TGListTreeItem *item)
Delete item from list tree.
void SetSelected(TGListTreeItem *item)
Definition TGListTree.h:355
TGListTreeItem * GetFirstItem() const
Definition TGListTree.h:383
TGListTreeItem * FindChildByName(TGListTreeItem *item, const char *name)
Find child of item by name.
Int_t SortChildren(TGListTreeItem *item)
Sort children of item.
void AdjustPosition(TGListTreeItem *item)
Move content to position of item.
void HighlightItem(TGListTreeItem *item)
Highlight item.
TGListTreeItem * FindChildByData(TGListTreeItem *item, void *userData)
Find child of item by userData.
void SetToolTipItem(TGListTreeItem *item, const char *string)
Set tooltip text for this item.
void GetPathnameFromItem(TGListTreeItem *item, char *path, Int_t depth=0)
Get pathname from item.
Defines top level windows that interact with the system Window Manager.
Definition TGFrame.h:399
TGClient * fClient
Connection to display server.
Definition TGObject.h:25
Handle_t GetId() const
Definition TGObject.h:41
Yield an action as soon as it is clicked.
Definition TGButton.h:228
The TGPicture class implements pictures and icons used in the different GUI elements and widgets.
Definition TGPicture.h:25
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:660
A TGTextEntry is a one line text input widget.
Definition TGTextEntry.h:24
Text string listbox entries.
Definition TGListBox.h:48
ROOT GUI Window base class.
Definition TGWindow.h:23
const char * GetName() const override
Return unique name, used in SavePrimitive methods.
Definition TGWindow.cxx:334
virtual void SetModel(TVirtualPad *pad, TObject *obj, Int_t event, Bool_t force=kFALSE)
Activate object editors according to the selected object.
An abstract interface to image processing library.
Definition TImage.h:29
static TImage * Open(const char *file, EImageFileTypes type=kUnknown)
Open a specified image file.
Definition TImage.cxx:117
@ kXpm
Definition TImage.h:37
static TImage * Create()
Create an image.
Definition TImage.cxx:34
Utility class for browsing TMapFile objects.
Definition TKeyMapFile.h:20
Book space in a file, create I/O buffers, to fill them, (un)compress them.
Definition TKey.h:28
A doubly linked list.
Definition TList.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:49
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:50
An array of TObjects.
Definition TObjArray.h:31
Collectable string class.
Definition TObjString.h:28
Mother of all ROOT objects.
Definition TObject.h:41
virtual Bool_t IsFolder() const
Returns kTRUE in case object contains browsable objects (like containers or lists of other objects).
Definition TObject.cxx:573
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:457
virtual void Browse(TBrowser *b)
Browse object. May be overridden for another default action.
Definition TObject.cxx:217
virtual const char * GetIconName() const
Returns mime type name of object.
Definition TObject.cxx:467
virtual TObject * DrawClone(Option_t *option="") const
Draw a clone of this object in the current selected pad with: gROOT->SetSelectedPad(c1).
Definition TObject.cxx:318
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Returns string containing info about the object at position (px,py).
Definition TObject.cxx:486
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:864
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:543
virtual const char * GetTitle() const
Returns title of object.
Definition TObject.cxx:501
virtual TClass * IsA() const
Definition TObject.h:246
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition TObject.cxx:293
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:865
Bool_t Disconnect(const char *signal=nullptr, void *receiver=nullptr, const char *slot=nullptr)
Disconnects signal of this object from slot of receiver.
Regular expression class.
Definition TRegexp.h:31
The TRemoteObject class provides protocol for browsing ROOT objects from a remote ROOT session.
This class creates a ROOT object browser, constituted by three main tabs.
void SetActBrowser(TBrowserImp *b)
virtual void Checked(TObject *obj, Bool_t check)
Emits signal when double clicking on icon.
TGTab * GetTabRight() const
Basic string class.
Definition TString.h:138
Ssiz_t Length() const
Definition TString.h:425
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition TString.cxx:2250
const char * Data() const
Definition TString.h:384
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:712
TString & Prepend(const char *cs)
Definition TString.h:681
TString & Append(const char *cs)
Definition TString.h:580
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:2384
Describes an Operating System directory for the browser.
virtual TList * GetListOfFiles() const
Returns a TList of TSystemFile objects representing the contents of the directory.
A TSystemFile describes an operating system file.
Definition TSystemFile.h:29
virtual Bool_t IsDirectory(const char *dir=nullptr) const
Check if object is a directory.
virtual int GetFsInfo(const char *path, Long_t *id, Long_t *bsize, Long_t *blocks, Long_t *bfree)
Get info about a file system: fs type, block size, number of blocks, number of free blocks.
Definition TSystem.cxx:1483
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
Definition TSystem.cxx:1285
virtual char * ConcatFileName(const char *dir, const char *name)
Concatenate a directory and a file name.
Definition TSystem.cxx:1082
virtual Int_t Exec(const char *shellcmd)
Execute a command.
Definition TSystem.cxx:651
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:1409
virtual TList * GetVolumes(Option_t *) const
Definition TSystem.h:465
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:1307
virtual Bool_t ChangeDirectory(const char *path)
Change directory.
Definition TSystem.cxx:872
virtual const char * UnixPathName(const char *unixpathname)
Convert from a local pathname to a Unix pathname.
Definition TSystem.cxx:1073
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
Definition TSystem.cxx:435
virtual const char * WorkingDirectory()
Return working directory.
Definition TSystem.cxx:881
virtual TString GetDirName(const char *pathname)
Return the directory name in pathname.
Definition TSystem.cxx:1042
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:261
Abstract base class used by ROOT graphics editor.
static TVirtualPadEditor * GetPadEditor(Bool_t load=kTRUE)
Returns the pad editor dialog. Static method.
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
R__ALWAYS_INLINE bool HasBeenDeleted(const TObject *obj)
Check if the TObject's memory has been deleted.
Definition TObject.h:405
Int_t fMode
Definition TSystem.h:135