EdbDisplayBase Class Reference

basic class for FEDRA Event Display More...

#include <EdbDisplayBase.h>

Inheritance diagram for EdbDisplayBase:

Collaboration diagram for EdbDisplayBase:

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
	Pointer to the display canvas. More...
TCanvas *	fCanvasTRK
	Pointer to the vertex canvas. More...
TCanvas *	fCanvasVTX
	Pointer to the vertex canvas. More...
TPad *	fPad
	Pointer to the event display main pad. More...
TPaveText *	fVTXTRKInfo
	Vertex - tracks information. More...

Protected Attributes
TButton *	fAccButton
	Button to accept modified vertex. More...
TButton *	fAllButton
	Button to draw all objects. More...
TArc *	fArcButton
	Gren/Red button to show Pick/Zoom mode. More...
TPad *	fButtons
	Pointer to the buttons pad. More...
TButton *	fCanButton
	Button to cancel modified vertex. More...
char	fCanvasName [128]
	Name of main canvas. More...
Int_t	fColorBG
	color for the display BG More...
TGeoVolume *	fDetector
	detector geometry More...
Bool_t	fDrawAllViews
	Flag True if AllViews selected. More...
Bool_t	fDrawDet
	True if drawing detector is on. More...
TButton *	fEnvButton
	Button to draw vertex environment. More...
TText *	fHdrVTX
	Vertex data header. More...
Width_t	fLineWidth
	Line width for tracks and segments. More...
TGMainFrame *	fMain
	Dialog frame. More...
TButton *	fNewBut
	Modified Vertex display button. More...
TText *	fNewVTX
	Modified Vertex data. More...
TButton *	fOldBut
	Old Vertex display button. More...
TText *	fOldVTX
	Old Vertex data. More...
Float_t	fPhi
	Viewing angle phi. More...
TButton *	fPickButton
	Button to activate Pick mode. More...
TButton *	fPreBut
	Previous Vertex display button. More...
TText *	fPreVTX
	Previous Vertex data. More...
Float_t	fPsi
	Viewving angle psi (rotation on display) More...
TButton *	fRemBut [50]
	track removing buttons More...
Int_t	fStyle
	Display style (line width, sizes etc) More...
Float_t	fTheta
	Viewing angle theta. More...
char	fTitle [128]
	EdbDisplay Object Name. More...
TPad *	fTrigPad
	Pointer to the trigger pad. More...
TButton *	fUndButton
	Button to undo vertex modofication. More...
TButton *	fUnZoomButton
	Button to Undo previous Zoom. More...
Edb3DView *	fView
	Main View object. More...
TPaveText *	fVTXTracks
	Vertex tracks information. More...
Float_t	fVx0
Float_t	fVx1
Float_t	fVy0
Float_t	fVy1
Float_t	fVz0
Float_t	fVz1
TButton *	fZoomButton
	Button to activate Zoom mode. More...
Int_t	fZoomMode
	=1 if in zoom mode More...
Int_t	fZooms
	Number of zooms. More...
Double_t	fZoomX0 [kMAXZOOMS]
	Low x range of zoom number i. More...
Double_t	fZoomX1 [kMAXZOOMS]
	High x range of zoom number i. More...
Double_t	fZoomY0 [kMAXZOOMS]
	Low y range of zoom number i. More...
Double_t	fZoomY1 [kMAXZOOMS]
	High y range of zoom number i. More...

Detailed Description

basic class for FEDRA Event Display

Constructor & Destructor Documentation

EdbDisplayBase() [1/2]

EdbDisplayBase::EdbDisplayBase

(

)

Default constructor

{
  Set0();
}

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
	)

