[u/mrichter/AliRoot.git] / DISPLAY / AliDisplay2.cxx

/**************************************************************************
 * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/////////////////////////////////////////////////////////////////////////
// ALICE EVENT DISPLAY CLASS                                           //
// Author: Mayeul   ROUSSELET                                          //
// e-mail: Mayeul.Rousselet@cern.ch                                    //
// Last update:26/08/2003                                              //
/////////////////////////////////////////////////////////////////////////

#define do_mc

//standard modules
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

//ROOT

#include <TTree.h>
#include <TGLayout.h>
#include <TObjArray.h>
#include <TSystem.h>
#include <TGWindow.h>
#include <TEnv.h>
#include <TPad.h>

//AliRoot Module
#include "AliModule.h"
#include "AliDetector.h"
#include "AliRun.h"
#include "AliMC.h"

#include "AliModuleInfo.h"
#include "AliSliderFrame.h"
#include "AliShutterFrame.h"
#include "AliDisplayFrame.h"
#include "AliInfoFrame.h"
#include "AliDetectorFrame.h"
#include "AliMenu.h"

#include "AliDisplay2.h"


 AliDisplay2 *gAliDisplay2;


ClassImp(AliDisplay2)
//_____________________________________________________________
AliDisplay2::AliDisplay2(const TGWindow *p, UInt_t w, UInt_t h)
			:TObject()
{
  //  Constructor
  //gAlice->SetDisplay(this);
  gAliDisplay2=this;
  fSliderUpdate = kFALSE;
  fZoomMode = kFALSE;
  fZoomStep = 1.2;
  fZoomFactor = 1.5;
  fNbParticles = 0;
  fEventNumber = 0;
  fNbHits = 0;
  fSliderStep = 0.01;
  fClustersLoaded = kFALSE;
  fHitsLoaded = kFALSE;
  fHLTLoaded = kFALSE;
  fTracksLoaded = kFALSE;
  fMode =0;
  FindModules();
  
  fIconsPath = new char[256];
  strcpy(fIconsPath,gSystem->Getenv("ALICE_ROOT"));
  strcat(fIconsPath,"/DISPLAY/icons/");
  LoadFromRC();
  fMainFrame = new TGMainFrame(p,w,h,kVerticalFrame);
  fSubFrame = new TGCompositeFrame(fMainFrame,w,h,kHorizontalFrame);
  fLeftFrame = new TGCompositeFrame(fSubFrame,150,h,kVerticalFrame|kFixedWidth);
  fRightFrame = new TGCompositeFrame(fSubFrame,600,h,kVerticalFrame);
  //fMainFrame->Connect("ProcessedEvent(Event_t*)", "AliDisplay2", this,"HandleMouseWheel(Event_t*)");
  fMainFrame->Connect("ProcessedEvent(Event_t*)", "AliDisplay2",this,"HandleResize(Event_t*)");
  //MenuBar
  fMenu = new AliMenu(fMainFrame,1,1,kRaisedFrame|kHorizontalFrame);
  
  //Slider Frame
  fSliderFrameLayout = new TGLayoutHints( kLHintsBottom| kLHintsRight| kLHintsExpandX | kLHintsCenterX, 2, 2, 2, 2);
  fSliderFrame  = new AliSliderFrame(fRightFrame,600,150);
  fRightFrame->AddFrame(fSliderFrame->GetSliderFrame(),fSliderFrameLayout);
  
  //Info Frame
  fInfoFrameLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft  | kLHintsExpandX  ,0,0,0,0);
  fInfoFrame = new AliInfoFrame(fLeftFrame,150,200);
  fLeftFrame->AddFrame(fInfoFrame->GetInfoFrame(),fInfoFrameLayout);
  
  
  //Shutter Frame
  fShutterFrameLayout = new TGLayoutHints( kLHintsTop | kLHintsLeft | kLHintsExpandY |kLHintsExpandX, 0, 0, 5, 0);
  fShutterFrame = new AliShutterFrame(fLeftFrame,150,300);
  fLeftFrame->AddFrame(fShutterFrame->GetShutterFrame(),fShutterFrameLayout);
  
  //Display Frame
  fDisplayFrameLayout = new TGLayoutHints( kLHintsTop | kLHintsRight | kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2); 
  fDisplayFrame = new AliDisplayFrame(fRightFrame, w-150,w-110);
  fRightFrame->AddFrame(fDisplayFrame->GetDisplayFrame(),fDisplayFrameLayout);
  fDisplayFrame->GetDisplayFrame()->Connect("ProcessedEvent(Event_t*)", "AliDisplay2", this,"HandleMouseWheel(Event_t*)");
  
  
  fLeftFrame->Layout();
  
  fSubFrame->AddFrame(fLeftFrame, new TGLayoutHints( kLHintsBottom | kLHintsLeft | kLHintsExpandY, 5, 5, 2, 2));
  fSubFrame->AddFrame(fRightFrame, new TGLayoutHints( kLHintsBottom | kLHintsRight | kLHintsExpandX | kLHintsExpandY, 5, 5, 2, 2));
  
  Int_t parts[] = {45,45,10};
  fStatusBar = new TGStatusBar(fMainFrame,50,10,kHorizontalFrame);
  fStatusBar->SetParts(parts,3);
  fStatusBar->SetText("AliDisplay v2.0",0);
  fMainFrame->AddFrame(fStatusBar,new TGLayoutHints(kLHintsBottom | kLHintsExpandX,0,0,0,0));
  
  fMainFrame->AddFrame(fSubFrame,new TGLayoutHints( kLHintsBottom | kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 5, 5, 2, 2));
  fMainFrame->SetWindowName("Ali Display");
  
  fMainFrame->MapSubwindows();
  fMainFrame->MapWindow();
  LoadSettings();

	
  fMainFrame->Resize(w-10,h);
  fMainFrame->Resize(w,h);
  fMainFrame->SetWMSizeHints(500,500,1280, 1200,1,1);
}

//_____________________________________________________________
AliDisplay2::~AliDisplay2(void)
{
  //Destructor
  delete fModules;
  delete [] fEnabledModules;
  delete fModuleInfo;
  
  delete fSliderFrameLayout;
  delete fSliderFrame;	
  delete fDisplayFrameLayout;
  delete fDisplayFrame;
  //	delete fZoomFrameLayout;
  //	delete fZoomFrame;
  delete fShutterFrameLayout;
  delete fShutterFrame;
  delete fInfoFrameLayout;
  delete fInfoFrame;
  delete fDetectorFrameLayout;
  delete fDetectorFrame;
  
  delete fSubFrame;
  delete fLeftFrame;
  delete fRightFrame;
  delete fMainFrame;
  delete fAliDisplay2rc;
  
  delete fMenu;
  delete fStatusBar;
}

//_____________________________________________________________
void AliDisplay2::CloseWindow(void)
{
  // Deletes the current display
  delete this;
}

//_____________________________________________________________
void AliDisplay2::LoadFromRC()
{
  // Load the environment settings from .alidisplayrc file
  TEnv *rc=new TEnv(".alidisplayrc");
  SetSliderUpdate(rc->GetValue("AliDisplay.SliderUpdate",kFALSE));
  SetZoomStep(rc->GetValue("AliDisplay.ZoomStep",1.2));
  SetSliderStep(rc->GetValue("AliDisplay.SliderStep",0.01));
  char c[128];
  fRawDataPath = new char[128];
  strcpy(c,gSystem->Getenv("ALICE_ROOT"));
  sprintf(fRawDataPath,"%s%s",c,rc->GetValue("AliDisplay.RawDataPath","/raw"));
  printf("\nRaw data path %s",fRawDataPath);
}

//_____________________________________________________________
void AliDisplay2::SaveToRC() const
{
  // Saves the environment settings in .alidisplayrc file
  TEnv *rc=new TEnv(".alidisplayrc");
  rc->SetValue("AliDisplay.SliderUpdate",GetSliderUpdate());
  rc->SetValue("AliDisplay.ZoomStep",GetZoomStep());
  rc->SetValue("AliDisplay.SliderStep",GetSliderStep());
  rc->SetValue("AliDisplay.RawDataPath","/raw");
  rc->SaveLevel(kEnvLocal);
  rc->Save();
}

//_____________________________________________________________
void AliDisplay2::DoSaveSettings(void)
{
  // Saves the environment settings for the slider frame and display
  fSliderFrame->SaveToRC();
  SaveToRC();
}

//_____________________________________________________________
void AliDisplay2::LoadSettings()
{
  // Loads settings
  LoadFromRC();
}

//_____________________________________________________________
void AliDisplay2::Draw(Option_t */*options*/)
{
  // Draws display frame
  fDisplayFrame->DoView(fCurrentView);
}

//_____________________________________________________________
void AliDisplay2::DrawX3d()
{
  // Draws display frame using X3d
  fDisplayFrame->DrawX3d();
}

//_____________________________________________________________
void AliDisplay2::DrawGL()
{
  // Draws display frame using GL
  fDisplayFrame->DrawGL();
}

//_____________________________________________________________
void AliDisplay2::ShowNextEvent(Int_t delta)
{
  //Load the next event
  clock_t t1,t2;
  t1=clock();
  Int_t newEvent=0;
  if(delta!=0){
    gAlice->Clear();
    newEvent = fEventNumber + delta;
    if( newEvent < 0) return;
    gAlice->GetEvent(newEvent);
    fEventNumber += delta;
    //		if(!gAlice->TreeH()) return;
  }
  if(IsEnabled(kHits)) LoadHits();
  if(IsEnabled(kClusters)) LoadClusters(newEvent);
  if(IsEnabled(kHLT)) LoadHLTClusters(newEvent);
  t2=clock();
  //	printf("\nEvent loaded in....%f sec", ((double)t2-t1)/(10000*CLK_TCK));
  Update(kmMODULES);
}

//_____________________________________________________________
void AliDisplay2::FindModules()
{
  // Find the modules used for the simulation and assign 
  // these modules to the array fModules
  fModules = new TObjArray;
  TObjArray *modules = gAlice->Modules();
  AliModule *mod;
  Int_t nbm = 0;
  for(Int_t i=0;i<modules->GetEntriesFast();i++){
    mod = (AliModule *) modules->At(i);
    if(!mod) continue;
    const char *avoid = strstr("BODY MAG ABSO DIPO HALL FRAME SHIL PIPE",mod->GetName());
    if(avoid) continue;
    fModules->AddLast(mod);
    nbm++;
  }
  fEnabledModules = new Bool_t[nbm];
  fNbModules = nbm;
  fModuleInfo = new AliModuleInfo(nbm);
  for(Int_t j=0;j<fModules->GetEntriesFast();j++){
    fModuleInfo->Add(fModules->At(j)->GetName(),j);
    fEnabledModules[j]=kTRUE;
  }
}

