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