{
   char VPadName[140], TPadName[140];
   char ZoomButName[140], PickButName[140], UnZoomButName[140];
   char CanTitle[140];
   char *pres = 0, *ptitle = 0;
 
   Set0();
   fVx0=x0; fVx1=x1; fVy0=y0; fVy1=y1; fVz0=z0; fVz1=z1;
   if(gEDBDEBUGLEVEL>2) printf("create display in limits: \nX = %f : %f   \nY = %f : %f   \nZ = %f : %f\n",
                   x0,x1,y0,y1,z0,z1);
 
   // Set side view by default
   fTheta = 180;
   fPhi   = 90;
   fPsi   = 90;
 
   fDrawAllViews  = kFALSE;
   fZoomMode      = 1;
   fZooms         = 0;
 
   if ((pres = strstr((char*)title, "Presentation"))) SetStyle(1); // presentation style
   else if ((pres = strstr((char*)title, "presentation"))) SetStyle(1);
   strcpy(fTitle, title);
   ptitle = fTitle;
   while (*ptitle) { if (*ptitle == ' ') *ptitle = '_'; ptitle++; }
    this->SetName(&fTitle[0]);
   this->SetTitle("FEDRA Event Display");
   strcpy(fCanvasName, "Canvas-");
   strcat(fCanvasName, title);
   ptitle = fCanvasName;
   while (*ptitle) { if (*ptitle == ' ') *ptitle = '_'; ptitle++; }
   strcpy(CanTitle, "FEDRA Event Display: ");
   strcat(CanTitle, title);
 
   // if Canvas not defined, then run as standalone viewer
 
   if (!Canvas) fCanvas = new TCanvas(fCanvasName, CanTitle, 14, 47, 800, 700);
   else {
     fCanvas = Canvas;
     fCanvas->SetName(fCanvasName);
     fCanvas->SetTitle(CanTitle);
   }
 
   fCanvas->ToggleEventStatus();
 
  // Create main display pad
   strcpy(VPadName, "ViewPad-");
   strcat(VPadName, title);
   fPad = new TPad(VPadName, "FEDRA Event Display",0.15,0.,1.,1.);
   fPad->Draw();
   fPad->Modified(kTRUE);
   fPad->SetFillColor(kBlack);
   fPad->SetBorderSize(2);
 
   // Create view type control pad
   DisplayButtons();
 
   // Create Control pad
   fCanvas->cd();
   Float_t dxtr     = 0.15;
   Float_t dytr     = 0.35;
   strcpy(TPadName, "ControlPad-");
   strcat(TPadName, title);
   fTrigPad = new TPad(TPadName, "Control Pad",0,0,dxtr,dytr);
   fTrigPad->Draw();
   fTrigPad->cd();
 
   if (fStyle/2 == 1) fTrigPad->SetFillColor(38); // blue shades
   else fTrigPad->SetFillColor(22);               // brown shades
 
   fTrigPad->SetBorderSize(2);
 
   Int_t butcolor = 33;              // blue shades
   if (fStyle/2 == 1) butcolor = 33; // blue shades
   else butcolor = 38;               // blue shades
 
   char undov[256];
   sprintf(undov,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->UndoModifiedVTX()",fTitle);
   Float_t db = 0.09;
   fUndButton = new TButton("Undo  VTX",undov,0.05,0.85,0.95,0.85+db);
   fUndButton->SetToolTipText("Undo last vertex modification");
   fUndButton->SetFillColor(butcolor);
   fUndButton->Draw();
 
   char cancelv[256];
   sprintf(cancelv,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->CancelModifiedVTX()",fTitle);
   fCanButton = new TButton("Cancel VTX",cancelv,0.05,0.74,0.95,0.74+db);
   fCanButton->SetToolTipText("Cancel vertex modifications");
   fCanButton->SetFillColor(butcolor);
   fCanButton->Draw();
 
   char acceptv[256];
   sprintf(acceptv,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->AcceptModifiedVTX()",fTitle);
   fAccButton = new TButton("Accept VTX",acceptv,0.05,0.63,0.95,0.63+db);
   fAccButton->SetToolTipText("Accept vertex modifications");
   fAccButton->SetFillColor(butcolor);
   fAccButton->Draw();
 
   char envv[256];
   sprintf(envv,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVertexEnvironment()",fTitle);
   fEnvButton = new TButton("Neighbor",envv,0.05,0.47,0.95,0.47+db);
   fEnvButton->SetToolTipText("Draw vertex neighborhood");
   fEnvButton->SetFillColor(butcolor);
   fEnvButton->Draw();
 
   char allv[256];
   sprintf(allv,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawAllObjects()",fTitle);
   fAllButton = new TButton("AllObjcts",allv,0.05,0.47,0.95,0.47+db);
   fAllButton->SetToolTipText("Draw all objects");
   fAllButton->SetFillColor(butcolor);
   fAllButton->Draw();
 
   char pickmode[256];
   sprintf(pickmode,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetPickMode()",fTitle);
   fPickButton = new TButton("Pick",pickmode,0.05,0.32,0.65,0.32+db);
   fPickButton->SetToolTipText("Set Pickup mode");
   fPickButton->SetFillColor(butcolor);
   strcpy(PickButName, "PickBut-");
   strcat(PickButName, title);
   fPickButton->SetName(PickButName);
   fPickButton->Draw();
 
   char zoommode[256];
   sprintf(zoommode,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetZoomMode()",fTitle);
   fZoomButton = new TButton("Zoom",zoommode,0.05,0.21,0.65,0.21+db);
   fZoomButton->SetToolTipText("Set Zooming mode");
   fZoomButton->SetFillColor(butcolor);
   strcpy(ZoomButName, "ZoomBut-");
   strcat(ZoomButName, title);
   fZoomButton->SetName(ZoomButName);
   fZoomButton->Draw();
 
   fArcButton = new TArc(.8,fZoomButton->GetYlowNDC()+0.5*db,0.33*db);
   fArcButton->SetFillColor(kGreen);
   fArcButton->Draw();
 
   char butUnzoom[256];
   sprintf(butUnzoom,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->UnZoom()",fTitle);
   fUnZoomButton = new TButton("UnZoom",butUnzoom,0.05,0.05,0.95,0.14);
   fUnZoomButton->SetToolTipText("Undo previous zooming");
   fUnZoomButton->SetFillColor(butcolor);
   strcpy(UnZoomButName, "UnZoomBut-");
   strcat(UnZoomButName, title);
   fUnZoomButton->SetName(UnZoomButName);
   fUnZoomButton->Draw();
 
   fTrigPad->SetEditable(kFALSE);
   fButtons->SetEditable(kFALSE);
 
   fCanvas->cd();
   fCanvas->Update();
 
   gROOT->GetListOfSpecials()->Add(this);
 
   TList *li = fTrigPad->GetListOfPrimitives();
   li->Remove(fUndButton);
   li->Remove(fAccButton);
   li->Remove(fCanButton);
   li->Remove(fEnvButton);
   li->Remove(fAllButton);
}

~EdbDisplayBase()

EdbDisplayBase::~EdbDisplayBase

(

)

Default destructor

{
 
  SafeDelete(fMain);
  SafeDelete(fView);
  SafeDelete(fCanvas);
  SafeDelete(fDetector);
}

Member Function Documentation

Clear()

virtual void EdbDisplayBase::Clear ( )

inlinevirtual

{ fPad->Clear("nodelete"); fView=0; }

ClearNewVTX()

void EdbDisplayBase::ClearNewVTX ( )

virtual

{
  fCanvasVTX->cd();
  fNewVTX->Clear();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

ClearPreVTX()

void EdbDisplayBase::ClearPreVTX ( )

virtual

{
  fCanvasVTX->cd();
  fPreVTX->Clear();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

CreateCanvasVTX()

void EdbDisplayBase::CreateCanvasVTX ( )

virtual

{
  static char CanvasVTXName[140];
  strcpy(CanvasVTXName, "VTX-");
  strcat(CanvasVTXName, fCanvasName);
  if ((fCanvasVTX = (TCanvas *)(gROOT->GetListOfCanvases()->FindObject(CanvasVTXName))))
  {
    fCanvasVTX->Clear();
  }
  else
  {
    int xpos = fCanvas->GetWindowTopX()+fCanvas->GetWw();
    int ypos = fCanvas->GetWindowTopY();
    fCanvasVTX = new TCanvas(CanvasVTXName, "Vertex Data Display",
                 -xpos, ypos, 640, 350);
    fCanvasVTX->ToggleEventStatus();
    for (int i=0; i<50; i++) fRemBut[i] = 0;
  }
  if (fHdrVTX)
  {
    fHdrVTX->Clear();
    fHdrVTX->SetText(0.05, 0.94,
    "Vertex  ID    Mult  X          Y          Z          Dist   Chi2     Prob");
  }
  else
  {
    fHdrVTX = new TText(0.05, 0.94,
    "Vertex  ID    Mult  X          Y          Z          Dist   Chi2     Prob");
    fHdrVTX->ResetBit(kCanDelete);
    fHdrVTX->SetTextColor(kBlue);
    fHdrVTX->SetTextSize(0.04);
    fHdrVTX->SetTextAlign(12);
    fHdrVTX->SetTextFont(102);
  }
  fHdrVTX->Draw();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

DisplayButtons()

void EdbDisplayBase::DisplayButtons ( )

virtual

Create the user interface buttons

{
   char ViewTypePadName[140];
 
   strcpy(ViewTypePadName, "ViewTypePad-");
   strcat(ViewTypePadName, fCanvasName);
   fButtons = new TPad(ViewTypePadName, "View Type Pad",0,0.35,0.15,1);
   fButtons->Draw();
   fButtons->SetFillColor(38); // blue shades
   fButtons->SetBorderSize(2);
   fButtons->cd();
 
   Int_t butcolor = 33; // blue shades
   Float_t dbutton = 0.05;
//   Float_t y  = 0.96;
   Float_t y  = 1.044;
   Float_t dy = 0.010;
   Float_t x0 = 0.05;
   Float_t x1 = 0.95;
 
   TButton *button;
 
//   y -= dbutton +dy;
 
   y -= dbutton +dy;
 
   char but3[256];
   sprintf(but3,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetView(90,90,90)",fTitle);
   button = new TButton("Top View",but3,x0,y-dbutton,x1,y);
   button->SetFillColor(butcolor);
   button->Draw();
 
   y -= dbutton +dy;
   char but4[256];
   sprintf(but4,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetView(180,90,90)",fTitle);
   button = new TButton("Side View",but4,x0,y-dbutton,x1,y);
   button->SetFillColor(butcolor);
   button->Draw();
 
   y -= dbutton +dy;
   char but5[256];
   sprintf(but5,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetView(180,0,90)",fTitle);
   button = new TButton("Front View",but5,x0,y-dbutton,x1,y);
   button->SetFillColor(butcolor);
   button->Draw();
 
   if (fStyle/2 == 1)
    butcolor = 33; // blue shades
   else
    butcolor = 38; // blue shades
 
   y -= dbutton +dy;
   char butA[256];
   sprintf(butA,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SwDrawDet()",fTitle);
   button=new TButton("Draw Detector",butA,x0,y-dbutton,x1,y);
   button->SetToolTipText("Toggle drawing detector on/off");
   button->SetFillColor(38);
   button->Draw();
 
   y -= dbutton +dy;
   char but6[256];
   sprintf(but6,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->SetRotate()",fTitle);
   button = new TButton("Rotate",but6,x0,y-dbutton,x1,y);
   button->SetName("Rotate");
   button->SetToolTipText("Rotate 3-D view");
   button->SetFillColor(butcolor);
   button->Draw();
 
   y -= dbutton +dy;
   char but7[256];
   sprintf(but7,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawViewGL()",fTitle);
   button = new TButton("OpenGL",but7,x0,y-dbutton,x1,y);
   button->SetName("OpenGL");
   button->SetToolTipText("Show 3-D view with OpenGL");
   button->SetFillColor(butcolor);
   button->Draw();
 
   y -= dbutton +dy;
   char but8[256];
   sprintf(but8,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawViewX3D()",fTitle);
   button = new TButton("X3D",but8,x0,y-dbutton,x1,y);
   button->SetName("X3D");
   button->SetToolTipText("Show 3-D view with X3D");
   button->SetFillColor(butcolor);
   button->Draw();
 
   y -= dbutton +dy;
   char but9[256];
   sprintf(but9,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DialogNeighborParameters()",fTitle);
   button = new TButton("NeighParms",but9,x0,y-dbutton,x1,y);
   button->SetName("NeighParms");
   button->SetToolTipText("Set Parameters for Neighborhood");
   button->SetFillColor(butcolor);
   button->Draw();
 
   y -= dbutton +dy;
   char but10[256];
   sprintf(but10,
   "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DialogTrackParameters()",fTitle);
   button = new TButton("TrackParms",but10,x0,y-dbutton,x1,y);
   button->SetName("TrackParms");
   button->SetToolTipText("Set Mometum and Mas for tracks creation and propagation");
   button->SetFillColor(butcolor);
   button->Draw();
 
   // display logo
   TDiamond *diamond = new TDiamond(0.05,0.017,0.95,0.21);
   diamond->SetFillColor(50); // red shades
   diamond->SetTextAlign(23);
   diamond->SetTextColor(kYellow);
   diamond->SetTextSize(0.09);
   diamond->Draw();
   diamond->AddText(".");
   diamond->AddText("ROOT");
   diamond->AddText("- OPERA -");
   diamond->AddText("FEDRA");
   diamond->AddText(".");
   diamond->SetName("Diamond");
}

DistancetoPrimitive()

Int_t EdbDisplayBase::DistancetoPrimitive ( Int_t  px, Int_t  py  )

virtual

Compute distance from point px,py to objects in event

{
 
 
   if (fPad == fTrigPad) return 9999;
   if (fPad == fButtons) return 9999;
 
//   fPad->SetCursor(kCross);
 
   const Int_t kbig = 9999;
   Int_t dist   = kbig;
   Float_t xmin = fPad->GetX1();
   Float_t xmax = fPad->GetX2();
   Float_t dx   = 0.002*(xmax - xmin);
   Float_t x    = fPad->AbsPixeltoX(px);
   if (x < xmin+dx || x > xmax-dx) return dist;
/*
   Float_t ymin = fPad->GetY1();
   Float_t ymax = fPad->GetY2();
   Float_t dy   = 0.02*(ymax - ymin);
   Float_t y    = fPad->AbsPixeltoX(py);
   if (y < ymin+dy || y > ymax-dy) return dist;
*/
   if (fZoomMode) return 0;
   else           return 7;
}

Draw()

void EdbDisplayBase::Draw ( Option_t *  option = "" )

virtual

Display current event

{
 
   if (fDrawAllViews) {
      DrawAllViews();
      return;
   }
 
   fPad->cd();
 
   DrawView(fTheta, fPhi, fPsi);
 
   // Display the event number and title   TODO???
   //fPad->cd();
   //DrawTitle();
//   fPad->cd();
 
}

DrawAcc()

void EdbDisplayBase::DrawAcc ( )

virtual

{
    fTrigPad->cd();
    if (fStyle/2 == 1)
    fAccButton->SetFillColor(33);
    else
    fAccButton->SetFillColor(38);
    fTrigPad->GetListOfPrimitives()->Add(fAccButton);
    fAccButton->SetPad(0.05,0.63,0.95,0.72);
    fAccButton->Draw();
    fTrigPad->Modified(kTRUE);
    fTrigPad->Update();
    fTrigPad->Draw();
    fPad->cd();
}

DrawAllViews()

void EdbDisplayBase::DrawAllViews ( )

virtual

Draw front,top,side and 30 deg views

{
 
   fDrawAllViews = kTRUE;
   fPad->cd();
   fPad->SetFillColor(15);  // gray shades
   fPad->Clear();
   fPad->Divide(2,2);
 
   // draw 30 deg view
   fPad->cd(1);
   DrawView(30, 30, 0);
   DrawTitle();
 
   // draw front view
   fPad->cd(2);
   DrawView(0, -90,0);
   DrawTitle("Front");
 
   // draw top view
   fPad->cd(3);
   DrawView(90, 90, 90);
   DrawTitle("Top");
 
   // draw side view
   fPad->cd(4);
   DrawView(90, 180, 90);
   DrawTitle("Side");
 
   fPad->cd(2);
}

DrawCan()

void EdbDisplayBase::DrawCan ( )

virtual

{
    fTrigPad->cd();
    if (fStyle/2 == 1)
    fCanButton->SetFillColor(33);
    else
    fCanButton->SetFillColor(38);
    fTrigPad->GetListOfPrimitives()->Add(fCanButton);
    fCanButton->SetPad(0.05,0.74,0.95,0.83);
    fCanButton->Draw();
    fTrigPad->Modified(kTRUE);
    fTrigPad->Update();
    fTrigPad->Draw();
    fPad->cd();
}

DrawDetector()

void EdbDisplayBase::DrawDetector ( )

virtual

{
  //if(!fDrawDet){return;}
  if(fDetector){
      fPad->GetListOfPrimitives()->Add(fDetector);
  } else {
    printf("\nError:no Detector!\n");
  }
}

DrawEnv()

void EdbDisplayBase::DrawEnv ( )

virtual

{
    fTrigPad->cd();
    if (fStyle/2 == 1)
    fEnvButton->SetFillColor(33);
    else
    fEnvButton->SetFillColor(38);
    fTrigPad->GetListOfPrimitives()->Add(fEnvButton);
    fEnvButton->SetPad(0.05,0.47,0.95,0.56);
    fEnvButton->Draw();
    fTrigPad->Modified(kTRUE);
    fTrigPad->Update();
    fTrigPad->Draw();
    fPad->cd();
}

DrawNewBut()

void EdbDisplayBase::DrawNewBut ( char *  text )

virtual

{
  fCanvasVTX->cd();
  if (!fNewBut)
  {
    char but[256];
    sprintf(but,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
    strcat(but,type);
    strcat(but,"\")");
    fNewBut = new TButton("TR",but,0.01,0.74,0.04,0.78);
    fNewBut->SetToolTipText("Show tracks table");
    fNewBut->ResetBit(kCanDelete);
    fNewBut->SetFillColor(38); // blue shades
    fNewBut->SetName("DrawNewVTX");
  }
  else
  {
    char but[256];
    sprintf(but,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
    strcat(but,type);
    strcat(but,"\")");
    fNewBut->SetMethod(but);
  }
  fNewBut->Draw();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

DrawNewVTX()

void EdbDisplayBase::DrawNewVTX ( char *  text )

virtual

{
  fCanvasVTX->cd();
  if (fNewVTX)
  {
    fNewVTX->Clear();
    fNewVTX->SetText(0.05, 0.76, ptitle);
  }
  else
  {
    fNewVTX = new TText(0.05, 0.76, ptitle);
    fNewVTX->ResetBit(kCanDelete);
    fNewVTX->SetTextColor(kBlack);
    fNewVTX->SetTextSize(0.04);
    fNewVTX->SetTextAlign(12);
    fNewVTX->SetTextFont(102);
  }
  fNewVTX->Draw();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

DrawOldBut()

void EdbDisplayBase::DrawOldBut ( char *  text )

virtual

{
  fCanvasVTX->cd();
  if (!fOldBut)
  {
    char but[256];
    sprintf(but,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
    strcat(but,type);
    strcat(but,"\")");
    fOldBut = new TButton("TR",but,0.01,0.86,0.04,0.90);
    fOldBut->SetToolTipText("Show tracks table");
    fOldBut->ResetBit(kCanDelete);
    fOldBut->SetFillColor(38); // blue shades
    fOldBut->SetName("DrawOldVTX");
  }
  else
  {
    char but[256];
    sprintf(but,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
    strcat(but,type);
    strcat(but,"\")");
    fOldBut->SetMethod(but);
  }
  fOldBut->Draw();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

DrawOldVTX()

void EdbDisplayBase::DrawOldVTX ( char *  text )

virtual

{
  fCanvasVTX->cd();
  if (fOldVTX)
  {
    fOldVTX->Clear();
    fOldVTX->SetText(0.05, 0.88, ptitle);
  }
  else
  {
    fOldVTX = new TText(0.05, 0.88, ptitle);
    fOldVTX->ResetBit(kCanDelete);
    fOldVTX->SetTextColor(kBlack);
    fOldVTX->SetTextSize(0.04);
    fOldVTX->SetTextAlign(12);
    fOldVTX->SetTextFont(102);
  }
  fOldVTX->Draw();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

DrawPreBut()

void EdbDisplayBase::DrawPreBut ( char *  text )

virtual

{
  fCanvasVTX->cd();
  if (!fPreBut)
  {
    char but[256];
    sprintf(but,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
    strcat(but,type);
    strcat(but,"\")");
    fPreBut = new TButton("TR",but,0.01,0.80,0.04,0.84);
    fPreBut->SetToolTipText("Show tracks table");
    fPreBut->ResetBit(kCanDelete);
    fPreBut->SetFillColor(38); // blue shades
    fPreBut->SetName("DrawPreVTX");
  }
  else
  {
    char but[256];
    sprintf(but,
    "((EdbDisplay*)(gROOT->GetListOfSpecials()->FindObject(\"%s\")))->DrawVTXTracks(\"",fTitle);
    strcat(but,type);
    strcat(but,"\")");
    fPreBut->SetMethod(but);
  }
  fPreBut->Draw();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

DrawPreVTX()

void EdbDisplayBase::DrawPreVTX ( char *  text )

virtual

{
  fCanvasVTX->cd();
  if (fPreVTX)
  {
    fPreVTX->Clear();
    fPreVTX->SetText(0.05, 0.82, ptitle);
  }
  else
  {
    fPreVTX = new TText(0.05, 0.82, ptitle);
    fPreVTX->ResetBit(kCanDelete);
    fPreVTX->SetTextColor(kBlack);
    fPreVTX->SetTextSize(0.04);
    fPreVTX->SetTextAlign(12);
    fPreVTX->SetTextFont(102);
  }
  fPreVTX->Draw();
  fCanvasVTX->Modified(kTRUE);
  fCanvasVTX->Update();
}

DrawTitle()

void EdbDisplayBase::DrawTitle ( Option_t *  option = "" )

virtual

Draw the event title

{
 
   Float_t xmin = fPad->GetX1();
   Float_t xmax = fPad->GetX2();
   Float_t ymin = fPad->GetY1();
   Float_t ymax = fPad->GetY2();
   Float_t dx   = xmax-xmin;
   Float_t dy   = ymax-ymin;
 
   if (strlen(option) == 0) {
      TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
      title->SetBit(kCanDelete);
      title->SetFillColor(42); // red shades
      title->Draw();
      char ptitle[100];
      sprintf(ptitle,"OPERA emulsion view");
      title->AddText(ptitle);
   } else {
      TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
      label->SetBit(kCanDelete);
      label->SetFillColor(42); // red shades
      label->Draw();
   }
}

DrawUnd()

void EdbDisplayBase::DrawUnd ( )

virtual

{
    fTrigPad->cd();
    if (fStyle/2 == 1)
    fUndButton->SetFillColor(33);
    else
    fUndButton->SetFillColor(38);
    fTrigPad->GetListOfPrimitives()->Add(fUndButton);
    fUndButton->SetPad(0.05,0.85,0.95,0.94);
    fUndButton->Draw();
    fTrigPad->Modified(kTRUE);
    fTrigPad->Update();
    fTrigPad->Draw();
    fPad->cd();
}

DrawView()

void EdbDisplayBase::DrawView ( Float_t  theta, Float_t  phi, Float_t  psi = 0  )

virtual

Draw a view of DataSet

{
 
   fPad->SetCursor(kWatch);
   fPad->SetFillColor(fColorBG);
 
//   TList *li = fPad->GetListOfPrimitives();
//   int np = li->GetSize();
//   TObject *o = 0;
//   for (int i=0; i<np; i++)
//   {
//    o = li->At(i);
//    if (o && o->TestBit(kCanDelete)) delete o;
//   }
//   li->Clear("nodelete");
 
   fPad->Clear("nodelete"); fView=0;
 
   if(!fView) { 
     fView = new Edb3DView(); 
     fPad->SetView(fView);
   }
   if(fPad->GetView()==0) fPad->SetView(fView);
   if (fPad->GetView() != fView || fView == 0) printf("Error: fView is not defined!\n");
 
   fView->SetRange((double)fVx0,(double)fVy0,(double)fVz0,(double)fVx1,(double)fVy1,(double)fVz1);
   
   SetView(theta,phi,psi);
 
   fZoomX0[0] = -1;
   fZoomY0[0] = -1;
   fZoomX1[0] =  1;
   fZoomY1[0] =  1;
 
   Refresh();
   AppendPad();
 
   fPad->Range(fZoomX0[fZooms],fZoomY0[fZooms],fZoomX1[fZooms],fZoomY1[fZooms]);   
   //SetRange(fVx0,fVy0,fVz0,fVx1,fVy1,fVz1);
   fPad->Modified(kTRUE);
}

DrawViewGL()

void EdbDisplayBase::DrawViewGL ( )

virtual

Draw current view using OPENGL

{
 
  TPad *pad = (TPad*)fPad->GetPadSave();
  pad->cd();
  TView *view = pad->GetView();
  if (!view) return;
  pad->GetViewer3D("ogl");
}

DrawViewX3D()

void EdbDisplayBase::DrawViewX3D ( )

virtual

Draw current view using X3D

{
 
   TPad *pad = (TPad*)fPad->GetPadSave();
   pad->cd();
   TView *view = pad->GetView();
   if (!view) return;
   pad->GetViewer3D("x3d");
}

ExecuteEvent()

void EdbDisplayBase::ExecuteEvent ( Int_t  event, Int_t  px, Int_t  py  )

virtual

Execute action corresponding to the mouse event

{
 
   static Double_t x0, y0, x1, y1;
 
   static Int_t pxold, pyold;
   static Int_t px0, py0;
   static Int_t linedrawn;
   Double_t temp;
 
//   if (px == 0 && py == 0) { //when called by sliders
//      if (event == kButton1Up) {
//         Draw();
//      }
//      return;
//   }
//   if (!fZoomMode && fPad->GetView()) {
//      fPad->GetView()->ExecuteRotateView(event, px, py);
//      return;
//   }
 
   // something to zoom ?
 
   if (!fZoomMode && fPad->GetView())
   {
    fPad->SetCursor(kPointer);
    return;
   }
 
   fPad->SetCursor(kCross);
 
   switch (event) {
 
   case kButton1Down:
      gVirtualX->SetLineColor(-1);
      fPad->TAttLine::Modify();  //Change line attributes only if necessary
      x0 = fPad->AbsPixeltoX(px);
      y0 = fPad->AbsPixeltoY(py);
      px0   = px; py0   = py;
      pxold = px; pyold = py;
      linedrawn = 0;
      return;
 
   case kButton1Motion:
      if (linedrawn) gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
      pxold = px;
      pyold = py;
      linedrawn = 1;
      gVirtualX->DrawBox(px0, py0, pxold, pyold, TVirtualX::kHollow);
      return;
 
   case kButton1Up:
      fPad->GetCanvas()->FeedbackMode(kFALSE);
      if (px == px0) return;
      if (py == py0) return;
      x1 = fPad->AbsPixeltoX(px);
      y1 = fPad->AbsPixeltoY(py);
 
      if (x1 < x0) {temp = x0; x0 = x1; x1 = temp;}
      if (y1 < y0) {temp = y0; y0 = y1; y1 = temp;}
      fPad->Range(x0,y0,x1,y1);
      if (fZooms < kMAXZOOMS-1) {
         fZooms++;
         fZoomX0[fZooms] = x0;
         fZoomY0[fZooms] = y0;
         fZoomX1[fZooms] = x1;
         fZoomY1[fZooms] = y1;
      }
      fPad->Modified(kTRUE);
      return;
   }
 
}

GetDrawDet()

Bool_t EdbDisplayBase::GetDrawDet ( ) const

inline

{ return fDrawDet; }

GetObjectInfo()

char * EdbDisplayBase::GetObjectInfo ( int  px, int  py  ) const

virtual

{
    static char rcoordinates[]="Rotated coordinates";
    static char coordinates[80];
    if (!fPad || !fView) return rcoordinates;
    float nxyz[3] = {fPad->AbsPixeltoX(px), fPad->AbsPixeltoY(py), 0.}, wxyz[3] = {0., 0., 0.};
    if (fView) fView->NDCtoWC(nxyz, wxyz);
    if (fView->GetLatitude() == 90.)
    {
    if (fView->GetLongitude() == 180.)
        sprintf(coordinates, "Y = %.1f, Z = %.1f", wxyz[1], wxyz[2]);
    else if (fView->GetLongitude() == 90.)
        sprintf(coordinates, "X = %.1f, Z = %.1f", wxyz[0], wxyz[2]);
    else
        return rcoordinates;
    }
    else if (fView->GetLatitude() == 0.)
    sprintf(coordinates, "X = %.1f, Y = %.1f", wxyz[0], wxyz[1]);
    else
    return rcoordinates;
    return coordinates;
}

Refresh()

virtual void EdbDisplayBase::Refresh ( )

inlinevirtual

Reimplemented in EdbDisplay.

{}

Set0()

void EdbDisplayBase::Set0 ( )

virtual

Reimplemented in EdbDisplay.

{
  fVx0=fVy0=fVz0=fVx1=fVy1=fVz1=0;
  fCanvas = 0;
  fCanvasVTX = 0;
  fCanvasTRK = 0;
  fTrigPad = 0;
  fButtons = 0;
  fPad = 0;
  fAllButton = 0;
  fEnvButton = 0;
  fUndButton = 0;
  fCanButton = 0;
  fAccButton = 0;
  fPickButton = 0;
  fZoomButton = 0;
  fUnZoomButton = 0;
  fArcButton = 0;
  fHdrVTX = 0;
  fOldVTX = 0;
  fNewVTX = 0;
  fPreVTX = 0;
  fOldBut = 0;
  fNewBut = 0;
  fPreBut = 0;
  fCanvasName[0] = '\0';
  fTitle[0] = '\0';
  fVTXTracks = 0;
  fVTXTRKInfo = 0;
  fMain      = 0;
  fView      = 0;
  fStyle     = 0;
  fLineWidth = 1;
  fColorBG   = kBlack;
  fDetector  = 0;
  fDrawDet = 0;
  for (int i=0; i<50; i++) fRemBut[i] = 0;
}

SetColorBG()

virtual void EdbDisplayBase::SetColorBG ( int  color = 1 )

inlinevirtual

{fColorBG=color;}

SetDetector()

virtual void EdbDisplayBase::SetDetector ( TGeoVolume *  det )

inlinevirtual

{fDetector=det;}

SetDrawDet()

void EdbDisplayBase::SetDrawDet ( Bool_t  fflag )

virtual

{
  if(!fDetector) { printf("WARNING: EdbDisplayBase::SetDrawDet: fDetector do not defined!\n"); return; }
  fDrawDet=fflag;
  TGeoVolume* vol=(TGeoVolume*)fPad->GetListOfPrimitives()->FindObject(fDetector);
  vol->SetVisibility(fDrawDet);
  printf("\nDrawDet is %i\n",vol->IsVisible());
  fPad->Modified(kTRUE);
}

SetLineWidth()

virtual void EdbDisplayBase::SetLineWidth ( int  width = 1 )

inlinevirtual

{fLineWidth=width;}

SetPickMode()

void EdbDisplayBase::SetPickMode ( )

virtual

Set Pick Mode – disable zoom

{
   if (fView) fView->SetRotateMode(false);
 
   fZoomMode = 0;
 
   fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
   fTrigPad->Modified(kTRUE);
   fPad->SetCursor(kPointer);
}

SetRange()

void EdbDisplayBase::SetRange ( Float_t  x0, Float_t  x1, Float_t  y0, Float_t  y1, Float_t  z0, Float_t  z1  )

virtual

{
   
   fVx0=x0; fVx1=x1; fVy0=y0; fVy1=y1; fVz0=z0; fVz1=z1;
 
   if (!fPad) return;
   fPad->Modified(kTRUE);
   //fPad->Clear();
   //Draw();
}

SetRotate()

void EdbDisplayBase::SetRotate ( )

virtual

Set 3-D View Rotate Mode

{
  
   fZoomMode = 0;
  
   if (fView) fView->SetRotateMode(true);
 
   fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
   fTrigPad->Modified(kTRUE);
}

SetStyle()

void EdbDisplayBase::SetStyle ( int  Style = 0 )

virtual

{
    if (Style == 0)
    {
    fStyle = Style;
    fLineWidth = 1;
    fColorBG=kBlack;
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(38);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(50);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kYellow);
    fButtons->Draw();
    fUndButton->SetFillColor(38); // blue shades
    fAccButton->SetFillColor(38);
    fCanButton->SetFillColor(38);
    fEnvButton->SetFillColor(38);
    fAllButton->SetFillColor(38);
    fPickButton->SetFillColor(38);
    fZoomButton->SetFillColor(38);
    fUnZoomButton->SetFillColor(38);
    fTrigPad->SetFillColor(22); // brown shades
    fTrigPad->Draw();
    fPad->cd();
    }
    else if (Style == 1)
    {
    fStyle = Style;
    fLineWidth = 2;
    fColorBG=kBlack;
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(38);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(50);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kYellow);
    fButtons->Draw();
    fUndButton->SetFillColor(38); // blue shades
    fAccButton->SetFillColor(38);
    fCanButton->SetFillColor(38);
    fEnvButton->SetFillColor(38);
    fAllButton->SetFillColor(38);
    fPickButton->SetFillColor(38);
    fZoomButton->SetFillColor(38);
    fUnZoomButton->SetFillColor(38);
    fTrigPad->SetFillColor(22); // brown shades
    fTrigPad->Draw();
    fPad->cd();
    }
    else if (Style == 2)
    {
    fStyle = Style;
    fLineWidth = 1;
    fColorBG=kWhite;
    fPad->SetFillColor(18);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(33);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(kYellow);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kRed);
    fButtons->Draw();
    fUndButton->SetFillColor(33); // blue shades
    fAccButton->SetFillColor(33);
    fCanButton->SetFillColor(33);
    fEnvButton->SetFillColor(33);
    fAllButton->SetFillColor(33);
    fPickButton->SetFillColor(33);
    fZoomButton->SetFillColor(33);
    fUnZoomButton->SetFillColor(33);
    fTrigPad->SetFillColor(38); // blue shades
    fTrigPad->Draw();
    fPad->cd();
    }
    else if (Style == 3)
    {
    fStyle = Style;
    fLineWidth = 2;
    fColorBG = kWhite;
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(33);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(33);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(kYellow);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kRed);
    fButtons->Draw();
    fUndButton->SetFillColor(33); // blue shades
    fAccButton->SetFillColor(33);
    fCanButton->SetFillColor(33);
    fEnvButton->SetFillColor(33);
    fAllButton->SetFillColor(33);
    fPickButton->SetFillColor(33);
    fZoomButton->SetFillColor(33);
    fUnZoomButton->SetFillColor(33);
    fTrigPad->SetFillColor(38); // blue shades
    fTrigPad->Draw();
    fPad->cd();
    }
    else
    {
    fStyle = Style;
    fLineWidth = 1;
    fColorBG=kBlack;
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("Rotate")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("OpenGL")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("X3D")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("NeighParms")))->SetFillColor(38);
    ((TButton *)(fButtons->GetListOfPrimitives()->FindObject("TrackParms")))->SetFillColor(38);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetFillColor(50);
    ((TDiamond *)(fButtons->GetListOfPrimitives()->FindObject("Diamond")))->SetTextColor(kYellow);
    fButtons->Draw();
    fUndButton->SetFillColor(38); // blue shades
    fAccButton->SetFillColor(38);
    fCanButton->SetFillColor(38);
    fEnvButton->SetFillColor(38);
    fAllButton->SetFillColor(38);
    fPickButton->SetFillColor(38);
    fZoomButton->SetFillColor(38);
    fUnZoomButton->SetFillColor(38);
    fTrigPad->SetFillColor(22); // brown shades
    fTrigPad->Draw();
    fPad->cd();
    }
    fPad->SetFillColor(fColorBG);
}

SetView()

void EdbDisplayBase::SetView ( Float_t  theta, Float_t  phi, Float_t  psi = 0  )

virtual

change viewing angles for current event

{
  Log(3,"EdbDisplayBase::SetView", "theta,phi,psi= %f %f %f",theta,phi,psi );
 
   if (fView) fView->SetRotateMode(false);
 
   fPad->cd();
   fDrawAllViews = kFALSE;
   fPhi   = phi;
   fTheta = theta;
   fPsi   = psi;
   Int_t iret = 0;
 
   TView *view = fPad->GetView();
   if (view) view->SetView(fTheta, fPhi, fPsi, iret);
   else      Draw();
 
   fPad->Modified(kTRUE);
}

SetZoomMode()

void EdbDisplayBase::SetZoomMode ( )

virtual

Set Zoom Mode – disable pick

{
   if (fView) fView->SetRotateMode(false);
 
   fZoomMode = 1;
 
   fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
   fTrigPad->Modified(kTRUE);
   fPad->SetCursor(kCross);
}

SwDrawDet()

virtual void EdbDisplayBase::SwDrawDet ( )

inlinevirtual

{ SetDrawDet(!fDrawDet); }

UnZoom()

void EdbDisplayBase::UnZoom ( )

virtual

Resets ZOOM

{
  if (fZooms <= 0)
  {
    fCanvas->Paint();
    fCanvas->Update();
    return;
  }
  fZooms--;
  fPad->Range(fZoomX0[fZooms],fZoomY0[fZooms], fZoomX1[fZooms],fZoomY1[fZooms]);
  fPad->Modified();
  fPad->cd();
  fPad->Draw();
  fCanvas->Paint();
  fCanvas->Update();
}

Member Data Documentation

fAccButton

TButton* EdbDisplayBase::fAccButton

protected

Button to accept modified vertex.

fAllButton

TButton* EdbDisplayBase::fAllButton

protected

Button to draw all objects.

fArcButton

TArc* EdbDisplayBase::fArcButton

protected

Gren/Red button to show Pick/Zoom mode.

fButtons

TPad* EdbDisplayBase::fButtons

protected

Pointer to the buttons pad.

fCanButton

TButton* EdbDisplayBase::fCanButton

protected

Button to cancel modified vertex.

fCanvas

TCanvas* EdbDisplayBase::fCanvas

Pointer to the display canvas.

fCanvasName

char EdbDisplayBase::fCanvasName[128]

protected

Name of main canvas.

fCanvasTRK

TCanvas* EdbDisplayBase::fCanvasTRK

Pointer to the vertex canvas.

fCanvasVTX

TCanvas* EdbDisplayBase::fCanvasVTX

Pointer to the vertex canvas.

fColorBG

Int_t EdbDisplayBase::fColorBG

protected

color for the display BG

fDetector

TGeoVolume* EdbDisplayBase::fDetector

protected

detector geometry

fDrawAllViews

Bool_t EdbDisplayBase::fDrawAllViews

protected

Flag True if AllViews selected.

fDrawDet

Bool_t EdbDisplayBase::fDrawDet

protected

True if drawing detector is on.

fEnvButton

TButton* EdbDisplayBase::fEnvButton

protected

Button to draw vertex environment.

fHdrVTX

TText* EdbDisplayBase::fHdrVTX

protected

Vertex data header.

fLineWidth

Width_t EdbDisplayBase::fLineWidth

protected

Line width for tracks and segments.

fMain

TGMainFrame* EdbDisplayBase::fMain

protected

Dialog frame.

fNewBut

TButton* EdbDisplayBase::fNewBut

protected

Modified Vertex display button.

fNewVTX

TText* EdbDisplayBase::fNewVTX

protected

Modified Vertex data.

fOldBut

TButton* EdbDisplayBase::fOldBut

protected

Old Vertex display button.

fOldVTX

TText* EdbDisplayBase::fOldVTX

protected

Old Vertex data.

fPad

TPad* EdbDisplayBase::fPad

Pointer to the event display main pad.

fPhi

Float_t EdbDisplayBase::fPhi

protected

Viewing angle phi.

fPickButton

TButton* EdbDisplayBase::fPickButton

protected

Button to activate Pick mode.

fPreBut

TButton* EdbDisplayBase::fPreBut

protected

Previous Vertex display button.

fPreVTX

TText* EdbDisplayBase::fPreVTX

protected

Previous Vertex data.

fPsi

Float_t EdbDisplayBase::fPsi

protected

Viewving angle psi (rotation on display)

fRemBut

TButton* EdbDisplayBase::fRemBut[50]

protected

track removing buttons

fStyle

Int_t EdbDisplayBase::fStyle

protected

Display style (line width, sizes etc)

fTheta

Float_t EdbDisplayBase::fTheta

protected

Viewing angle theta.

fTitle

char EdbDisplayBase::fTitle[128]

protected

EdbDisplay Object Name.

fTrigPad

TPad* EdbDisplayBase::fTrigPad

protected

Pointer to the trigger pad.

fUndButton

TButton* EdbDisplayBase::fUndButton

protected

Button to undo vertex modofication.

fUnZoomButton

TButton* EdbDisplayBase::fUnZoomButton

protected

Button to Undo previous Zoom.

fView

Edb3DView* EdbDisplayBase::fView

protected

Main View object.

fVTXTracks

TPaveText* EdbDisplayBase::fVTXTracks

protected

Vertex tracks information.

fVTXTRKInfo

TPaveText* EdbDisplayBase::fVTXTRKInfo

Vertex - tracks information.

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

Button to activate Zoom mode.

fZoomMode

Int_t EdbDisplayBase::fZoomMode

protected

=1 if in zoom mode

fZooms

Int_t EdbDisplayBase::fZooms

protected

Number of zooms.

fZoomX0

Double_t EdbDisplayBase::fZoomX0[kMAXZOOMS]

protected

Low x range of zoom number i.

fZoomX1

Double_t EdbDisplayBase::fZoomX1[kMAXZOOMS]

protected

High x range of zoom number i.

fZoomY0

Double_t EdbDisplayBase::fZoomY0[kMAXZOOMS]

protected

Low y range of zoom number i.

fZoomY1

Double_t EdbDisplayBase::fZoomY1[kMAXZOOMS]

protected

High y range of zoom number i.

---

The documentation for this class was generated from the following files:

• /home/antonio/fedra_doxygen/src/libEdd/EdbDisplayBase.h
• /home/antonio/fedra_doxygen/src/libEdd/EdbDisplayBase.cxx