[u/mrichter/AliRoot.git] / DISPLAY / AliSliderFrame.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 SLIDER FRAME CLASS                                            //
// Author: Mayeul   ROUSSELET                                          //
// e-mail: Mayeul.Rousselet@cern.ch                                    //
// Last update:26/08/2003                                              //
/////////////////////////////////////////////////////////////////////////

#include <TGFrame.h>
#include <TGLayout.h>
#include <TGLabel.h>
#include <TGNumberEntry.h>
#include <TEnv.h>

#include "AliSliderFrame.h"
#include "AliDisplay2.h"

ClassImp(AliSliderFrame);

//_____________________________________________________________
AliSliderFrame::AliSliderFrame(const TGWindow *p, UInt_t w, UInt_t h)
{
  // Constructor
  fMainFrame = new TGCompositeFrame(p, w, h, kVerticalFrame | kRaisedFrame);
  fLayout = new TGLayoutHints( kLHintsBottom | kLHintsRight | kLHintsExpandX,5,5,2,2);
  
  //Momentum Slider
  fMomentumFrame = new TGCompositeFrame(fMainFrame,0,0, kHorizontalFrame);
  fMomentumLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX ,5,5,2,2);
  fMomentumSlider = new TGDoubleHSlider(fMomentumFrame, 400, kDoubleScaleBoth, kIdsMOMENTUM);
  fMomentumSlider->Connect("PositionChanged()","AliSliderFrame",this,"DoSlider()");
  fMomentumSlider->Connect("PositionChanged()","AliSliderFrame",this,"DoPositionChanged(Int_t)");
  fMomentumSlider->Connect("Released()","AliSliderFrame",this,"DoReleased()");
  SetMomentumRange(0,2);
  fMomentumSlider->SetPosition(0,2);
  fMomentumLabel = new TGLabel(fMomentumFrame,"Momentum");
  
  fMomentumMinValue = new TGNumberEntry(fMomentumFrame,GetMomentumMin(),7,kIdsMomentumMIN);
  fMomentumMinValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
  fMomentumMinValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
  fMomentumMinValue->SetButtonToNum(kFALSE);
  
  fMomentumMaxValue = new TGNumberEntry(fMomentumFrame,GetMomentumMax(),7,kIdsMomentumMAX);
  fMomentumMaxValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
  fMomentumMaxValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
  fMomentumMaxValue->SetButtonToNum(kFALSE);
  
  fMomentumFrame->AddFrame(fMomentumLabel,new TGLayoutHints( kLHintsLeft | kLHintsCenterY,5,5,2,2));
  fMomentumFrame->AddFrame(fMomentumMinValue,new TGLayoutHints( kLHintsLeft ,5,5,2,2));
  fMomentumFrame->AddFrame(fMomentumSlider,fMomentumLayout);
  fMomentumFrame->AddFrame(fMomentumMaxValue,new TGLayoutHints( kLHintsRight,5,5,2,2));
  fMomentumFrame->Resize(700,100);
  
  
  //Rapidity Slider
  fRapidityFrame = new TGCompositeFrame(fMainFrame,0,0, kHorizontalFrame);
  fRapidityLayout = new TGLayoutHints( kLHintsLeft | kLHintsTop | kLHintsExpandX,5,5,2,2);
  fRapiditySlider = new TGDoubleHSlider(fRapidityFrame, 400, kDoubleScaleBoth, kIdsRAPIDITY);
  fRapiditySlider->Connect("PositionChanged()","AliSliderFrame",this,"DoSlider()");
  fRapiditySlider->Connect("PositionChanged()","AliSliderFrame",this,"DoPositionChanged(Int_t)");
  fRapiditySlider->Connect("Released()","AliSliderFrame",this,"DoReleased()");
  SetRapidityRange(-1.5,1.5);
  fRapiditySlider->SetPosition(-1.5,1.5);
  fRapidityLabel = new TGLabel(fRapidityFrame,"Rapidity    ");
  fRapidityMinValue = new TGNumberEntry(fRapidityFrame,GetRapidityMin(),7,kIdsRapidityMIN);
  fRapidityMinValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
  fRapidityMinValue->SetButtonToNum(kFALSE);
  fRapidityMinValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
  
  fRapidityMaxValue = new TGNumberEntry(fRapidityFrame,GetRapidityMax(),7,kIdsRapidityMAX);
  fRapidityMaxValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
  fRapidityMaxValue->SetButtonToNum(kFALSE);
  fRapidityMaxValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
  
  fRapidityFrame->AddFrame(fRapidityLabel,new TGLayoutHints( kLHintsLeft | kLHintsCenterY,5,5,2,2));
  fRapidityFrame->AddFrame(fRapidityMinValue,new TGLayoutHints( kLHintsLeft ,5,5,2,2));
  fRapidityFrame->AddFrame(fRapiditySlider,fRapidityLayout);
  fRapidityFrame->AddFrame(fRapidityMaxValue,new TGLayoutHints( kLHintsRight ,5,5,2,2));
  fRapidityFrame->Resize(700,100);
  
  fMainFrame->AddFrame(fMomentumFrame,fLayout);
  fMainFrame->AddFrame(fRapidityFrame,fLayout);
  fMainFrame->MapSubwindows();
  fMainFrame->MapWindow();
  fMainFrame->Resize(700,100);
  LoadFromRC();
}

//_____________________________________________________________
AliSliderFrame::~AliSliderFrame(void)
{
  // Destructor
  delete fLayout;
  delete fRapidityLayout;
  delete fMomentumLayout;
  delete fMomentumMinValue;
  delete fMomentumMaxValue;
  delete fMainFrame;
  delete fRapidityFrame;
  delete fMomentumFrame;
  delete fMomentumSlider;
  delete fRapiditySlider;
  delete fMomentumLabel;
  delete fRapidityLabel;
  delete fRapidityMinValue;
  delete fRapidityMaxValue;
}

//_____________________________________________________________
void AliSliderFrame::CloseWindow(void)
{
  // Deletes this window
  delete this;
}

//_____________________________________________________________
void AliSliderFrame::DoSlider(Int_t /*pos*/)
{
  // Updates the values in case one moves a slider
  TGFrame *frame = (TGFrame *) gTQSender;
  TGDoubleSlider * ds = (TGDoubleSlider *) frame;
  int id = ds->WidgetId();
  char min[8];
  char max[8];
  switch(id){
  case kIdsMOMENTUM:{
    //sprintf(buf,"momentum min:%f max:%f",GetMomentumMin(),GetMomentumMax());
    //printf("\n%s",buf);
    sprintf(min,"%.4f",GetMomentumMin());
    sprintf(max,"%.4f",GetMomentumMax());
    fMomentumMaxValue->SetText(max);
    fMomentumMinValue->SetText(min);
  }
    break;
  case kIdsRAPIDITY:{
    sprintf(min,"%.4f",GetRapidityMin());
    sprintf(max,"%.4f",GetRapidityMax());
    fRapidityMaxValue->SetText(max);
    fRapidityMinValue->SetText(min);
  }
    break;
  default:break;
  }
}

//_____________________________________________________________
void AliSliderFrame::DoReleased(Int_t /*pos*/) const
{
  // Updates the display when the slider is released
  TGFrame *frame = (TGFrame *) gTQSender;
  TGDoubleSlider * ds = (TGDoubleSlider *) frame;
  int id = ds->WidgetId();
  switch(id){
  case kIdsRAPIDITY:
  case kIdsMOMENTUM:
    gAliDisplay2->Update(kmCUTS);
    break;
  default: break;
  }
}

//_____________________________________________________________
void AliSliderFrame::DoPositionChanged(Int_t /*pos*/) const
{
  // Updates the display when a slider has changed
  if(!gAliDisplay2->GetSliderUpdate()) return;
  TGFrame *frame = (TGFrame *) gTQSender;
  TGDoubleSlider * ds = (TGDoubleSlider *) frame;
  int id = ds->WidgetId();
  switch(id){
  case kIdsRapidityMIN:
  case kIdsRapidityMAX:
  case kIdsMomentumMIN:
  case kIdsMomentumMAX:{
    gAliDisplay2->Update(kmCUTS);
  }
    break;
  default: break;
  }
}

//_____________________________________________________________
void AliSliderFrame::DoField(Long_t pos)
{
  // Updates the display in case of changed min/max values for
  // momentum and/or rapidity
  TGNumberEntry *ne = (TGNumberEntry *) gTQSender;
  int id = ne->WidgetId();
  char max[8],min[8];
  Int_t sign=0;
  Float_t step=gAliDisplay2->GetSliderStep();
  if((pos/10000)==0){//Up button pressed
    sign = 1;
  }
  else sign = -1;
  
  switch(id){
  case kIdsMomentumMIN:{
    fMomentumMinValue->SetNumber(fMomentumMinValue->GetNumber()+step*sign);
    sprintf(min,"%.4f",fMomentumMinValue->GetNumber());
    fMomentumMinValue->SetText(min);
  }
    break;
  case kIdsMomentumMAX:{
    fMomentumMaxValue->SetNumber(fMomentumMaxValue->GetNumber()+step*sign);
    sprintf(max,"%.4f",fMomentumMaxValue->GetNumber());
    fMomentumMaxValue->SetText(max);
  }
    break;
  case kIdsRapidityMIN:{
    fRapidityMinValue->SetNumber(fRapidityMinValue->GetNumber()+step*sign);
    sprintf(min,"%.4f",fRapidityMinValue->GetNumber());
    fRapidityMinValue->SetText(min);
  }
    break;
  case kIdsRapidityMAX:{
    fRapidityMaxValue->SetNumber(fRapidityMaxValue->GetNumber()+step*sign);
    sprintf(max,"%.4f",fRapidityMaxValue->GetNumber());
    fRapidityMaxValue->SetText(max);
  }
    break;
  default:break;
  }
  
  fMomentumSlider->SetPosition(fMomentumMinValue->GetNumber(),fMomentumMaxValue->GetNumber());
  fRapiditySlider->SetPosition(fRapidityMinValue->GetNumber(),fRapidityMaxValue->GetNumber());
  //	gAliDisplay2->Draw();
  gAliDisplay2->Update(kmCUTS);
}

//_____________________________________________________________
void AliSliderFrame::SaveToRC() const
{
  // Saves settings in the .alidisplayrc file
  TEnv *rc=new TEnv(".alidisplayrc");
  rc->SetValue("AliDisplay.MomentumMin",GetMomentumMin());
  rc->SetValue("AliDisplay.MomentumMax",GetMomentumMax());
  rc->SetValue("AliDisplay.RapidityMin",GetRapidityMin());
  rc->SetValue("AliDisplay.RapidityMax",GetRapidityMax());
  rc->SaveLevel(kEnvLocal);
  rc->Save();
}

//_____________________________________________________________	
void AliSliderFrame::LoadFromRC()
{
  // Loads settings from the .alidisplayrc file
  // and uses the default momentum and rapidity ranges
  TEnv *rc=new TEnv(".alidisplayrc");
  Float_t a,b;
  a=rc->GetValue("AliDisplay.MomentumMin",0);
  b=rc->GetValue("AliDisplay.MomentumMax",2);
  fMomentumSlider->SetPosition(a,b);
  a=rc->GetValue("AliDisplay.RapidityMin",-1.5);
  b=rc->GetValue("AliDisplay.RapidityMax",1.5);
  fRapiditySlider->SetPosition(a,b);
}
Commit	Line	Data
7bb7ac14	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	**************************************************************************/
	15	/////////////////////////////////////////////////////////////////////////
	16	// ALICE SLIDER FRAME CLASS //
	17	// Author: Mayeul ROUSSELET //
	18	// e-mail: Mayeul.Rousselet@cern.ch //
	19	// Last update:26/08/2003 //
	20	/////////////////////////////////////////////////////////////////////////
	21
	22	#include <TGFrame.h>
	23	#include <TGLayout.h>
	24	#include <TGLabel.h>
	25	#include <TGNumberEntry.h>
	26	#include <TEnv.h>
	27
	28	#include "AliSliderFrame.h"
	29	#include "AliDisplay2.h"
	30
	31	ClassImp(AliSliderFrame);
	32
	33	//_____________________________________________________________
	34	AliSliderFrame::AliSliderFrame(const TGWindow *p, UInt_t w, UInt_t h)
	35	{
	36	// Constructor
	37	fMainFrame = new TGCompositeFrame(p, w, h, kVerticalFrame \| kRaisedFrame);
	38	fLayout = new TGLayoutHints( kLHintsBottom \| kLHintsRight \| kLHintsExpandX,5,5,2,2);
	39
	40	//Momentum Slider
	41	fMomentumFrame = new TGCompositeFrame(fMainFrame,0,0, kHorizontalFrame);
	42	fMomentumLayout = new TGLayoutHints( kLHintsLeft \| kLHintsTop \| kLHintsExpandX ,5,5,2,2);
	43	fMomentumSlider = new TGDoubleHSlider(fMomentumFrame, 400, kDoubleScaleBoth, kIdsMOMENTUM);
	44	fMomentumSlider->Connect("PositionChanged()","AliSliderFrame",this,"DoSlider()");
	45	fMomentumSlider->Connect("PositionChanged()","AliSliderFrame",this,"DoPositionChanged(Int_t)");
	46	fMomentumSlider->Connect("Released()","AliSliderFrame",this,"DoReleased()");
	47	SetMomentumRange(0,2);
	48	fMomentumSlider->SetPosition(0,2);
	49	fMomentumLabel = new TGLabel(fMomentumFrame,"Momentum");
	50
	51	fMomentumMinValue = new TGNumberEntry(fMomentumFrame,GetMomentumMin(),7,kIdsMomentumMIN);
	52	fMomentumMinValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
	53	fMomentumMinValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
	54	fMomentumMinValue->SetButtonToNum(kFALSE);
	55
	56	fMomentumMaxValue = new TGNumberEntry(fMomentumFrame,GetMomentumMax(),7,kIdsMomentumMAX);
	57	fMomentumMaxValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
	58	fMomentumMaxValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
	59	fMomentumMaxValue->SetButtonToNum(kFALSE);
	60
	61	fMomentumFrame->AddFrame(fMomentumLabel,new TGLayoutHints( kLHintsLeft \| kLHintsCenterY,5,5,2,2));
	62	fMomentumFrame->AddFrame(fMomentumMinValue,new TGLayoutHints( kLHintsLeft ,5,5,2,2));
	63	fMomentumFrame->AddFrame(fMomentumSlider,fMomentumLayout);
	64	fMomentumFrame->AddFrame(fMomentumMaxValue,new TGLayoutHints( kLHintsRight,5,5,2,2));
65	fMomentumFrame->Resize(700,100);
66
67
68	//Rapidity Slider
69	fRapidityFrame = new TGCompositeFrame(fMainFrame,0,0, kHorizontalFrame);
70	fRapidityLayout = new TGLayoutHints( kLHintsLeft \| kLHintsTop \| kLHintsExpandX,5,5,2,2);
71	fRapiditySlider = new TGDoubleHSlider(fRapidityFrame, 400, kDoubleScaleBoth, kIdsRAPIDITY);
72	fRapiditySlider->Connect("PositionChanged()","AliSliderFrame",this,"DoSlider()");
73	fRapiditySlider->Connect("PositionChanged()","AliSliderFrame",this,"DoPositionChanged(Int_t)");
74	fRapiditySlider->Connect("Released()","AliSliderFrame",this,"DoReleased()");
75	SetRapidityRange(-1.5,1.5);
76	fRapiditySlider->SetPosition(-1.5,1.5);
77	fRapidityLabel = new TGLabel(fRapidityFrame,"Rapidity ");
78	fRapidityMinValue = new TGNumberEntry(fRapidityFrame,GetRapidityMin(),7,kIdsRapidityMIN);
79	fRapidityMinValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
80	fRapidityMinValue->SetButtonToNum(kFALSE);
81	fRapidityMinValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
82
83	fRapidityMaxValue = new TGNumberEntry(fRapidityFrame,GetRapidityMax(),7,kIdsRapidityMAX);
84	fRapidityMaxValue->Connect("ValueChanged(Long_t)","AliSliderFrame",this,"DoField(Long_t)");
85	fRapidityMaxValue->SetButtonToNum(kFALSE);
86	fRapidityMaxValue->GetNumberEntry()->Connect("ReturnPressed()","AliSliderFrame",this,"DoField(Long_t)");
87
88	fRapidityFrame->AddFrame(fRapidityLabel,new TGLayoutHints( kLHintsLeft \| kLHintsCenterY,5,5,2,2));
89	fRapidityFrame->AddFrame(fRapidityMinValue,new TGLayoutHints( kLHintsLeft ,5,5,2,2));
90	fRapidityFrame->AddFrame(fRapiditySlider,fRapidityLayout);
91	fRapidityFrame->AddFrame(fRapidityMaxValue,new TGLayoutHints( kLHintsRight ,5,5,2,2));
92	fRapidityFrame->Resize(700,100);
93
94	fMainFrame->AddFrame(fMomentumFrame,fLayout);
95	fMainFrame->AddFrame(fRapidityFrame,fLayout);
96	fMainFrame->MapSubwindows();
97	fMainFrame->MapWindow();
98	fMainFrame->Resize(700,100);
99	LoadFromRC();
100	}
101
102	//_____________________________________________________________
103	AliSliderFrame::~AliSliderFrame(void)
104	{
105	// Destructor
106	delete fLayout;
107	delete fRapidityLayout;
108	delete fMomentumLayout;
109	delete fMomentumMinValue;
110	delete fMomentumMaxValue;
111	delete fMainFrame;
112	delete fRapidityFrame;
113	delete fMomentumFrame;
114	delete fMomentumSlider;
115	delete fRapiditySlider;
116	delete fMomentumLabel;
117	delete fRapidityLabel;
118	delete fRapidityMinValue;
119	delete fRapidityMaxValue;
120	}
121
122	//_____________________________________________________________
123	void AliSliderFrame::CloseWindow(void)
124	{
125	// Deletes this window
126	delete this;
127	}
128
129	//_____________________________________________________________
130	void AliSliderFrame::DoSlider(Int_t /pos/)
131	{
132	// Updates the values in case one moves a slider
133	TGFrame frame = (TGFrame ) gTQSender;
134	TGDoubleSlider * ds = (TGDoubleSlider *) frame;
135	int id = ds->WidgetId();
136	char min[8];
137	char max[8];
138	switch(id){
139	case kIdsMOMENTUM:{
140	//sprintf(buf,"momentum min:%f max:%f",GetMomentumMin(),GetMomentumMax());
141	//printf("\n%s",buf);
142	sprintf(min,"%.4f",GetMomentumMin());
143	sprintf(max,"%.4f",GetMomentumMax());
144	fMomentumMaxValue->SetText(max);
145	fMomentumMinValue->SetText(min);
146	}
147	break;
148	case kIdsRAPIDITY:{
149	sprintf(min,"%.4f",GetRapidityMin());
150	sprintf(max,"%.4f",GetRapidityMax());
151	fRapidityMaxValue->SetText(max);
152	fRapidityMinValue->SetText(min);
153	}
154	break;
155	default:break;
156	}
157	}
158
159	//_____________________________________________________________
160	void AliSliderFrame::DoReleased(Int_t /pos/) const
161	{
162	// Updates the display when the slider is released
163	TGFrame frame = (TGFrame ) gTQSender;
164	TGDoubleSlider * ds = (TGDoubleSlider *) frame;
165	int id = ds->WidgetId();
166	switch(id){
167	case kIdsRAPIDITY:
168	case kIdsMOMENTUM:
169	gAliDisplay2->Update(kmCUTS);
170	break;
171	default: break;
172	}
173	}
174
175	//_____________________________________________________________
176	void AliSliderFrame::DoPositionChanged(Int_t /pos/) const
177	{
178	// Updates the display when a slider has changed
179	if(!gAliDisplay2->GetSliderUpdate()) return;
180	TGFrame frame = (TGFrame ) gTQSender;
181	TGDoubleSlider * ds = (TGDoubleSlider *) frame;
182	int id = ds->WidgetId();
183	switch(id){
184	case kIdsRapidityMIN:
185	case kIdsRapidityMAX:
186	case kIdsMomentumMIN:
187	case kIdsMomentumMAX:{
188	gAliDisplay2->Update(kmCUTS);
189	}
190	break;
191	default: break;
192	}
193	}
194
195	//_____________________________________________________________
196	void AliSliderFrame::DoField(Long_t pos)
197	{
198	// Updates the display in case of changed min/max values for
199	// momentum and/or rapidity
200	TGNumberEntry ne = (TGNumberEntry ) gTQSender;
201	int id = ne->WidgetId();
202	char max[8],min[8];
203	Int_t sign=0;
204	Float_t step=gAliDisplay2->GetSliderStep();
205	if((pos/10000)==0){//Up button pressed
206	sign = 1;
207	}
208	else sign = -1;
209
210	switch(id){
211	case kIdsMomentumMIN:{
212	fMomentumMinValue->SetNumber(fMomentumMinValue->GetNumber()+step*sign);
213	sprintf(min,"%.4f",fMomentumMinValue->GetNumber());
214	fMomentumMinValue->SetText(min);
215	}
216	break;
217	case kIdsMomentumMAX:{
218	fMomentumMaxValue->SetNumber(fMomentumMaxValue->GetNumber()+step*sign);
219	sprintf(max,"%.4f",fMomentumMaxValue->GetNumber());
220	fMomentumMaxValue->SetText(max);
221	}
222	break;
223	case kIdsRapidityMIN:{
224	fRapidityMinValue->SetNumber(fRapidityMinValue->GetNumber()+step*sign);
225	sprintf(min,"%.4f",fRapidityMinValue->GetNumber());
226	fRapidityMinValue->SetText(min);
227	}
228	break;
229	case kIdsRapidityMAX:{
230	fRapidityMaxValue->SetNumber(fRapidityMaxValue->GetNumber()+step*sign);
231	sprintf(max,"%.4f",fRapidityMaxValue->GetNumber());
232	fRapidityMaxValue->SetText(max);
233	}
234	break;
235	default:break;
236	}
237
238	fMomentumSlider->SetPosition(fMomentumMinValue->GetNumber(),fMomentumMaxValue->GetNumber());
239	fRapiditySlider->SetPosition(fRapidityMinValue->GetNumber(),fRapidityMaxValue->GetNumber());
240	// gAliDisplay2->Draw();
241	gAliDisplay2->Update(kmCUTS);
242	}
243
244	//_____________________________________________________________
245	void AliSliderFrame::SaveToRC() const
246	{
247	// Saves settings in the .alidisplayrc file
248	TEnv *rc=new TEnv(".alidisplayrc");
249	rc->SetValue("AliDisplay.MomentumMin",GetMomentumMin());
250	rc->SetValue("AliDisplay.MomentumMax",GetMomentumMax());
251	rc->SetValue("AliDisplay.RapidityMin",GetRapidityMin());
252	rc->SetValue("AliDisplay.RapidityMax",GetRapidityMax());
253	rc->SaveLevel(kEnvLocal);
254	rc->Save();
255	}
256
257	//_____________________________________________________________
258	void AliSliderFrame::LoadFromRC()
259	{
260	// Loads settings from the .alidisplayrc file
261	// and uses the default momentum and rapidity ranges
262	TEnv *rc=new TEnv(".alidisplayrc");
263	Float_t a,b;
264	a=rc->GetValue("AliDisplay.MomentumMin",0);
265	b=rc->GetValue("AliDisplay.MomentumMax",2);
266	fMomentumSlider->SetPosition(a,b);
267	a=rc->GetValue("AliDisplay.RapidityMin",-1.5);
268	b=rc->GetValue("AliDisplay.RapidityMax",1.5);
269	fRapiditySlider->SetPosition(a,b);
270	}
271