//_____________________________________________________________
void AliDisplay2::LoadHits()
{
  //Load the detected hits from each detector to memory
  gAlice->ResetPoints();
  TIter next(gAlice->Modules());
  AliModule *module;
  Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
  while((module = (AliModule*)next())) 
    {
      AliDetector* detector = dynamic_cast<AliDetector*>(module);
      if(detector) detector->SetTreeAddress();
    }
  next.Reset();
  for (Int_t track=0; track<ntracks;track++) {
    gAlice->ResetHits();
    while((module = (AliModule*)next())) {
      AliDetector* detector = dynamic_cast<AliDetector*>(module);
      if(detector)
	{
	  detector->TreeH()->GetEvent(track);
	  detector->LoadPoints(track);
	}
    }
    next.Reset();
  }
  fHitsLoaded = kTRUE;
}

//_____________________________________________________________
void AliDisplay2::LoadClusters(Int_t nevent)
{
  //clock_t t1,t2;
  fDisplayFrame->LoadClusters(nevent);
  fClustersLoaded = kTRUE;
  //	printf("\nClusters loaded in....%f sec", ((double)t2-t1)/(10000*CLK_TCK));
}

//_____________________________________________________________
void AliDisplay2::LoadHLTClusters(Int_t nevent)
{
  // Loads HLT clusters
  fDisplayFrame->LoadHLTClusters(nevent);
  fHLTLoaded = kTRUE;
}

//_____________________________________________________________
void AliDisplay2::Enable(Int_t m)
{
  // Enables the given mode m
  if(m==kHits){
    if((fMode&kHits)==kHits) return;
    fMode = kHits|fMode;
    if(!fHitsLoaded) LoadHits();
    Update(kmPOINTS);
  }
  if(m==kClusters){
    if((fMode&kClusters)==kClusters) return;
    fMode = kClusters|fMode;
    if(!fClustersLoaded) LoadClusters(fEventNumber);
    Update();
  }
  if(m==kHLT){
    if((fMode&kHLT)==kHLT) return;
    fMode = kHLT|fMode;
    if(!fHLTLoaded) {
      LoadHLTClusters(fEventNumber);
    }
    Update();
  }
  if(m==kTracks){
    if((fMode&kTracks)==kTracks) return;
    fMode = kTracks|fMode;
    Update();
  }
}

//_____________________________________________________________
void AliDisplay2::Disable(Int_t m)
{
  // Disables the given mode m
  if(m==kHits){
    fMode = fMode|kHits;
    fMode = fMode^kHits;
  }
  if(m==kClusters){
    fMode = fMode|kClusters;
    fMode = fMode^kClusters;
  }
  if(m==kHLT){
    fMode = fMode|kHLT;
    fMode = fMode^kHLT;
  }
  if(m==kTracks){
    fMode = fMode|kTracks;
    fMode = fMode^kTracks;
  }
  Update();
}

//_____________________________________________________________
Bool_t AliDisplay2::IsEnabled(Int_t m) const
{
  // Checks if the mode m is enabled
  if(m==kHits){
    if((fMode&kHits)==kHits) return kTRUE;
    return kFALSE;
  }
  if(m==kClusters){
    if((fMode&kClusters)==kClusters) return kTRUE;
    return kFALSE;
  }
  if(m==kHLT){
    if((fMode&kHLT)==kHLT) return kTRUE;
    return kFALSE;
  }
  if(m==kTracks){
    if((fMode&kTracks)==kTracks) return kTRUE;
    return kFALSE;
  }
  return kFALSE;
}

//_____________________________________________________________
void AliDisplay2::HandleMouseWheel(Event_t *event)
{
  //Handle mouve event, not working yet
  if(event->fType != kButtonPress && event->fType != kButtonRelease) return;
  
  if(event->fCode == kButton4){
    fZoomFactor *= fZoomStep;
    Draw();
  }
  
  if(event->fCode == kButton5){
    fZoomFactor /= fZoomStep;
    Draw();
  }
}

//_____________________________________________________________
void AliDisplay2::HandleResize(Event_t *event)
{
  // Handle resize event
  switch(event->fType){
  case kConfigureNotify:{
    Draw();
  }
    break;
  default:break;
  }
}	

//_____________________________________________________________
void AliDisplay2::Update(Int_t tag)
{
  // Update the view, if loading only the modified data from the previous
  // changes, the integer tag indicates the kind of modification
  if(tag==kmMODULES){
    LoadEnabledModules();
    if(((fMode)&kHits)==kHits){
      LoadEnabledHits();
      ApplyCuts();
    }
  }
  if(tag==kmCUTS){
    if(((fMode)&kHits)==kHits)ApplyCuts();
  }
  if(tag==kmPOINTS){
    if(((fMode)&kHits)==kHits){
      LoadEnabledHits();
      ApplyCuts();
    }
  }
  Draw();
  fInfoFrame->Update();
}
Commit	Line	Data
37f14bbf	1	/**************************************************************************
	2	* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
7bb7ac14	15	/////////////////////////////////////////////////////////////////////////
	16	// ALICE EVENT DISPLAY CLASS //
	17	// Author: Mayeul ROUSSELET //
	18	// e-mail: Mayeul.Rousselet@cern.ch //
	19	// Last update:26/08/2003 //
	20	/////////////////////////////////////////////////////////////////////////
37f14bbf	21
	22	#define do_mc
	23
	24	//standard modules
	25	#include <stdlib.h>
	26	#include <stdio.h>
	27	#include <time.h>
	28
	29	//ROOT
	30
37f14bbf	31	#include <TTree.h>
37f14bbf	32	#include <TGLayout.h>
37f14bbf	33	#include <TObjArray.h>
37f14bbf	34	#include <TSystem.h>
37f14bbf	35	#include <TGWindow.h>
37f14bbf	36	#include <TEnv.h>
7bb7ac14	37	#include <TPad.h>
37f14bbf	38
	39	//AliRoot Module
	40	#include "AliModule.h"
	41	#include "AliDetector.h"
37f14bbf	42	#include "AliRun.h"
37f14bbf	43	#include "AliMC.h"
37f14bbf	44
7bb7ac14	45	#include "AliModuleInfo.h"
	46	#include "AliSliderFrame.h"
	47	#include "AliShutterFrame.h"
	48	#include "AliDisplayFrame.h"
	49	#include "AliInfoFrame.h"
	50	#include "AliDetectorFrame.h"
	51	#include "AliMenu.h"
37f14bbf	52
	53	#include "AliDisplay2.h"
	54
37f14bbf	55
7bb7ac14	56	AliDisplay2 *gAliDisplay2;
37f14bbf	57
37f14bbf	58
925e6570	59	ClassImp(AliDisplay2)
37f14bbf	60	//_____________________________________________________________
7bb7ac14	61	AliDisplay2::AliDisplay2(const TGWindow *p, UInt_t w, UInt_t h)
7bb7ac14	62	:TObject()
37f14bbf	63	{
7bb7ac14	64	// Constructor
	65	//gAlice->SetDisplay(this);
	66	gAliDisplay2=this;
	67	fSliderUpdate = kFALSE;
	68	fZoomMode = kFALSE;
	69	fZoomStep = 1.2;
	70	fZoomFactor = 1.5;
	71	fNbParticles = 0;
	72	fEventNumber = 0;
	73	fNbHits = 0;
	74	fSliderStep = 0.01;
	75	fClustersLoaded = kFALSE;
	76	fHitsLoaded = kFALSE;
	77	fHLTLoaded = kFALSE;
	78	fTracksLoaded = kFALSE;
	79	fMode =0;
	80	FindModules();
37f14bbf	81
dc16a642	82	fIconsPath = new char[256];
7bb7ac14	83	strcpy(fIconsPath,gSystem->Getenv("ALICE_ROOT"));
	84	strcat(fIconsPath,"/DISPLAY/icons/");
	85	LoadFromRC();
	86	fMainFrame = new TGMainFrame(p,w,h,kVerticalFrame);
	87	fSubFrame = new TGCompositeFrame(fMainFrame,w,h,kHorizontalFrame);
	88	fLeftFrame = new TGCompositeFrame(fSubFrame,150,h,kVerticalFrame\|kFixedWidth);
	89	fRightFrame = new TGCompositeFrame(fSubFrame,600,h,kVerticalFrame);
	90	//fMainFrame->Connect("ProcessedEvent(Event_t)", "AliDisplay2", this,"HandleMouseWheel(Event_t)");
	91	fMainFrame->Connect("ProcessedEvent(Event_t)", "AliDisplay2",this,"HandleResize(Event_t)");
	92	//MenuBar
	93	fMenu = new AliMenu(fMainFrame,1,1,kRaisedFrame\|kHorizontalFrame);
37f14bbf	94
7bb7ac14	95	//Slider Frame
	96	fSliderFrameLayout = new TGLayoutHints( kLHintsBottom\| kLHintsRight\| kLHintsExpandX \| kLHintsCenterX, 2, 2, 2, 2);
	97	fSliderFrame = new AliSliderFrame(fRightFrame,600,150);
	98	fRightFrame->AddFrame(fSliderFrame->GetSliderFrame(),fSliderFrameLayout);
37f14bbf	99
7bb7ac14	100	//Info Frame
	101	fInfoFrameLayout = new TGLayoutHints( kLHintsTop \| kLHintsLeft \| kLHintsExpandX ,0,0,0,0);
	102	fInfoFrame = new AliInfoFrame(fLeftFrame,150,200);
	103	fLeftFrame->AddFrame(fInfoFrame->GetInfoFrame(),fInfoFrameLayout);
37f14bbf	104
37f14bbf	105
7bb7ac14	106	//Shutter Frame
	107	fShutterFrameLayout = new TGLayoutHints( kLHintsTop \| kLHintsLeft \| kLHintsExpandY \|kLHintsExpandX, 0, 0, 5, 0);
	108	fShutterFrame = new AliShutterFrame(fLeftFrame,150,300);
	109	fLeftFrame->AddFrame(fShutterFrame->GetShutterFrame(),fShutterFrameLayout);
	110
	111	//Display Frame
	112	fDisplayFrameLayout = new TGLayoutHints( kLHintsTop \| kLHintsRight \| kLHintsExpandX \| kLHintsExpandY, 2, 2, 2, 2);
	113	fDisplayFrame = new AliDisplayFrame(fRightFrame, w-150,w-110);
	114	fRightFrame->AddFrame(fDisplayFrame->GetDisplayFrame(),fDisplayFrameLayout);
	115	fDisplayFrame->GetDisplayFrame()->Connect("ProcessedEvent(Event_t)", "AliDisplay2", this,"HandleMouseWheel(Event_t)");
	116
	117
	118	fLeftFrame->Layout();
	119
	120	fSubFrame->AddFrame(fLeftFrame, new TGLayoutHints( kLHintsBottom \| kLHintsLeft \| kLHintsExpandY, 5, 5, 2, 2));
	121	fSubFrame->AddFrame(fRightFrame, new TGLayoutHints( kLHintsBottom \| kLHintsRight \| kLHintsExpandX \| kLHintsExpandY, 5, 5, 2, 2));
	122
	123	Int_t parts[] = {45,45,10};
	124	fStatusBar = new TGStatusBar(fMainFrame,50,10,kHorizontalFrame);
	125	fStatusBar->SetParts(parts,3);
	126	fStatusBar->SetText("AliDisplay v2.0",0);
	127	fMainFrame->AddFrame(fStatusBar,new TGLayoutHints(kLHintsBottom \| kLHintsExpandX,0,0,0,0));
	128
	129	fMainFrame->AddFrame(fSubFrame,new TGLayoutHints( kLHintsBottom \| kLHintsLeft \| kLHintsExpandX \| kLHintsExpandY, 5, 5, 2, 2));
	130	fMainFrame->SetWindowName("Ali Display");
	131
	132	fMainFrame->MapSubwindows();
	133	fMainFrame->MapWindow();
	134	LoadSettings();
37f14bbf	135
37f14bbf	136
7bb7ac14	137	fMainFrame->Resize(w-10,h);
	138	fMainFrame->Resize(w,h);
	139	fMainFrame->SetWMSizeHints(500,500,1280, 1200,1,1);
37f14bbf	140	}
	141
	142	//_____________________________________________________________
	143	AliDisplay2::~AliDisplay2(void)
	144	{
7bb7ac14	145	//Destructor
37f14bbf	146	delete fModules;
	147	delete [] fEnabledModules;
	148	delete fModuleInfo;
7bb7ac14	149
	150	delete fSliderFrameLayout;
	151	delete fSliderFrame;
	152	delete fDisplayFrameLayout;
	153	delete fDisplayFrame;
	154	// delete fZoomFrameLayout;
	155	// delete fZoomFrame;
	156	delete fShutterFrameLayout;
	157	delete fShutterFrame;
	158	delete fInfoFrameLayout;
	159	delete fInfoFrame;
	160	delete fDetectorFrameLayout;
	161	delete fDetectorFrame;
	162
	163	delete fSubFrame;
	164	delete fLeftFrame;
	165	delete fRightFrame;
	166	delete fMainFrame;
	167	delete fAliDisplay2rc;
	168
	169	delete fMenu;
	170	delete fStatusBar;
37f14bbf	171	}
	172
	173	//_____________________________________________________________
	174	void AliDisplay2::CloseWindow(void)
	175	{
7bb7ac14	176	// Deletes the current display
7bb7ac14	177	delete this;
37f14bbf	178	}
	179
	180	//_____________________________________________________________
	181	void AliDisplay2::LoadFromRC()
	182	{
7bb7ac14	183	// Load the environment settings from .alidisplayrc file
37f14bbf	184	TEnv *rc=new TEnv(".alidisplayrc");
	185	SetSliderUpdate(rc->GetValue("AliDisplay.SliderUpdate",kFALSE));
	186	SetZoomStep(rc->GetValue("AliDisplay.ZoomStep",1.2));
	187	SetSliderStep(rc->GetValue("AliDisplay.SliderStep",0.01));
	188	char c[128];
	189	fRawDataPath = new char[128];
	190	strcpy(c,gSystem->Getenv("ALICE_ROOT"));
	191	sprintf(fRawDataPath,"%s%s",c,rc->GetValue("AliDisplay.RawDataPath","/raw"));
	192	printf("\nRaw data path %s",fRawDataPath);
	193	}
	194
	195	//_____________________________________________________________
7bb7ac14	196	void AliDisplay2::SaveToRC() const
37f14bbf	197	{
7bb7ac14	198	// Saves the environment settings in .alidisplayrc file
37f14bbf	199	TEnv *rc=new TEnv(".alidisplayrc");
	200	rc->SetValue("AliDisplay.SliderUpdate",GetSliderUpdate());
	201	rc->SetValue("AliDisplay.ZoomStep",GetZoomStep());
	202	rc->SetValue("AliDisplay.SliderStep",GetSliderStep());
	203	rc->SetValue("AliDisplay.RawDataPath","/raw");
	204	rc->SaveLevel(kEnvLocal);
	205	rc->Save();
	206	}
	207
	208	//_____________________________________________________________
	209	void AliDisplay2::DoSaveSettings(void)
	210	{
7bb7ac14	211	// Saves the environment settings for the slider frame and display
37f14bbf	212	fSliderFrame->SaveToRC();
	213	SaveToRC();
	214	}
	215
	216	//_____________________________________________________________
	217	void AliDisplay2::LoadSettings()
	218	{
7bb7ac14	219	// Loads settings
37f14bbf	220	LoadFromRC();
	221	}
	222
	223	//_____________________________________________________________
	224	void AliDisplay2::Draw(Option_t /options*/)
	225	{
7bb7ac14	226	// Draws display frame
7bb7ac14	227	fDisplayFrame->DoView(fCurrentView);
37f14bbf	228	}
	229
	230	//_____________________________________________________________
	231	void AliDisplay2::DrawX3d()
	232	{
7bb7ac14	233	// Draws display frame using X3d
7bb7ac14	234	fDisplayFrame->DrawX3d();
37f14bbf	235	}
	236
	237	//_____________________________________________________________
	238	void AliDisplay2::DrawGL()
	239	{
7bb7ac14	240	// Draws display frame using GL
7bb7ac14	241	fDisplayFrame->DrawGL();
37f14bbf	242	}
	243
	244	//_____________________________________________________________
	245	void AliDisplay2::ShowNextEvent(Int_t delta)
	246	{
7bb7ac14	247	//Load the next event
	248	clock_t t1,t2;
	249	t1=clock();
	250	Int_t newEvent=0;
	251	if(delta!=0){
	252	gAlice->Clear();
	253	newEvent = fEventNumber + delta;
	254	if( newEvent < 0) return;
	255	gAlice->GetEvent(newEvent);
	256	fEventNumber += delta;
	257	// if(!gAlice->TreeH()) return;
	258	}
	259	if(IsEnabled(kHits)) LoadHits();
	260	if(IsEnabled(kClusters)) LoadClusters(newEvent);
	261	if(IsEnabled(kHLT)) LoadHLTClusters(newEvent);
	262	t2=clock();
	263	// printf("\nEvent loaded in....%f sec", ((double)t2-t1)/(10000*CLK_TCK));
	264	Update(kmMODULES);
37f14bbf	265	}
	266
	267	//_____________________________________________________________
	268	void AliDisplay2::FindModules()
	269	{
7bb7ac14	270	// Find the modules used for the simulation and assign
	271	// these modules to the array fModules
	272	fModules = new TObjArray;
	273	TObjArray *modules = gAlice->Modules();
	274	AliModule *mod;
	275	Int_t nbm = 0;
	276	for(Int_t i=0;i<modules->GetEntriesFast();i++){
	277	mod = (AliModule *) modules->At(i);
	278	if(!mod) continue;
	279	const char *avoid = strstr("BODY MAG ABSO DIPO HALL FRAME SHIL PIPE",mod->GetName());
	280	if(avoid) continue;
	281	fModules->AddLast(mod);
	282	nbm++;
	283	}
	284	fEnabledModules = new Bool_t[nbm];
	285	fNbModules = nbm;
	286	fModuleInfo = new AliModuleInfo(nbm);
	287	for(Int_t j=0;j<fModules->GetEntriesFast();j++){
	288	fModuleInfo->Add(fModules->At(j)->GetName(),j);
	289	fEnabledModules[j]=kTRUE;
	290	}
37f14bbf	291	}
	292
	293	//_____________________________________________________________
	294	void AliDisplay2::LoadHits()
	295	{
7bb7ac14	296	//Load the detected hits from each detector to memory
	297	gAlice->ResetPoints();
	298	TIter next(gAlice->Modules());
	299	AliModule *module;
	300	Int_t ntracks = gAlice->GetMCApp()->GetNtrack();
	301	while((module = (AliModule*)next()))
37f14bbf	302	{
7bb7ac14	303	AliDetector* detector = dynamic_cast<AliDetector*>(module);
	304	if(detector) detector->SetTreeAddress();
	305	}
	306	next.Reset();
	307	for (Int_t track=0; track<ntracks;track++) {
	308	gAlice->ResetHits();
	309	while((module = (AliModule*)next())) {
	310	AliDetector* detector = dynamic_cast<AliDetector*>(module);
	311	if(detector)
	312	{
	313	detector->TreeH()->GetEvent(track);
	314	detector->LoadPoints(track);
	315	}
37f14bbf	316	}
7bb7ac14	317	next.Reset();
	318	}
	319	fHitsLoaded = kTRUE;
37f14bbf	320	}
	321
	322	//_____________________________________________________________
	323	void AliDisplay2::LoadClusters(Int_t nevent)
	324	{
	325	//clock_t t1,t2;
7bb7ac14	326	fDisplayFrame->LoadClusters(nevent);
	327	fClustersLoaded = kTRUE;
	328	// printf("\nClusters loaded in....%f sec", ((double)t2-t1)/(10000*CLK_TCK));
37f14bbf	329	}
	330
	331	//_____________________________________________________________
	332	void AliDisplay2::LoadHLTClusters(Int_t nevent)
	333	{
7bb7ac14	334	// Loads HLT clusters
37f14bbf	335	fDisplayFrame->LoadHLTClusters(nevent);
	336	fHLTLoaded = kTRUE;
	337	}
	338
	339	//_____________________________________________________________
	340	void AliDisplay2::Enable(Int_t m)
	341	{
7bb7ac14	342	// Enables the given mode m
37f14bbf	343	if(m==kHits){
	344	if((fMode&kHits)==kHits) return;
	345	fMode = kHits\|fMode;
	346	if(!fHitsLoaded) LoadHits();
	347	Update(kmPOINTS);
	348	}
	349	if(m==kClusters){
	350	if((fMode&kClusters)==kClusters) return;
	351	fMode = kClusters\|fMode;
	352	if(!fClustersLoaded) LoadClusters(fEventNumber);
	353	Update();
	354	}
	355	if(m==kHLT){
	356	if((fMode&kHLT)==kHLT) return;
	357	fMode = kHLT\|fMode;
	358	if(!fHLTLoaded) {
	359	LoadHLTClusters(fEventNumber);
	360	}
	361	Update();
	362	}
	363	if(m==kTracks){
	364	if((fMode&kTracks)==kTracks) return;
	365	fMode = kTracks\|fMode;
	366	Update();
	367	}
925e6570	368	}
37f14bbf	369
	370	//_____________________________________________________________
	371	void AliDisplay2::Disable(Int_t m)
	372	{
7bb7ac14	373	// Disables the given mode m
37f14bbf	374	if(m==kHits){
	375	fMode = fMode\|kHits;
	376	fMode = fMode^kHits;
	377	}
	378	if(m==kClusters){
	379	fMode = fMode\|kClusters;
	380	fMode = fMode^kClusters;
	381	}
	382	if(m==kHLT){
	383	fMode = fMode\|kHLT;
	384	fMode = fMode^kHLT;
	385	}
	386	if(m==kTracks){
	387	fMode = fMode\|kTracks;
	388	fMode = fMode^kTracks;
	389	}
	390	Update();
	391	}
	392
	393	//_____________________________________________________________
7bb7ac14	394	Bool_t AliDisplay2::IsEnabled(Int_t m) const
37f14bbf	395	{
7bb7ac14	396	// Checks if the mode m is enabled
37f14bbf	397	if(m==kHits){
	398	if((fMode&kHits)==kHits) return kTRUE;
	399	return kFALSE;
	400	}
	401	if(m==kClusters){
	402	if((fMode&kClusters)==kClusters) return kTRUE;
	403	return kFALSE;
	404	}
	405	if(m==kHLT){
	406	if((fMode&kHLT)==kHLT) return kTRUE;
	407	return kFALSE;
	408	}
	409	if(m==kTracks){
	410	if((fMode&kTracks)==kTracks) return kTRUE;
	411	return kFALSE;
	412	}
	413	return kFALSE;
	414	}
	415
	416	//_____________________________________________________________
	417	void AliDisplay2::HandleMouseWheel(Event_t *event)
	418	{
7bb7ac14	419	//Handle mouve event, not working yet
	420	if(event->fType != kButtonPress && event->fType != kButtonRelease) return;
	421
	422	if(event->fCode == kButton4){
	423	fZoomFactor *= fZoomStep;
	424	Draw();
	425	}
	426
	427	if(event->fCode == kButton5){
	428	fZoomFactor /= fZoomStep;
	429	Draw();
	430	}
37f14bbf	431	}
	432
	433	//_____________________________________________________________
	434	void AliDisplay2::HandleResize(Event_t *event)
	435	{
7bb7ac14	436	// Handle resize event
	437	switch(event->fType){
	438	case kConfigureNotify:{
	439	Draw();
	440	}
	441	break;
	442	default:break;
	443	}
37f14bbf	444	}
	445
	446	//_____________________________________________________________
	447	void AliDisplay2::Update(Int_t tag)
	448	{
7bb7ac14	449	// Update the view, if loading only the modified data from the previous
	450	// changes, the integer tag indicates the kind of modification
	451	if(tag==kmMODULES){
	452	LoadEnabledModules();
	453	if(((fMode)&kHits)==kHits){
	454	LoadEnabledHits();
	455	ApplyCuts();
	456	}
	457	}
	458	if(tag==kmCUTS){
	459	if(((fMode)&kHits)==kHits)ApplyCuts();
	460	}
	461	if(tag==kmPOINTS){
	462	if(((fMode)&kHits)==kHits){
	463	LoadEnabledHits();
	464	ApplyCuts();
	465	}
	466	}
	467	Draw();
	468	fInfoFrame->Update();
37f14bbf	469	}
	470
	471