FEDRA emulsion software from the OPERA Collaboration
Public Member Functions | Public Attributes | Protected Attributes | List of all members
EdbDisplayBase Class Reference

#include <EdbDisplayBase.h>

Inheritance diagram for EdbDisplayBase:
Inheritance graph
[legend]
Collaboration diagram for EdbDisplayBase:
Collaboration graph
[legend]

Public Member Functions

virtual void Clear ()
 
virtual void ClearNewVTX ()
 
virtual void ClearPreVTX ()
 
virtual void CreateCanvasVTX ()
 
virtual void DisplayButtons ()
 
virtual Int_t DistancetoPrimitive (Int_t px, Int_t py)
 
virtual void Draw (Option_t *option="")
 
virtual void DrawAcc ()
 
virtual void DrawAllViews ()
 
virtual void DrawCan ()
 
virtual void DrawDetector ()
 
virtual void DrawEnv ()
 
virtual void DrawNewBut (char *text)
 
virtual void DrawNewVTX (char *text)
 
virtual void DrawOldBut (char *text)
 
virtual void DrawOldVTX (char *text)
 
virtual void DrawPreBut (char *text)
 
virtual void DrawPreVTX (char *text)
 
virtual void DrawTitle (Option_t *option="")
 
virtual void DrawUnd ()
 
virtual void DrawView (Float_t theta, Float_t phi, Float_t psi=0)
 
virtual void DrawViewGL ()
 
virtual void DrawViewX3D ()
 
 EdbDisplayBase ()
 
 EdbDisplayBase (const char *title, Float_t x0, Float_t x1, Float_t y0, Float_t y1, Float_t z0, Float_t z1, TCanvas *Canvas=0)
 
virtual void ExecuteEvent (Int_t event, Int_t px, Int_t py)
 
Bool_t GetDrawDet () const
 
virtual char * GetObjectInfo (int px, int py) const
 
virtual void Refresh ()
 
virtual void Set0 ()
 
virtual void SetColorBG (int color=1)
 
virtual void SetDetector (TGeoVolume *det)
 
virtual void SetDrawDet (Bool_t fflag)
 
virtual void SetLineWidth (int width=1)
 
virtual void SetPickMode ()
 
virtual void SetRange (Float_t x0, Float_t x1, Float_t y0, Float_t y1, Float_t z0, Float_t z1)
 
virtual void SetRotate ()
 
virtual void SetStyle (int Style=0)
 
virtual void SetView (Float_t theta, Float_t phi, Float_t psi=0)
 
virtual void SetZoomMode ()
 
virtual void SwDrawDet ()
 
virtual void UnZoom ()
 
 ~EdbDisplayBase ()
 

Public Attributes

TCanvas * fCanvas
 
TCanvas * fCanvasTRK
 
TCanvas * fCanvasVTX
 
TPad * fPad
 
TPaveText * fVTXTRKInfo
 

Protected Attributes

TButton * fAccButton
 
TButton * fAllButton
 
TArc * fArcButton
 
TPad * fButtons
 
TButton * fCanButton
 
char fCanvasName [128]
 
Int_t fColorBG
 
TGeoVolume * fDetector
 
Bool_t fDrawAllViews
 
Bool_t fDrawDet
 
TButton * fEnvButton
 
TText * fHdrVTX
 
Width_t fLineWidth
 
TGMainFrame * fMain
 
TButton * fNewBut
 
TText * fNewVTX
 
TButton * fOldBut
 
TText * fOldVTX
 
Float_t fPhi
 
TButton * fPickButton
 
TButton * fPreBut
 
TText * fPreVTX
 
Float_t fPsi
 
TButton * fRemBut [50]
 
Int_t fStyle
 
Float_t fTheta
 
char fTitle [128]
 
TPad * fTrigPad
 
TButton * fUndButton
 
TButton * fUnZoomButton
 
Edb3DView * fView
 
TPaveText * fVTXTracks
 
Float_t fVx0
 
Float_t fVx1
 
Float_t fVy0
 
Float_t fVy1
 
Float_t fVz0
 
Float_t fVz1
 
TButton * fZoomButton
 
Int_t fZoomMode
 
Int_t fZooms
 
Double_t fZoomX0 [kMAXZOOMS]
 
Double_t fZoomX1 [kMAXZOOMS]
 
Double_t fZoomY0 [kMAXZOOMS]
 
Double_t fZoomY1 [kMAXZOOMS]
 

Constructor & Destructor Documentation

◆ EdbDisplayBase() [1/2]

EdbDisplayBase::EdbDisplayBase ( )
27 {
28  //
29  // Default constructor
30  //
31  Set0();
32 }
EdbDisplayBase::Set0
virtual void Set0()
Definition: EdbDisplayBase.cxx:224

◆ EdbDisplayBase() [2/2]

EdbDisplayBase::EdbDisplayBase ( const char *  title,
Float_t  x0,
Float_t  x1,
Float_t  y0,
Float_t  y1,
Float_t  z0,
Float_t  z1,
TCanvas *  Canvas = 0 
)
40 {
41  char VPadName[140], TPadName[140];
42  char ZoomButName[140], PickButName[140], UnZoomButName[140];
43  char CanTitle[140];
44  char *pres = 0, *ptitle = 0;
45 
46  Set0();
47  fVx0=x0; fVx1=x1; fVy0=y0; fVy1=y1; fVz0=z0; fVz1=z1;
48  if(gEDBDEBUGLEVEL>2) printf("create display in limits: \nX = %f : %f \nY = %f : %f \nZ = %f : %f\n",
49  x0,x1,y0,y1,z0,z1);
50 
51  // Set side view by default
52  fTheta = 180;
53  fPhi = 90;
54  fPsi = 90;
55 
56  fDrawAllViews = kFALSE;
57  fZoomMode = 1;
58  fZooms = 0;
59 
60  if ((pres = strstr((char*)title, "Presentation"))) SetStyle(1); // presentation style
61  else if ((pres = strstr((char*)title, "presentation"))) SetStyle(1);
62  strcpy(fTitle, title);
63  ptitle = fTitle;
64  while (*ptitle) { if (*ptitle == ' ') *ptitle = '_'; ptitle++; }
65  this->SetName(&fTitle[0]);
66  this->SetTitle("FEDRA Event Display");
67  strcpy(fCanvasName, "Canvas-");
68  strcat(fCanvasName, title);
69  ptitle = fCanvasName;
70  while (*ptitle) { if (*ptitle == ' ') *ptitle = '_'; ptitle++; }
71  strcpy(CanTitle, "FEDRA Event Display: ");
72  strcat(CanTitle, title);
73 
74  // if Canvas not defined, then run as standalone viewer
75 
76  if (!Canvas) fCanvas = new TCanvas(fCanvasName, CanTitle, 14, 47, 800, 700);
77  else {
78  fCanvas = Canvas;
79  fCanvas->SetName(fCanvasName);
80  fCanvas->SetTitle(CanTitle);
81  }
82 
83  fCanvas->ToggleEventStatus();
84 
85  // Create main display pad
86  strcpy(VPadName, "ViewPad-");
87  strcat(VPadName, title);
88  fPad = new TPad(VPadName, "FEDRA Event Display",0.15,0.,1.,1.);
89  fPad->Draw();
90  fPad->Modified(kTRUE);
91  fPad->SetFillColor(kBlack);
92  fPad->SetBorderSize(2);
93 
94  // Create view type control pad
95  DisplayButtons();
96 
97  // Create Control pad
98  fCanvas->cd();
99  Float_t dxtr = 0.15;
100  Float_t dytr = 0.35;
101  strcpy(TPadName, "ControlPad-");
102  strcat(TPadName, title);
103  fTrigPad = new TPad(TPadName, "Control Pad",0,0,dxtr,dytr);
104  fTrigPad->Draw();
105  fTrigPad->cd();
106 
107  if (fStyle/2 == 1) fTrigPad->SetFillColor(38); // blue shades
108  else fTrigPad->SetFillColor(22); // brown shades
109 
110  fTrigPad->SetBorderSize(2);
111 
112  Int_t butcolor = 33; // blue shades
113  if (fStyle/2 == 1) butcolor = 33; // blue shades
114  else butcolor = 38; // blue shades
115 
116  char undov[256];
117  sprintf(undov,
118  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->UndoModifiedVTX()",fTitle);
119  Float_t db = 0.09;
120  fUndButton = new TButton("Undo VTX",undov,0.05,0.85,0.95,0.85+db);
121  fUndButton->SetToolTipText("Undo last vertex modification");
122  fUndButton->SetFillColor(butcolor);
123  fUndButton->Draw();
124 
125  char cancelv[256];
126  sprintf(cancelv,
127  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->CancelModifiedVTX()",fTitle);
128  fCanButton = new TButton("Cancel VTX",cancelv,0.05,0.74,0.95,0.74+db);
129  fCanButton->SetToolTipText("Cancel vertex modifications");
130  fCanButton->SetFillColor(butcolor);
131  fCanButton->Draw();
132 
133  char acceptv[256];
134  sprintf(acceptv,
135  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->AcceptModifiedVTX()",fTitle);
136  fAccButton = new TButton("Accept VTX",acceptv,0.05,0.63,0.95,0.63+db);
137  fAccButton->SetToolTipText("Accept vertex modifications");
138  fAccButton->SetFillColor(butcolor);
139  fAccButton->Draw();
140 
141  char envv[256];
142  sprintf(envv,
143  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVertexEnvironment()",fTitle);
144  fEnvButton = new TButton("Neighbor",envv,0.05,0.47,0.95,0.47+db);
145  fEnvButton->SetToolTipText("Draw vertex neighborhood");
146  fEnvButton->SetFillColor(butcolor);
147  fEnvButton->Draw();
148 
149  char allv[256];
150  sprintf(allv,
151  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawAllObjects()",fTitle);
152  fAllButton = new TButton("AllObjcts",allv,0.05,0.47,0.95,0.47+db);
153  fAllButton->SetToolTipText("Draw all objects");
154  fAllButton->SetFillColor(butcolor);
155  fAllButton->Draw();
156 
157  char pickmode[256];
158  sprintf(pickmode,
159  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetPickMode()",fTitle);
160  fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
161  fPickButton->SetToolTipText("Set Pickup mode");
162  fPickButton->SetFillColor(butcolor);
163  strcpy(PickButName, "PickBut-");
164  strcat(PickButName, title);
165  fPickButton->SetName(PickButName);
166  fPickButton->Draw();
167 
168  char zoommode[256];
169  sprintf(zoommode,
170  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetZoomMode()",fTitle);
171  fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
172  fZoomButton->SetToolTipText("Set Zooming mode");
173  fZoomButton->SetFillColor(butcolor);
174  strcpy(ZoomButName, "ZoomBut-");
175  strcat(ZoomButName, title);
176  fZoomButton->SetName(ZoomButName);
177  fZoomButton->Draw();
178 
179  fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
180  fArcButton->SetFillColor(kGreen);
181  fArcButton->Draw();
182 
183  char butUnzoom[256];
184  sprintf(butUnzoom,
185  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->UnZoom()",fTitle);
186  fUnZoomButton = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.14);
187  fUnZoomButton->SetToolTipText("Undo previous zooming");
188  fUnZoomButton->SetFillColor(butcolor);
189  strcpy(UnZoomButName, "UnZoomBut-");
190  strcat(UnZoomButName, title);
191  fUnZoomButton->SetName(UnZoomButName);
192  fUnZoomButton->Draw();
193 
194  fTrigPad->SetEditable(kFALSE);
195  fButtons->SetEditable(kFALSE);
196 
197  fCanvas->cd();
198  fCanvas->Update();
199 
200  gROOT->GetListOfSpecials()->Add(this);
201 
202  TList *li = fTrigPad->GetListOfPrimitives();
203  li->Remove(fUndButton);
204  li->Remove(fAccButton);
205  li->Remove(fCanButton);
206  li->Remove(fEnvButton);
207  li->Remove(fAllButton);
208 }
SetName
graph SetName("Graph")
z0
brick z0
Definition: RecDispMC.C:106
SetTitle
NbBT SetTitle("Number of BT per shower")
EdbDisplayBase::fVz1
Float_t fVz1
Definition: EdbDisplayBase.h:75
EdbDisplayBase::fArcButton
TArc * fArcButton
Definition: EdbDisplayBase.h:106
EdbDisplayBase::fAccButton
TButton * fAccButton
Definition: EdbDisplayBase.h:101
EdbDisplayBase::fUndButton
TButton * fUndButton
Definition: EdbDisplayBase.h:100
EdbDisplayBase::fDrawAllViews
Bool_t fDrawAllViews
Definition: EdbDisplayBase.h:79
EdbDisplayBase::DisplayButtons
virtual void DisplayButtons()
Definition: EdbDisplayBase.cxx:422
EdbDisplayBase::fZoomButton
TButton * fZoomButton
Definition: EdbDisplayBase.h:104
EdbDisplayBase::fUnZoomButton
TButton * fUnZoomButton
Definition: EdbDisplayBase.h:105
EdbDisplayBase::fCanvas
TCanvas * fCanvas
Definition: EdbDisplayBase.h:123
EdbDisplayBase::fAllButton
TButton * fAllButton
Definition: EdbDisplayBase.h:98
EdbDisplayBase::fPickButton
TButton * fPickButton
Definition: EdbDisplayBase.h:103
EdbDisplayBase::fVy0
Float_t fVy0
Definition: EdbDisplayBase.h:75
EdbDisplayBase::fPad
TPad * fPad
Definition: EdbDisplayBase.h:126
EdbDisplayBase::fStyle
Int_t fStyle
Definition: EdbDisplayBase.h:88
EdbDisplayBase::fTrigPad
TPad * fTrigPad
Definition: EdbDisplayBase.h:96
EdbDisplayBase::fCanvasName
char fCanvasName[128]
Definition: EdbDisplayBase.h:117
EdbDisplayBase::fButtons
TPad * fButtons
Definition: EdbDisplayBase.h:97
EdbDisplayBase::fTheta
Float_t fTheta
Definition: EdbDisplayBase.h:80
EdbDisplayBase::fPhi
Float_t fPhi
Definition: EdbDisplayBase.h:81
EdbDisplayBase::fZoomMode
Int_t fZoomMode
Definition: EdbDisplayBase.h:78
EdbDisplayBase::fCanButton
TButton * fCanButton
Definition: EdbDisplayBase.h:102
EdbDisplayBase::fEnvButton
TButton * fEnvButton
Definition: EdbDisplayBase.h:99
EdbDisplayBase::fZooms
Int_t fZooms
Definition: EdbDisplayBase.h:87
EdbDisplayBase::fTitle
char fTitle[128]
Definition: EdbDisplayBase.h:95
EdbDisplayBase::SetStyle
virtual void SetStyle(int Style=0)
Definition: EdbDisplayBase.cxx:263
EdbDisplayBase::fPsi
Float_t fPsi
Definition: EdbDisplayBase.h:82
EdbDisplayBase::fVy1
Float_t fVy1
Definition: EdbDisplayBase.h:75
EdbDisplayBase::fVz0
Float_t fVz0
Definition: EdbDisplayBase.h:75
EdbDisplayBase::fVx0
Float_t fVx0
Definition: EdbDisplayBase.h:75
EdbDisplayBase::fVx1
Float_t fVx1
Definition: EdbDisplayBase.h:75
gEDBDEBUGLEVEL
gEDBDEBUGLEVEL
Definition: energy.C:7
strcpy
strcpy(cmd,"cp Shower.root Shower2.root")
TCanvas
new TCanvas()
db
TOracleServerE * db
Definition: test_oracle.C:8

◆ ~EdbDisplayBase()

EdbDisplayBase::~EdbDisplayBase ( )
211 {
212  //
213  // Default destructor
214  //
215 
216  SafeDelete(fMain);
217  SafeDelete(fView);
218  SafeDelete(fCanvas);
219  SafeDelete(fDetector);
220 }
EdbDisplayBase::fMain
TGMainFrame * fMain
Definition: EdbDisplayBase.h:107
EdbDisplayBase::fDetector
TGeoVolume * fDetector
Definition: EdbDisplayBase.h:119
EdbDisplayBase::fView
Edb3DView * fView
Definition: EdbDisplayBase.h:94

Member Function Documentation

◆ Clear()

virtual void EdbDisplayBase::Clear ( )
inlinevirtual
141 { fPad->Clear("nodelete"); fView=0; }

◆ ClearNewVTX()

void EdbDisplayBase::ClearNewVTX ( )
virtual
1032 {
1033  fCanvasVTX->cd();
1034  fNewVTX->Clear();
1035  fCanvasVTX->Modified(kTRUE);
1036  fCanvasVTX->Update();
1037 }
EdbDisplayBase::fCanvasVTX
TCanvas * fCanvasVTX
Definition: EdbDisplayBase.h:124
EdbDisplayBase::fNewVTX
TText * fNewVTX
Definition: EdbDisplayBase.h:110

◆ ClearPreVTX()

void EdbDisplayBase::ClearPreVTX ( )
virtual
1040 {
1041  fCanvasVTX->cd();
1042  fPreVTX->Clear();
1043  fCanvasVTX->Modified(kTRUE);
1044  fCanvasVTX->Update();
1045 }
EdbDisplayBase::fPreVTX
TText * fPreVTX
Definition: EdbDisplayBase.h:111

◆ CreateCanvasVTX()

void EdbDisplayBase::CreateCanvasVTX ( )
virtual
993 {
994  static char CanvasVTXName[140];
995  strcpy(CanvasVTXName, "VTX-");
996  strcat(CanvasVTXName, fCanvasName);
997  if ((fCanvasVTX = (TCanvas *)(gROOT->GetListOfCanvases()->FindObject(CanvasVTXName))))
998  {
999  fCanvasVTX->Clear();
1000  }
1001  else
1002  {
1003  int xpos = fCanvas->GetWindowTopX()+fCanvas->GetWw();
1004  int ypos = fCanvas->GetWindowTopY();
1005  fCanvasVTX = new TCanvas(CanvasVTXName, "Vertex Data Display",
1006  -xpos, ypos, 640, 350);
1007  fCanvasVTX->ToggleEventStatus();
1008  for (int i=0; i<50; i++) fRemBut[i] = 0;
1009  }
1010  if (fHdrVTX)
1011  {
1012  fHdrVTX->Clear();
1013  fHdrVTX->SetText(0.05, 0.94,
1014  "Vertex ID Mult X Y Z Dist Chi2 Prob");
1015  }
1016  else
1017  {
1018  fHdrVTX = new TText(0.05, 0.94,
1019  "Vertex ID Mult X Y Z Dist Chi2 Prob");
1020  fHdrVTX->ResetBit(kCanDelete);
1021  fHdrVTX->SetTextColor(kBlue);
1022  fHdrVTX->SetTextSize(0.04);
1023  fHdrVTX->SetTextAlign(12);
1024  fHdrVTX->SetTextFont(102);
1025  }
1026  fHdrVTX->Draw();
1027  fCanvasVTX->Modified(kTRUE);
1028  fCanvasVTX->Update();
1029 }
EdbDisplayBase::fHdrVTX
TText * fHdrVTX
Definition: EdbDisplayBase.h:108
EdbDisplayBase::fRemBut
TButton * fRemBut[50]
Definition: EdbDisplayBase.h:116

◆ DisplayButtons()

void EdbDisplayBase::DisplayButtons ( )
virtual
423 {
424 // Create the user interface buttons
425  char ViewTypePadName[140];
426 
427  strcpy(ViewTypePadName, "ViewTypePad-");
428  strcat(ViewTypePadName, fCanvasName);
429  fButtons = new TPad(ViewTypePadName, "View Type Pad",0,0.35,0.15,1);
430  fButtons->Draw();
431  fButtons->SetFillColor(38); // blue shades
432  fButtons->SetBorderSize(2);
433  fButtons->cd();
434 
435  Int_t butcolor = 33; // blue shades
436  Float_t dbutton = 0.05;
437 // Float_t y = 0.96;
438  Float_t y = 1.044;
439  Float_t dy = 0.010;
440  Float_t x0 = 0.05;
441  Float_t x1 = 0.95;
442 
443  TButton *button;
444 
445 // y -= dbutton +dy;
446 
447  y -= dbutton +dy;
448 
449  char but3[256];
450  sprintf(but3,
451  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetView(90,90,90)",fTitle);
452  button = new TButton("Top View",but3,x0,y-dbutton,x1,y);
453  button->SetFillColor(butcolor);
454  button->Draw();
455 
456  y -= dbutton +dy;
457  char but4[256];
458  sprintf(but4,
459  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetView(180,90,90)",fTitle);
460  button = new TButton("Side View",but4,x0,y-dbutton,x1,y);
461  button->SetFillColor(butcolor);
462  button->Draw();
463 
464  y -= dbutton +dy;
465  char but5[256];
466  sprintf(but5,
467  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetView(180,0,90)",fTitle);
468  button = new TButton("Front View",but5,x0,y-dbutton,x1,y);
469  button->SetFillColor(butcolor);
470  button->Draw();
471 
472  if (fStyle/2 == 1)
473  butcolor = 33; // blue shades
474  else
475  butcolor = 38; // blue shades
476 
478  y -= dbutton +dy;
479  char butA[256];
480  sprintf(butA,
481  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SwDrawDet()",fTitle);
482  button=new TButton("Draw Detector",butA,x0,y-dbutton,x1,y);
483  button->SetToolTipText("Toggle drawing detector on/off");
484  button->SetFillColor(38);
485  button->Draw();
486 
487  y -= dbutton +dy;
488  char but6[256];
489  sprintf(but6,
490  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetRotate()",fTitle);
491  button = new TButton("Rotate",but6,x0,y-dbutton,x1,y);
492  button->SetName("Rotate");
493  button->SetToolTipText("Rotate 3-D view");
494  button->SetFillColor(butcolor);
495  button->Draw();
496 
497  y -= dbutton +dy;
498  char but7[256];
499  sprintf(but7,
500  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawViewGL()",fTitle);
501  button = new TButton("OpenGL",but7,x0,y-dbutton,x1,y);
502  button->SetName("OpenGL");
503  button->SetToolTipText("Show 3-D view with OpenGL");
504  button->SetFillColor(butcolor);
505  button->Draw();
506 
507  y -= dbutton +dy;
508  char but8[256];
509  sprintf(but8,
510  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawViewX3D()",fTitle);
511  button = new TButton("X3D",but8,x0,y-dbutton,x1,y);
512  button->SetName("X3D");
513  button->SetToolTipText("Show 3-D view with X3D");
514  button->SetFillColor(butcolor);
515  button->Draw();
516 
517  y -= dbutton +dy;
518  char but9[256];
519  sprintf(but9,
520  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DialogNeighborParameters()",fTitle);
521  button = new TButton("NeighParms",but9,x0,y-dbutton,x1,y);
522  button->SetName("NeighParms");
523  button->SetToolTipText("Set Parameters for Neighborhood");
524  button->SetFillColor(butcolor);
525  button->Draw();
526 
527  y -= dbutton +dy;
528  char but10[256];
529  sprintf(but10,
530  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DialogTrackParameters()",fTitle);
531  button = new TButton("TrackParms",but10,x0,y-dbutton,x1,y);
532  button->SetName("TrackParms");
533  button->SetToolTipText("Set Mometum and Mas for tracks creation and propagation");
534  button->SetFillColor(butcolor);
535  button->Draw();
536 
537  // display logo
538  TDiamond *diamond = new TDiamond(0.05,0.017,0.95,0.21);
539  diamond->SetFillColor(50); // red shades
540  diamond->SetTextAlign(23);
541  diamond->SetTextColor(kYellow);
542  diamond->SetTextSize(0.09);
543  diamond->Draw();
544  diamond->AddText(".");
545  diamond->AddText("ROOT");
546  diamond->AddText("- OPERA -");
547  diamond->AddText("FEDRA");
548  diamond->AddText(".");
549  diamond->SetName("Diamond");
550 }

◆ DistancetoPrimitive()

Int_t EdbDisplayBase::DistancetoPrimitive ( Int_t  px,
Int_t  py 
)
virtual
875 {
876 // Compute distance from point px,py to objects in event
877 
878 
879  if (fPad == fTrigPad) return 9999;
880  if (fPad == fButtons) return 9999;
881 
882 // fPad->SetCursor(kCross);
883 
884  const Int_t kbig = 9999;
885  Int_t dist = kbig;
886  Float_t xmin = fPad->GetX1();
887  Float_t xmax = fPad->GetX2();
888  Float_t dx = 0.002*(xmax - xmin);
889  Float_t x = fPad->AbsPixeltoX(px);
890  if (x < xmin+dx || x > xmax-dx) return dist;
891 /*
892  Float_t ymin = fPad->GetY1();
893  Float_t ymax = fPad->GetY2();
894  Float_t dy = 0.02*(ymax - ymin);
895  Float_t y = fPad->AbsPixeltoX(py);
896  if (y < ymin+dy || y > ymax-dy) return dist;
897 */
898  if (fZoomMode) return 0;
899  else return 7;
900 }
xmin
float xmin
Definition: emthickness.cpp:61
xmax
float xmax
Definition: emthickness.cpp:61

◆ Draw()

void EdbDisplayBase::Draw ( Option_t *  option = "")
virtual
787 {
788 // Display current event
789 
790  if (fDrawAllViews) {
791  DrawAllViews();
792  return;
793  }
794 
795  fPad->cd();
796 
797  DrawView(fTheta, fPhi, fPsi);
798 
799  // Display the event number and title TODO???
800  //fPad->cd();
801  //DrawTitle();
802 // fPad->cd();
803 
804 }
EdbDisplayBase::DrawAllViews
virtual void DrawAllViews()
Definition: EdbDisplayBase.cxx:728
EdbDisplayBase::DrawView
virtual void DrawView(Float_t theta, Float_t phi, Float_t psi=0)
Definition: EdbDisplayBase.cxx:587

◆ DrawAcc()

void EdbDisplayBase::DrawAcc ( )
virtual
1154 {
1155  fTrigPad->cd();
1156  if (fStyle/2 == 1)
1157  fAccButton->SetFillColor(33);
1158  else
1159  fAccButton->SetFillColor(38);
1160  fTrigPad->GetListOfPrimitives()->Add(fAccButton);
1161  fAccButton->SetPad(0.05,0.63,0.95,0.72);
1162  fAccButton->Draw();
1163  fTrigPad->Modified(kTRUE);
1164  fTrigPad->Update();
1165  fTrigPad->Draw();
1166  fPad->cd();
1167 }

◆ DrawAllViews()

void EdbDisplayBase::DrawAllViews ( )
virtual
729 {
730 // Draw front,top,side and 30 deg views
731 
732  fDrawAllViews = kTRUE;
733  fPad->cd();
734  fPad->SetFillColor(15); // gray shades
735  fPad->Clear();
736  fPad->Divide(2,2);
737 
738  // draw 30 deg view
739  fPad->cd(1);
740  DrawView(30, 30, 0);
741  DrawTitle();
742 
743  // draw front view
744  fPad->cd(2);
745  DrawView(0, -90,0);
746  DrawTitle("Front");
747 
748  // draw top view
749  fPad->cd(3);
750  DrawView(90, 90, 90);
751  DrawTitle("Top");
752 
753  // draw side view
754  fPad->cd(4);
755  DrawView(90, 180, 90);
756  DrawTitle("Side");
757 
758  fPad->cd(2);
759 }
EdbDisplayBase::DrawTitle
virtual void DrawTitle(Option_t *option="")
Definition: EdbDisplayBase.cxx:394

◆ DrawCan()

void EdbDisplayBase::DrawCan ( )
virtual
1170 {
1171  fTrigPad->cd();
1172  if (fStyle/2 == 1)
1173  fCanButton->SetFillColor(33);
1174  else
1175  fCanButton->SetFillColor(38);
1176  fTrigPad->GetListOfPrimitives()->Add(fCanButton);
1177  fCanButton->SetPad(0.05,0.74,0.95,0.83);
1178  fCanButton->Draw();
1179  fTrigPad->Modified(kTRUE);
1180  fTrigPad->Update();
1181  fTrigPad->Draw();
1182  fPad->cd();
1183 }

◆ DrawDetector()

void EdbDisplayBase::DrawDetector ( )
virtual
565 {
566  //if(!fDrawDet){return;}
567  if(fDetector){
568  fPad->GetListOfPrimitives()->Add(fDetector);
569  } else {
570  printf("\nError:no Detector!\n");
571  }
572 }

◆ DrawEnv()

void EdbDisplayBase::DrawEnv ( )
virtual
1186 {
1187  fTrigPad->cd();
1188  if (fStyle/2 == 1)
1189  fEnvButton->SetFillColor(33);
1190  else
1191  fEnvButton->SetFillColor(38);
1192  fTrigPad->GetListOfPrimitives()->Add(fEnvButton);
1193  fEnvButton->SetPad(0.05,0.47,0.95,0.56);
1194  fEnvButton->Draw();
1195  fTrigPad->Modified(kTRUE);
1196  fTrigPad->Update();
1197  fTrigPad->Draw();
1198  fPad->cd();
1199 }

◆ DrawNewBut()

void EdbDisplayBase::DrawNewBut ( char *  text)
virtual
1108 {
1109  fCanvasVTX->cd();
1110  if (!fNewBut)
1111  {
1112  char but[256];
1113  sprintf(but,
1114  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
1115  strcat(but,type);
1116  strcat(but,"\")");
1117  fNewBut = new TButton("TR",but,0.01,0.74,0.04,0.78);
1118  fNewBut->SetToolTipText("Show tracks table");
1119  fNewBut->ResetBit(kCanDelete);
1120  fNewBut->SetFillColor(38); // blue shades
1121  fNewBut->SetName("DrawNewVTX");
1122  }
1123  else
1124  {
1125  char but[256];
1126  sprintf(but,
1127  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
1128  strcat(but,type);
1129  strcat(but,"\")");
1130  fNewBut->SetMethod(but);
1131  }
1132  fNewBut->Draw();
1133  fCanvasVTX->Modified(kTRUE);
1134  fCanvasVTX->Update();
1135 }
EdbDisplayBase::fNewBut
TButton * fNewBut
Definition: EdbDisplayBase.h:114
type
Int_t type
Definition: testBGReduction_By_ANN.C:15

◆ DrawNewVTX()

void EdbDisplayBase::DrawNewVTX ( char *  text)
virtual
971 {
972  fCanvasVTX->cd();
973  if (fNewVTX)
974  {
975  fNewVTX->Clear();
976  fNewVTX->SetText(0.05, 0.76, ptitle);
977  }
978  else
979  {
980  fNewVTX = new TText(0.05, 0.76, ptitle);
981  fNewVTX->ResetBit(kCanDelete);
982  fNewVTX->SetTextColor(kBlack);
983  fNewVTX->SetTextSize(0.04);
984  fNewVTX->SetTextAlign(12);
985  fNewVTX->SetTextFont(102);
986  }
987  fNewVTX->Draw();
988  fCanvasVTX->Modified(kTRUE);
989  fCanvasVTX->Update();
990 }

◆ DrawOldBut()

void EdbDisplayBase::DrawOldBut ( char *  text)
virtual
1048 {
1049  fCanvasVTX->cd();
1050  if (!fOldBut)
1051  {
1052  char but[256];
1053  sprintf(but,
1054  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
1055  strcat(but,type);
1056  strcat(but,"\")");
1057  fOldBut = new TButton("TR",but,0.01,0.86,0.04,0.90);
1058  fOldBut->SetToolTipText("Show tracks table");
1059  fOldBut->ResetBit(kCanDelete);
1060  fOldBut->SetFillColor(38); // blue shades
1061  fOldBut->SetName("DrawOldVTX");
1062  }
1063  else
1064  {
1065  char but[256];
1066  sprintf(but,
1067  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
1068  strcat(but,type);
1069  strcat(but,"\")");
1070  fOldBut->SetMethod(but);
1071  }
1072  fOldBut->Draw();
1073  fCanvasVTX->Modified(kTRUE);
1074  fCanvasVTX->Update();
1075 }
EdbDisplayBase::fOldBut
TButton * fOldBut
Definition: EdbDisplayBase.h:113

◆ DrawOldVTX()

void EdbDisplayBase::DrawOldVTX ( char *  text)
virtual
927 {
928  fCanvasVTX->cd();
929  if (fOldVTX)
930  {
931  fOldVTX->Clear();
932  fOldVTX->SetText(0.05, 0.88, ptitle);
933  }
934  else
935  {
936  fOldVTX = new TText(0.05, 0.88, ptitle);
937  fOldVTX->ResetBit(kCanDelete);
938  fOldVTX->SetTextColor(kBlack);
939  fOldVTX->SetTextSize(0.04);
940  fOldVTX->SetTextAlign(12);
941  fOldVTX->SetTextFont(102);
942  }
943  fOldVTX->Draw();
944  fCanvasVTX->Modified(kTRUE);
945  fCanvasVTX->Update();
946 }
EdbDisplayBase::fOldVTX
TText * fOldVTX
Definition: EdbDisplayBase.h:109

◆ DrawPreBut()

void EdbDisplayBase::DrawPreBut ( char *  text)
virtual
1078 {
1079  fCanvasVTX->cd();
1080  if (!fPreBut)
1081  {
1082  char but[256];
1083  sprintf(but,
1084  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
1085  strcat(but,type);
1086  strcat(but,"\")");
1087  fPreBut = new TButton("TR",but,0.01,0.80,0.04,0.84);
1088  fPreBut->SetToolTipText("Show tracks table");
1089  fPreBut->ResetBit(kCanDelete);
1090  fPreBut->SetFillColor(38); // blue shades
1091  fPreBut->SetName("DrawPreVTX");
1092  }
1093  else
1094  {
1095  char but[256];
1096  sprintf(but,
1097  "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
1098  strcat(but,type);
1099  strcat(but,"\")");
1100  fPreBut->SetMethod(but);
1101  }
1102  fPreBut->Draw();
1103  fCanvasVTX->Modified(kTRUE);
1104  fCanvasVTX->Update();
1105 }
EdbDisplayBase::fPreBut
TButton * fPreBut
Definition: EdbDisplayBase.h:115

◆ DrawPreVTX()

void EdbDisplayBase::DrawPreVTX ( char *  text)
virtual
949 {
950  fCanvasVTX->cd();
951  if (fPreVTX)
952  {
953  fPreVTX->Clear();
954  fPreVTX->SetText(0.05, 0.82, ptitle);
955  }
956  else
957  {
958  fPreVTX = new TText(0.05, 0.82, ptitle);
959  fPreVTX->ResetBit(kCanDelete);
960  fPreVTX->SetTextColor(kBlack);
961  fPreVTX->SetTextSize(0.04);
962  fPreVTX->SetTextAlign(12);
963  fPreVTX->SetTextFont(102);
964  }
965  fPreVTX->Draw();
966  fCanvasVTX->Modified(kTRUE);
967  fCanvasVTX->Update();
968 }

◆ DrawTitle()

void EdbDisplayBase::DrawTitle ( Option_t *  option = "")
virtual
395 {
396 // Draw the event title
397 
398  Float_t xmin = fPad->GetX1();
399  Float_t xmax = fPad->GetX2();
400  Float_t ymin = fPad->GetY1();
401  Float_t ymax = fPad->GetY2();
402  Float_t dx = xmax-xmin;
403  Float_t dy = ymax-ymin;
404 
405  if (strlen(option) == 0) {
406  TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
407  title->SetBit(kCanDelete);
408  title->SetFillColor(42); // red shades
409  title->Draw();
410  char ptitle[100];
411  sprintf(ptitle,"OPERA emulsion view");
412  title->AddText(ptitle);
413  } else {
414  TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
415  label->SetBit(kCanDelete);
416  label->SetFillColor(42); // red shades
417  label->Draw();
418  }
419 }
ymin
float ymin
Definition: emthickness.cpp:63
ymax
float ymax
Definition: emthickness.cpp:63

◆ DrawUnd()

void EdbDisplayBase::DrawUnd ( )
virtual
1138 {
1139  fTrigPad->cd();
1140  if (fStyle/2 == 1)
1141  fUndButton->SetFillColor(33);
1142  else
1143  fUndButton->SetFillColor(38);
1144  fTrigPad->GetListOfPrimitives()->Add(fUndButton);
1145  fUndButton->SetPad(0.05,0.85,0.95,0.94);
1146  fUndButton->Draw();
1147  fTrigPad->Modified(kTRUE);
1148  fTrigPad->Update();
1149  fTrigPad->Draw();
1150  fPad->cd();
1151 }

◆ DrawView()

void EdbDisplayBase::DrawView ( Float_t  theta,
Float_t  phi,
Float_t  psi = 0 
)
virtual
588 {
589 // Draw a view of DataSet
590 
591  fPad->SetCursor(kWatch);
592  fPad->SetFillColor(fColorBG);
593 
594 // TList *li = fPad->GetListOfPrimitives();
595 // int np = li->GetSize();
596 // TObject *o = 0;
597 // for (int i=0; i<np; i++)
598 // {
599 // o = li->At(i);
600 // if (o && o->TestBit(kCanDelete)) delete o;
601 // }
602 // li->Clear("nodelete");
603 
604  fPad->Clear("nodelete"); fView=0;
605 
606  if(!fView) {
607  fView = new Edb3DView();
608  fPad->SetView(fView);
609  }
610  if(fPad->GetView()==0) fPad->SetView(fView);
611  if (fPad->GetView() != fView || fView == 0) printf("Error: fView is not defined!\n");
612 
613  fView->SetRange((double)fVx0,(double)fVy0,(double)fVz0,(double)fVx1,(double)fVy1,(double)fVz1);
614 
615  SetView(theta,phi,psi);
616 
617  fZoomX0[0] = -1;
618  fZoomY0[0] = -1;
619  fZoomX1[0] = 1;
620  fZoomY1[0] = 1;
621 
622  Refresh();
623  AppendPad();
624 
625  fPad->Range(fZoomX0[fZooms],fZoomY0[fZooms],fZoomX1[fZooms],fZoomY1[fZooms]);
626  //SetRange(fVx0,fVy0,fVz0,fVx1,fVy1,fVz1);
627  fPad->Modified(kTRUE);
628 }
Edb3DView
Definition: EdbDisplayBase.h:47
EdbDisplayBase::fZoomY0
Double_t fZoomY0[kMAXZOOMS]
Definition: EdbDisplayBase.h:84
EdbDisplayBase::fZoomY1
Double_t fZoomY1[kMAXZOOMS]
Definition: EdbDisplayBase.h:86
EdbDisplayBase::fColorBG
Int_t fColorBG
Definition: EdbDisplayBase.h:93
EdbDisplayBase::fZoomX1
Double_t fZoomX1[kMAXZOOMS]
Definition: EdbDisplayBase.h:85
EdbDisplayBase::Refresh
virtual void Refresh()
Definition: EdbDisplayBase.h:142
EdbDisplayBase::fZoomX0
Double_t fZoomX0[kMAXZOOMS]
Definition: EdbDisplayBase.h:83
EdbDisplayBase::SetView
virtual void SetView(Float_t theta, Float_t phi, Float_t psi=0)
Definition: EdbDisplayBase.cxx:706

◆ DrawViewGL()

void EdbDisplayBase::DrawViewGL ( )
virtual
762 {
763 // Draw current view using OPENGL
764 
765  TPad *pad = (TPad*)fPad->GetPadSave();
766  pad->cd();
767  TView *view = pad->GetView();
768  if (!view) return;
769  pad->GetViewer3D("ogl");
770 }

◆ DrawViewX3D()

void EdbDisplayBase::DrawViewX3D ( )
virtual
774 {
775 // Draw current view using X3D
776 
777  TPad *pad = (TPad*)fPad->GetPadSave();
778  pad->cd();
779  TView *view = pad->GetView();
780  if (!view) return;
781  pad->GetViewer3D("x3d");
782 }

◆ ExecuteEvent()

void EdbDisplayBase::ExecuteEvent ( Int_t  event,
Int_t  px,
Int_t  py 
)
virtual
632 {
633 // Execute action corresponding to the mouse event
634 
635  static Double_t x0, y0, x1, y1;
636 
637  static Int_t pxold, pyold;
638  static Int_t px0, py0;
639  static Int_t linedrawn;
640  Double_t temp;
641 
642 // if (px == 0 && py == 0) { //when called by sliders
643 // if (event == kButton1Up) {
644 // Draw();
645 // }
646 // return;
647 // }
648 // if (!fZoomMode && fPad->GetView()) {
649 // fPad->GetView()->ExecuteRotateView(event, px, py);
650 // return;
651 // }
652 
653  // something to zoom ?
654 
655  if (!fZoomMode && fPad->GetView())
656  {
657  fPad->SetCursor(kPointer);
658  return;
659  }
660 
661  fPad->SetCursor(kCross);
662 
663  switch (event) {
664 
665  case kButton1Down:
666  gVirtualX->SetLineColor(-1);
667  fPad->TAttLine::Modify(); //Change line attributes only if necessary
668  x0 = fPad->AbsPixeltoX(px);
669  y0 = fPad->AbsPixeltoY(py);
670  px0 = px; py0 = py;
671  pxold = px; pyold = py;
672  linedrawn = 0;
673  return;
674 
675  case kButton1Motion:
676  if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
677  pxold = px;
678  pyold = py;
679  linedrawn = 1;
680  gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
681  return;
682 
683  case kButton1Up:
684  fPad->GetCanvas()->FeedbackMode(kFALSE);
685  if (px == px0) return;
686  if (py == py0) return;
687  x1 = fPad->AbsPixeltoX(px);
688  y1 = fPad->AbsPixeltoY(py);
689 
690  if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
691  if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
692  fPad->Range(x0,y0,x1,y1);
693  if (fZooms < kMAXZOOMS-1) {
694  fZooms++;
695  fZoomX0[fZooms] = x0;
696  fZoomY0[fZooms] = y0;
697  fZoomX1[fZooms] = x1;
698  fZoomY1[fZooms] = y1;
699  }
700  fPad->Modified(kTRUE);
701  return;
702  }
703 
704 }
SHOWER_PAR::event
int event
Definition: shower_tr.C:25

◆ GetDrawDet()

Bool_t EdbDisplayBase::GetDrawDet ( ) const
inline
177 { return fDrawDet; }
EdbDisplayBase::fDrawDet
Bool_t fDrawDet
Definition: EdbDisplayBase.h:118

◆ GetObjectInfo()

char * EdbDisplayBase::GetObjectInfo ( int  px,
int  py 
) const
virtual
903 {
904  static char rcoordinates[]="Rotated coordinates";
905  static char coordinates[80];
906  if (!fPad || !fView) return rcoordinates;
907  float nxyz[3] = {fPad->AbsPixeltoX(px), fPad->AbsPixeltoY(py), 0.}, wxyz[3] = {0., 0., 0.};
908  if (fView) fView->NDCtoWC(nxyz, wxyz);
909  if (fView->GetLatitude() == 90.)
910  {
911  if (fView->GetLongitude() == 180.)
912  sprintf(coordinates, "Y = %.1f, Z = %.1f", wxyz[1], wxyz[2]);
913  else if (fView->GetLongitude() == 90.)
914  sprintf(coordinates, "X = %.1f, Z = %.1f", wxyz[0], wxyz[2]);
915  else
916  return rcoordinates;
917  }
918  else if (fView->GetLatitude() == 0.)
919  sprintf(coordinates, "X = %.1f, Y = %.1f", wxyz[0], wxyz[1]);
920  else
921  return rcoordinates;
922  return coordinates;
923 }

◆ Refresh()

virtual void EdbDisplayBase::Refresh ( )
inlinevirtual

Reimplemented in EdbDisplay.

142 {}

◆ Set0()

void EdbDisplayBase::Set0 ( )
virtual

Reimplemented in EdbDisplay.

225 {
226  fVx0=fVy0=fVz0=fVx1=fVy1=fVz1=0;
227  fCanvas = 0;
228  fCanvasVTX = 0;
229  fCanvasTRK = 0;
230  fTrigPad = 0;
231  fButtons = 0;
232  fPad = 0;
233  fAllButton = 0;
234  fEnvButton = 0;
235  fUndButton = 0;
236  fCanButton = 0;
237  fAccButton = 0;
238  fPickButton = 0;
239  fZoomButton = 0;
240  fUnZoomButton = 0;
241  fArcButton = 0;
242  fHdrVTX = 0;
243  fOldVTX = 0;
244  fNewVTX = 0;
245  fPreVTX = 0;
246  fOldBut = 0;
247  fNewBut = 0;
248  fPreBut = 0;
249  fCanvasName[0] = '\0';
250  fTitle[0] = '\0';
251  fVTXTracks = 0;
252  fVTXTRKInfo = 0;
253  fMain = 0;
254  fView = 0;
255  fStyle = 0;
256  fLineWidth = 1;
257  fColorBG = kBlack;
258  fDetector = 0;
259  fDrawDet = 0;
260  for (int i=0; i<50; i++) fRemBut[i] = 0;
261 }
EdbDisplayBase::fVTXTracks
TPaveText * fVTXTracks
Definition: EdbDisplayBase.h:112
EdbDisplayBase::fLineWidth
Width_t fLineWidth
Definition: EdbDisplayBase.h:92
EdbDisplayBase::fCanvasTRK
TCanvas * fCanvasTRK
Definition: EdbDisplayBase.h:125
EdbDisplayBase::fVTXTRKInfo
TPaveText * fVTXTRKInfo
Definition: EdbDisplayBase.h:122

◆ SetColorBG()

virtual void EdbDisplayBase::SetColorBG ( int  color = 1)
inlinevirtual
174 {fColorBG=color;}

◆ SetDetector()

virtual void EdbDisplayBase::SetDetector ( TGeoVolume *  det)
inlinevirtual
179 {fDetector=det;}

◆ SetDrawDet()

void EdbDisplayBase::SetDrawDet ( Bool_t  fflag)
virtual
554 {
555  if(!fDetector) { printf("WARNING: EdbDisplayBase::SetDrawDet: fDetector do not defined!\n"); return; }
556  fDrawDet=fflag;
557  TGeoVolume* vol=(TGeoVolume*)fPad->GetListOfPrimitives()->FindObject(fDetector);
558  vol->SetVisibility(fDrawDet);
559  printf("\nDrawDet is %i\n",vol->IsVisible());
560  fPad->Modified(kTRUE);
561 }
vol
EdbPatternsVolume * vol
Definition: RecDispNU.C:116

◆ SetLineWidth()

virtual void EdbDisplayBase::SetLineWidth ( int  width = 1)
inlinevirtual
173 {fLineWidth=width;}
width
float width
Definition: emthickness.cpp:71

◆ SetPickMode()

void EdbDisplayBase::SetPickMode ( )
virtual
809 {
810  //
811  // Set Pick Mode -- disable zoom
812  //
813  if (fView) fView->SetRotateMode(false);
814 
815  fZoomMode = 0;
816 
817  fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
818  fTrigPad->Modified(kTRUE);
819  fPad->SetCursor(kPointer);
820 }
Edb3DView::SetRotateMode
virtual void SetRotateMode(bool Mode=true)
Definition: EdbDisplayBase.cxx:1367

◆ SetRange()

void EdbDisplayBase::SetRange ( Float_t  x0,
Float_t  x1,
Float_t  y0,
Float_t  y1,
Float_t  z0,
Float_t  z1 
)
virtual
576 {
577 
578  fVx0=x0; fVx1=x1; fVy0=y0; fVy1=y1; fVz0=z0; fVz1=z1;
579 
580  if (!fPad) return;
581  fPad->Modified(kTRUE);
582  //fPad->Clear();
583  //Draw();
584 }

◆ SetRotate()

void EdbDisplayBase::SetRotate ( )
virtual
839 {
840  //
841  // Set 3-D View Rotate Mode
842  //
843 
844  fZoomMode = 0;
845 
846  if (fView) fView->SetRotateMode(true);
847 
848  fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
849  fTrigPad->Modified(kTRUE);
850 }

◆ SetStyle()

void EdbDisplayBase::SetStyle ( int  Style = 0)
virtual
264 {
265  if (Style == 0)
266  {
267  fStyle = Style;
268  fLineWidth = 1;
269  fColorBG=kBlack;
270  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(38);
271  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(38);
272  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(38);
273  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(38);
274  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(38);
275  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(50);
276  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kYellow);
277  fButtons->Draw();
278  fUndButton->SetFillColor(38); // blue shades
279  fAccButton->SetFillColor(38);
280  fCanButton->SetFillColor(38);
281  fEnvButton->SetFillColor(38);
282  fAllButton->SetFillColor(38);
283  fPickButton->SetFillColor(38);
284  fZoomButton->SetFillColor(38);
285  fUnZoomButton->SetFillColor(38);
286  fTrigPad->SetFillColor(22); // brown shades
287  fTrigPad->Draw();
288  fPad->cd();
289  }
290  else if (Style == 1)
291  {
292  fStyle = Style;
293  fLineWidth = 2;
294  fColorBG=kBlack;
295  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(38);
296  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(38);
297  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(38);
298  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(38);
299  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(38);
300  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(50);
301  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kYellow);
302  fButtons->Draw();
303  fUndButton->SetFillColor(38); // blue shades
304  fAccButton->SetFillColor(38);
305  fCanButton->SetFillColor(38);
306  fEnvButton->SetFillColor(38);
307  fAllButton->SetFillColor(38);
308  fPickButton->SetFillColor(38);
309  fZoomButton->SetFillColor(38);
310  fUnZoomButton->SetFillColor(38);
311  fTrigPad->SetFillColor(22); // brown shades
312  fTrigPad->Draw();
313  fPad->cd();
314  }
315  else if (Style == 2)
316  {
317  fStyle = Style;
318  fLineWidth = 1;
319  fColorBG=kWhite;
320  fPad->SetFillColor(18);
321  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(33);
322  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(33);
323  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(33);
324  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(33);
325  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(33);
326  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(kYellow);
327  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kRed);
328  fButtons->Draw();
329  fUndButton->SetFillColor(33); // blue shades
330  fAccButton->SetFillColor(33);
331  fCanButton->SetFillColor(33);
332  fEnvButton->SetFillColor(33);
333  fAllButton->SetFillColor(33);
334  fPickButton->SetFillColor(33);
335  fZoomButton->SetFillColor(33);
336  fUnZoomButton->SetFillColor(33);
337  fTrigPad->SetFillColor(38); // blue shades
338  fTrigPad->Draw();
339  fPad->cd();
340  }
341  else if (Style == 3)
342  {
343  fStyle = Style;
344  fLineWidth = 2;
345  fColorBG = kWhite;
346  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(33);
347  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(33);
348  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(33);
349  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(33);
350  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(33);
351  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(kYellow);
352  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kRed);
353  fButtons->Draw();
354  fUndButton->SetFillColor(33); // blue shades
355  fAccButton->SetFillColor(33);
356  fCanButton->SetFillColor(33);
357  fEnvButton->SetFillColor(33);
358  fAllButton->SetFillColor(33);
359  fPickButton->SetFillColor(33);
360  fZoomButton->SetFillColor(33);
361  fUnZoomButton->SetFillColor(33);
362  fTrigPad->SetFillColor(38); // blue shades
363  fTrigPad->Draw();
364  fPad->cd();
365  }
366  else
367  {
368  fStyle = Style;
369  fLineWidth = 1;
370  fColorBG=kBlack;
371  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(38);
372  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(38);
373  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(38);
374  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(38);
375  ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(38);
376  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(50);
377  ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kYellow);
378  fButtons->Draw();
379  fUndButton->SetFillColor(38); // blue shades
380  fAccButton->SetFillColor(38);
381  fCanButton->SetFillColor(38);
382  fEnvButton->SetFillColor(38);
383  fAllButton->SetFillColor(38);
384  fPickButton->SetFillColor(38);
385  fZoomButton->SetFillColor(38);
386  fUnZoomButton->SetFillColor(38);
387  fTrigPad->SetFillColor(22); // brown shades
388  fTrigPad->Draw();
389  fPad->cd();
390  }
391  fPad->SetFillColor(fColorBG);
392 }

◆ SetView()

void EdbDisplayBase::SetView ( Float_t  theta,
Float_t  phi,
Float_t  psi = 0 
)
virtual
707 {
708  // change viewing angles for current event
709  Log(3,"EdbDisplayBase::SetView", "theta,phi,psi= %f %f %f",theta,phi,psi );
710 
711  if (fView) fView->SetRotateMode(false);
712 
713  fPad->cd();
714  fDrawAllViews = kFALSE;
715  fPhi = phi;
716  fTheta = theta;
717  fPsi = psi;
718  Int_t iret = 0;
719 
720  TView *view = fPad->GetView();
721  if (view) view->SetView(fTheta, fPhi, fPsi, iret);
722  else Draw();
723 
724  fPad->Modified(kTRUE);
725 }
Log
bool Log(int level, const char *location, const char *fmt,...)
Definition: EdbLog.cxx:75
EdbDisplayBase::Draw
virtual void Draw(Option_t *option="")
Definition: EdbDisplayBase.cxx:786

◆ SetZoomMode()

void EdbDisplayBase::SetZoomMode ( )
virtual
824 {
825  //
826  // Set Zoom Mode -- disable pick
827  //
828  if (fView) fView->SetRotateMode(false);
829 
830  fZoomMode = 1;
831 
832  fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
833  fTrigPad->Modified(kTRUE);
834  fPad->SetCursor(kCross);
835 }

◆ SwDrawDet()

virtual void EdbDisplayBase::SwDrawDet ( )
inlinevirtual
176 { SetDrawDet(!fDrawDet); }
EdbDisplayBase::SetDrawDet
virtual void SetDrawDet(Bool_t fflag)
Definition: EdbDisplayBase.cxx:553

◆ UnZoom()

void EdbDisplayBase::UnZoom ( )
virtual
854 {
855  //
856  // Resets ZOOM
857  //
858  if (fZooms <= 0)
859  {
860  fCanvas->Paint();
861  fCanvas->Update();
862  return;
863  }
864  fZooms--;
865  fPad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
866  fPad->Modified();
867  fPad->cd();
868  fPad->Draw();
869  fCanvas->Paint();
870  fCanvas->Update();
871 }

Member Data Documentation

◆ fAccButton

TButton* EdbDisplayBase::fAccButton
protected

◆ fAllButton

TButton* EdbDisplayBase::fAllButton
protected

◆ fArcButton

TArc* EdbDisplayBase::fArcButton
protected

◆ fButtons

TPad* EdbDisplayBase::fButtons
protected

◆ fCanButton

TButton* EdbDisplayBase::fCanButton
protected

◆ fCanvas

TCanvas* EdbDisplayBase::fCanvas

◆ fCanvasName

char EdbDisplayBase::fCanvasName[128]
protected

◆ fCanvasTRK

TCanvas* EdbDisplayBase::fCanvasTRK

◆ fCanvasVTX

TCanvas* EdbDisplayBase::fCanvasVTX

◆ fColorBG

Int_t EdbDisplayBase::fColorBG
protected

◆ fDetector

TGeoVolume* EdbDisplayBase::fDetector
protected

◆ fDrawAllViews

Bool_t EdbDisplayBase::fDrawAllViews
protected

◆ fDrawDet

Bool_t EdbDisplayBase::fDrawDet
protected

◆ fEnvButton

TButton* EdbDisplayBase::fEnvButton
protected

◆ fHdrVTX

TText* EdbDisplayBase::fHdrVTX
protected

◆ fLineWidth

Width_t EdbDisplayBase::fLineWidth
protected

◆ fMain

TGMainFrame* EdbDisplayBase::fMain
protected

◆ fNewBut

TButton* EdbDisplayBase::fNewBut
protected

◆ fNewVTX

TText* EdbDisplayBase::fNewVTX
protected

◆ fOldBut

TButton* EdbDisplayBase::fOldBut
protected

◆ fOldVTX

TText* EdbDisplayBase::fOldVTX
protected

◆ fPad

TPad* EdbDisplayBase::fPad

◆ fPhi

Float_t EdbDisplayBase::fPhi
protected

◆ fPickButton

TButton* EdbDisplayBase::fPickButton
protected

◆ fPreBut

TButton* EdbDisplayBase::fPreBut
protected

◆ fPreVTX

TText* EdbDisplayBase::fPreVTX
protected

◆ fPsi

Float_t EdbDisplayBase::fPsi
protected

◆ fRemBut

TButton* EdbDisplayBase::fRemBut[50]
protected

◆ fStyle

Int_t EdbDisplayBase::fStyle
protected

◆ fTheta

Float_t EdbDisplayBase::fTheta
protected

◆ fTitle

char EdbDisplayBase::fTitle[128]
protected

◆ fTrigPad

TPad* EdbDisplayBase::fTrigPad
protected

◆ fUndButton

TButton* EdbDisplayBase::fUndButton
protected

◆ fUnZoomButton

TButton* EdbDisplayBase::fUnZoomButton
protected

◆ fView

Edb3DView* EdbDisplayBase::fView
protected

◆ fVTXTracks

TPaveText* EdbDisplayBase::fVTXTracks
protected

◆ fVTXTRKInfo

TPaveText* EdbDisplayBase::fVTXTRKInfo

◆ fVx0

Float_t EdbDisplayBase::fVx0
protected

◆ fVx1

Float_t EdbDisplayBase::fVx1
protected

◆ fVy0

Float_t EdbDisplayBase::fVy0
protected

◆ fVy1

Float_t EdbDisplayBase::fVy1
protected

◆ fVz0

Float_t EdbDisplayBase::fVz0
protected

◆ fVz1

Float_t EdbDisplayBase::fVz1
protected

◆ fZoomButton

TButton* EdbDisplayBase::fZoomButton
protected

◆ fZoomMode

Int_t EdbDisplayBase::fZoomMode
protected

◆ fZooms

Int_t EdbDisplayBase::fZooms
protected

◆ fZoomX0

Double_t EdbDisplayBase::fZoomX0[kMAXZOOMS]
protected

◆ fZoomX1

Double_t EdbDisplayBase::fZoomX1[kMAXZOOMS]
protected

◆ fZoomY0

Double_t EdbDisplayBase::fZoomY0[kMAXZOOMS]
protected

◆ fZoomY1

Double_t EdbDisplayBase::fZoomY1[kMAXZOOMS]
protected
The documentation for this class was generated from the following files: