[u/mrichter/AliRoot.git] / MUON / AliMUONPainterPlotSelector.cxx

/**************************************************************************
* Copyright(c) 1998-1999, 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.                  *
**************************************************************************/

// $Id$

/// \class AliMUONPainterPlotSelector
/// 
/// Widget to select which data to plot for painters
/// 
/// \author Laurent Aphecetche
///
/// See AliMUONPainterInterfaceHelper for an important implementation note
/// about our use of TGButtonGroup
///

#include "AliMUONPainterPlotSelector.h"

#include "AliMUONPainterGroup.h"
#include "AliMUONPainterInterfaceHelper.h"
#include "AliMUONPainterMatrix.h"
#include "AliMUONPainterRegistry.h"
#include "AliMUONVPainter.h"
#include "AliMUONVTrackerData.h"
#include "AliLog.h"
#include <Riostream.h>
#include <TGButton.h>
#include <TGButtonGroup.h>
#include <TObjArray.h>
#include <TObjString.h>

///\cond CLASSIMP
ClassImp(AliMUONPainterPlotSelector)
///\endcond

const char* AliMUONPainterPlotSelector::fgkDefaultSourceName = "none";  

//_____________________________________________________________________________
AliMUONPainterPlotSelector::AliMUONPainterPlotSelector(const TGWindow* window, UInt_t w, UInt_t h)
: TGCompositeFrame(window,w,h,kHorizontalFrame),
fTypes(0x0),
fDataSourceNames(0x0),
fDataSourceDimensions(0x0),
fDimensionButtonMap(new TMap),
fCurrentType(""),
fCurrentData(0x0),
fCurrentDimension(-1)
{
  /// ctor
  fTypes = new TGButtonGroup(this,"Plot");

  fDataSourceNames = new TGButtonGroup(this,"Sources");
      
  AliMUONPainterRegistry* reg = AliMUONPainterRegistry::Instance();
  
  reg->Connect("DataSourceWasRegistered(AliMUONVTrackerData*)",
               "AliMUONPainterPlotSelector",
               this,
               "DataSourceWasRegistered(AliMUONVTrackerData*)");
  
  reg->Connect("DataSourceWasUnregistered(AliMUONVTrackerData*)",
               "AliMUONPainterPlotSelector",
               this,
               "DataSourceWasUnregistered(AliMUONVTrackerData*)");
    
  AliMUONPainterInterfaceHelper::AddRadioButton(*fDataSourceNames,
                                                fgkDefaultSourceName,
                                                0x0,
                                                kTRUE);
  
  CreateDimensionButtons(fgkDefaultSourceName);
  
  fDataSourceDimensions = new TGButtonGroup(this,0,3,5,0,"Dimensions");
  
  for ( Int_t i = 0; i < reg->NumberOfDataSources(); ++i )
  {
    AliMUONVTrackerData* data = reg->DataSource(i);
    DataSourceWasRegistered(data);
  }
  
  fDataSourceNames->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",
                            this,
                            "SourceButtonWasClicked(Int_t)");

  AddFrame(fTypes);
  AddFrame(fDataSourceNames);
  AddFrame(fDataSourceDimensions);
}

//_____________________________________________________________________________
AliMUONPainterPlotSelector::~AliMUONPainterPlotSelector()
{
  /// dtor
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::BackupDimensionButtons()
{
  /// Backup the dimension button group
  
  TString name = fDataSourceDimensions->GetTitle();

  AliDebug(1,Form("name %s",name.Data()));

  if ( name !=  fgkDefaultSourceName )
  {
    TGButtonGroup* group = static_cast<TGButtonGroup*>(fDimensionButtonMap->GetValue(name));
    if (!group) 
    {
      AliError(Form("Did not find group %s",name.Data()));
    }
    else
    {
      AliMUONPainterInterfaceHelper::Copy(*fDataSourceDimensions,*group);
    }
  
  }
  
  fDataSourceDimensions->Disconnect("Clicked(Int_t)",
                                    this,
                                    "DimensionButtonWasClicked(Int_t)");  
}


//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::CreateDimensionButtons(const char* dataSourceName)
{
  /// Create the dimension button group for a given data source
  
  AliDebug(1,Form("Creating dimension buttons for dataSource %s",dataSourceName));
  
  AliMUONVTrackerData* data = AliMUONPainterRegistry::Instance()->DataSource(dataSourceName);

  TGButtonGroup* bg = new TGButtonGroup(this,0,3,5,0,dataSourceName);
  
  if ( data ) 
  {
    for ( Int_t i = 0; i < data->NumberOfDimensions(); ++i ) 
    {
      AliMUONPainterInterfaceHelper::AddRadioButton(*bg,
                                                    data->DimensionName(i),
                                                    reinterpret_cast<void*>(i));
    }
  }
  
  fDimensionButtonMap->Add(new TObjString(dataSourceName),bg);
  
  AliDebug(1,Form("bg is %p Count=%d",bg,bg->GetCount()));
  StdoutToAliDebug(1,AliMUONPainterInterfaceHelper::Dump(*bg));
  
  bg->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",this,
                                "DimensionButtonWasClicked(Int_t)");
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::CreateTypeButtons(const TObjArray& types)
{
  /// Create the type button group
  
  AliMUONPainterInterfaceHelper::ClearButtons(*fTypes);

  TIter nextType(&types);
  TObjString* str;

  while ( ( str = static_cast<TObjString*>(nextType()) ) )
  {
    AliMUONPainterInterfaceHelper::AddRadioButton(*fTypes,str->String());
  }

  fTypes->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",this,
                  "TypeButtonWasClicked(Int_t)");
  
  fTypes->Show();
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::DataSourceWasChanged()
{
  /// Data source was changed
  DataSourceWasChanged(fCurrentType.Data(),fCurrentData,fCurrentDimension);
}

//_____________________________________________________________________________
void 
AliMUONPainterPlotSelector::DataSourceWasChanged(const char* type, 
                                                 AliMUONVTrackerData* data,
                                                 Int_t dataIndex)
{
  /// Emit a signal to tell data source was changed
  AliDebug(1,Form("type=%s data=%s (%s)",
                  type,
                  ( data ? data->GetName() : "" ),
                  ( ( data && dataIndex >= 0 ) ? data->DimensionName(dataIndex).Data() :
                    "")));
  
	UpdateTypeButton();
	
  Long_t param[] = { (Long_t)type, (Long_t)data,
    (Long_t)dataIndex };
  
  Emit("DataSourceWasChanged(const char*,AliMUONVTrackerData*,Int_t)",param);
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::DataSourceWasRegistered(AliMUONVTrackerData* data)
{
  /// A new data source has been registered : add it to the interface
  
  AliDebug(1,Form("Registering %s",data->GetName()));
  
  AliMUONPainterInterfaceHelper::AddRadioButton(*fDataSourceNames,
                                                data->GetName(),
                                                data);
  
  data->Connect("NumberOfEventsChanged()",
                "AliMUONPainterPlotSelector",
                this,
                "NumberOfEventsChanged()");
  
  CreateDimensionButtons(data->GetName());
  
  fDataSourceNames->Show();
  
  Layout();
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::NumberOfEventsChanged()
{
  /// Change the tool tip of the corresponding data source button

  // find first the sender of the signal
  
//  AliMUONVTrackerData* data = reinterpret_cast<AliMUONVTrackerData*>(gTQSender);
//  
//  TGButton* button = AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceNames,data);
//  
//  if (button)
//  {
//    button->SetToolTipText(Form("%d events",data->NumberOfEvents()),250);
//  }
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::DataSourceWasUnregistered(AliMUONVTrackerData* data)
{
  /// A data source has been unregistered : remove it from the interface
  
  TGButton* button = AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceNames,data);

  TGButton* bd = AliMUONPainterInterfaceHelper::FindDownButton(*fDataSourceNames);

  if ( bd == button ) 
  {
    // selected data source is the one we are removing...
    // revert to "none" before actually removing it.
    SourceButtonWasClicked(1);
  }
  
  AliMUONPainterInterfaceHelper::RemoveButton(*fDataSourceNames,button);

  // do not forget to re-connect things
  fDataSourceNames->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",
                            this,
                            "SourceButtonWasClicked(Int_t)");
  

  TObject* o = fDimensionButtonMap->Remove(new TObjString(data->GetName()));
  
  if (!o)
  {
    AliError("Remove failed. Please check");    
  }

  fDataSourceNames->Show();
  
  Layout();
}

//_____________________________________________________________________________
void 
AliMUONPainterPlotSelector::DimensionButtonWasClicked(Int_t id)
{
  /// One dim button was clicked
  
  AliDebug(1,Form("id=%d",id));
  
  TGTextButton* button = (TGTextButton*)fDataSourceDimensions->GetButton(id);
  
  SetCurrentDimension(reinterpret_cast<Long_t>(button->GetUserData()));
  
  if ( fCurrentDimension >= 0 )
  {
    AliMUONPainterInterfaceHelper::SetState(*fTypes,kTRUE);
    AliMUONPainterInterfaceHelper::Select(*fTypes,fCurrentType.Data(),kFALSE);
    fTypes->Show();
  }
  
  AliDebug(1,Form("fCurrentDimension=%ld fCurrentData=%p fCurrentType=%s",
                  fCurrentDimension,fCurrentData,fCurrentType.Data()));
  
  DataSourceWasChanged();
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::ResetDimensionButtonMap()
{
  /// Reset the button group map
  
  TIter next(fDimensionButtonMap);
  TObjString* str;
  
  while ( ( str = static_cast<TObjString*>(next()) ) )
  {
    TGButtonGroup* bg = static_cast<TGButtonGroup*>(fDimensionButtonMap->GetValue(str->String()));
    AliMUONPainterInterfaceHelper::Unselect(*bg,"*");
  }
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::RestoreDimensionButtons(const char* dataSourceName,
                                                    Bool_t updateCurrentDimension)
{
  /// Restore (i.e. contrary of Backup) a given dimension button group
  
  AliDebug(1,Form("name %s",dataSourceName));
  TGButtonGroup* group = static_cast<TGButtonGroup*>(fDimensionButtonMap->GetValue(dataSourceName));
  
  AliMUONPainterInterfaceHelper::Copy(*group,*fDataSourceDimensions);
  
  fDataSourceDimensions->Connect("Clicked(Int_t)",
                                 "AliMUONPainterPlotSelector",this,
                                 "DimensionButtonWasClicked(Int_t)");    
  
  if ( updateCurrentDimension ) 
  {
    TGButton* button = AliMUONPainterInterfaceHelper::FindDownButton(*fDataSourceDimensions);
    if ( button ) 
    {
      SetCurrentDimension(reinterpret_cast<Long_t>(button->GetUserData()));
    }
    else 
    {
      SetCurrentDimension(-1);
    }
  }
  
  fDataSourceDimensions->Show();
}

//_____________________________________________________________________________
void 
AliMUONPainterPlotSelector::SetCurrentData(AliMUONVTrackerData* data)
{
  /// Set the current data pointer
  AliDebug(1,Form("fCurrentData %p -> %p",fCurrentData,data));
  fCurrentData = data;
}

//_____________________________________________________________________________
void 
AliMUONPainterPlotSelector::SetCurrentDimension(Long_t i)
{
  /// Set the current dimension
  AliDebug(1,Form("fCurrentDimension %ld -> %ld",fCurrentDimension,i));
  fCurrentDimension = i;
}

//_____________________________________________________________________________
void 
AliMUONPainterPlotSelector::SetCurrentType(const char* type)
{
  /// Set the current type
  AliDebug(1,Form("fCurrentType %s -> %s",fCurrentType.Data(),type));
  fCurrentType = type;
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::SourceButtonWasClicked(Int_t id)
{
  /// A source button was clicked
  AliDebug(1,Form("BEGIN id %d fCurrentDimension=%ld fCurrentData=%p fCurrentType=%s",
                  id,
                  fCurrentDimension,fCurrentData,fCurrentType.Data()));

  BackupDimensionButtons();
  
  TGButton* button = fDataSourceNames->GetButton(id);
  if ( !button ) 
  {
    AliError(Form("Could not get DataSource button id=%d",id));
    StdoutToAliDebug(1,AliMUONPainterInterfaceHelper::Dump(*fDataSourceNames));
    button->GetUserData(); // to trigger a crash so gdb is possible ;-)
  }
  
  AliMUONVTrackerData* data = reinterpret_cast<AliMUONVTrackerData*>(button->GetUserData());

  TString name =  data ? data->GetName() : fgkDefaultSourceName;

  RestoreDimensionButtons(name,kTRUE);
  
  if ( data != 0 && 
       fCurrentDimension >= 0 && 
       fCurrentDimension < (Long_t)(data->NumberOfDimensions()) )
  {
    AliMUONPainterInterfaceHelper::SetState(*fTypes,kTRUE);
  }
  else
  {
    AliMUONPainterInterfaceHelper::SetState(*fTypes,kFALSE);
  }
  
  SetCurrentData(data);
  
  UpdateTypeButton();
  
  fDataSourceNames->Show();
  fDataSourceDimensions->Show();
  fTypes->Show();
  
  Resize();
  Layout();
  
  AliDebug(1,Form("END fCurrentDimension=%ld fCurrentData=%p fCurrentType=%s",
                  fCurrentDimension,fCurrentData,fCurrentType.Data()));

  DataSourceWasChanged();
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::TypeButtonWasClicked(Int_t id)
{
  /// A type button was clicked
  AliDebug(1,Form("fCurrentDimension=%ld fCurrentData=%p",
                  fCurrentDimension,fCurrentData));

  TGTextButton* button = (TGTextButton*)fTypes->GetButton(id);
  SetCurrentType(button->GetTitle());
  
  AliDebug(1,Form("fCurrentType=%s",fCurrentType.Data()));
  
  DataSourceWasChanged();
}

//_____________________________________________________________________________
void AliMUONPainterPlotSelector::Update(const AliMUONPainterMatrix& painterMatrix)
{
  /// Update ourselves from a new painter matrix
  
  AliDebug(1,"BEGIN");

  SetCurrentType("");
  SetCurrentData(0x0);
  SetCurrentDimension(-1);
  
  AliMUONPainterInterfaceHelper::Unselect(*fDataSourceNames,"*");
  AliMUONPainterInterfaceHelper::Unselect(*fDataSourceDimensions,"*");
  
  ResetDimensionButtonMap();
  
  TObjArray types;
  types.SetOwner(kTRUE);  
  painterMatrix.GetTypes(types);  
  CreateTypeButtons(types);
  
  if ( painterMatrix.Size() > 0 ) 
  {
    AliMUONVPainter* painter = painterMatrix.Painter(painterMatrix.Size()-1);
    
    AliMUONPainterGroup* plotterGroup = painter->PlotterGroup();
    
    if ( plotterGroup )
    {
      // the group have some data to plot, so update our internal pointers
      // to reflect that
      SetCurrentData(plotterGroup->Data());
      SetCurrentDimension(plotterGroup->DataIndex());
      SetCurrentType(plotterGroup->Type());
    }
  }
  
  AliDebug(1,Form("After update type=%s data=%p dim=%ld",
                  fCurrentType.Data(),fCurrentData,fCurrentDimension));

  // the *order* of the 3 following lines is *very* important

  AliDebug(1,"Will update source buttons");
  UpdateSourceButton();
  AliDebug(1,"Will update dimension buttons");
  UpdateDimensionButton();
  AliDebug(1,"Will update type buttons");
  UpdateTypeButton();
  
  Resize();
  Layout();
  
  AliDebug(1,Form("END fCurrentType=%s fCurrentData=%p fCurrentDimension=%ld",
                  fCurrentType.Data(),fCurrentData,
                  fCurrentDimension));
}

//_____________________________________________________________________________
void 
AliMUONPainterPlotSelector::UpdateDimensionButton()
{
  /// Update the dim buttons
  
  TGTextButton* button = static_cast<TGTextButton*>
  (AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceDimensions,
                                                       reinterpret_cast<void*>(fCurrentDimension)));
  
  if ( button ) 
  {
    // set this button as "ON"
    AliMUONPainterInterfaceHelper::Select(*fDataSourceDimensions,button->GetTitle());
  }
  else
  {
    AliMUONPainterInterfaceHelper::Unselect(*fDataSourceDimensions,"*");
  }
  
  fDataSourceDimensions->Show();
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::UpdateSourceButton()
{
  /// Update the source buttons
  
  TGTextButton* button = static_cast<TGTextButton*>
  (AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceNames,
                                                       fCurrentData));
  
  if ( button ) 
  {
    AliMUONPainterInterfaceHelper::Select(*fDataSourceNames,button->GetTitle());
  
    RestoreDimensionButtons(button->GetTitle(),kFALSE);
  }
  
  fDataSourceNames->Show();
}

//_____________________________________________________________________________
void
AliMUONPainterPlotSelector::UpdateTypeButton()
{
  /// Update the type buttons
	
  AliDebug(1,Form("fCurrentType=%s",fCurrentType.Data()));
  
	if (!fCurrentData)
  {
    AliMUONPainterInterfaceHelper::SetState(*fTypes,kFALSE);
  }
	else
	{
		// disable levels that cannot be handled by this data
		TGTextButton* padButton = static_cast<TGTextButton*>
		(AliMUONPainterInterfaceHelper::FindButtonByName(*fTypes,"PAD"));
		if (padButton) 
		{ 
			padButton->SetEnabled(fCurrentData->IsChannelLevelEnabled());
		}
		TGTextButton* manuButton = static_cast<TGTextButton*>
		(AliMUONPainterInterfaceHelper::FindButtonByName(*fTypes,"MANU"));
		if (manuButton) 
		{ 
			manuButton->SetEnabled(fCurrentData->IsManuLevelEnabled());
		}
    
	}
	
  TGTextButton* button = static_cast<TGTextButton*>
  (AliMUONPainterInterfaceHelper::FindButtonByName(*fTypes,fCurrentType));

  if ( button ) 
  {
    AliMUONPainterInterfaceHelper::Select(*fTypes,button->GetTitle());
  }
  else
  {
    AliMUONPainterInterfaceHelper::Unselect(*fTypes,"*");
  }

	
  fTypes->Show();
}
Commit	Line	Data
0145e89a	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	// $Id$
	17
	18	/// \class AliMUONPainterPlotSelector
	19	///
	20	/// Widget to select which data to plot for painters
	21	///
	22	/// \author Laurent Aphecetche
	23	///
	24	/// See AliMUONPainterInterfaceHelper for an important implementation note
	25	/// about our use of TGButtonGroup
	26	///
	27
	28	#include "AliMUONPainterPlotSelector.h"
	29
	30	#include "AliMUONPainterGroup.h"
	31	#include "AliMUONPainterInterfaceHelper.h"
	32	#include "AliMUONPainterMatrix.h"
	33	#include "AliMUONPainterRegistry.h"
	34	#include "AliMUONVPainter.h"
	35	#include "AliMUONVTrackerData.h"
	36	#include "AliLog.h"
	37	#include <Riostream.h>
	38	#include <TGButton.h>
	39	#include <TGButtonGroup.h>
	40	#include <TObjArray.h>
	41	#include <TObjString.h>
	42
	43	///\cond CLASSIMP
	44	ClassImp(AliMUONPainterPlotSelector)
	45	///\endcond
	46
	47	const char* AliMUONPainterPlotSelector::fgkDefaultSourceName = "none";
	48
	49	//_____________________________________________________________________________
	50	AliMUONPainterPlotSelector::AliMUONPainterPlotSelector(const TGWindow* window, UInt_t w, UInt_t h)
	51	: TGCompositeFrame(window,w,h,kHorizontalFrame),
	52	fTypes(0x0),
	53	fDataSourceNames(0x0),
	54	fDataSourceDimensions(0x0),
	55	fDimensionButtonMap(new TMap),
	56	fCurrentType(""),
	57	fCurrentData(0x0),
	58	fCurrentDimension(-1)
	59	{
	60	/// ctor
	61	fTypes = new TGButtonGroup(this,"Plot");
	62
	63	fDataSourceNames = new TGButtonGroup(this,"Sources");
	64
65	AliMUONPainterRegistry* reg = AliMUONPainterRegistry::Instance();
66
67	reg->Connect("DataSourceWasRegistered(AliMUONVTrackerData*)",
68	"AliMUONPainterPlotSelector",
69	this,
70	"DataSourceWasRegistered(AliMUONVTrackerData*)");
71
72	reg->Connect("DataSourceWasUnregistered(AliMUONVTrackerData*)",
73	"AliMUONPainterPlotSelector",
74	this,
75	"DataSourceWasUnregistered(AliMUONVTrackerData*)");
76
77	AliMUONPainterInterfaceHelper::AddRadioButton(*fDataSourceNames,
78	fgkDefaultSourceName,
79	0x0,
80	kTRUE);
81
82	CreateDimensionButtons(fgkDefaultSourceName);
83
84	fDataSourceDimensions = new TGButtonGroup(this,0,3,5,0,"Dimensions");
85
86	for ( Int_t i = 0; i < reg->NumberOfDataSources(); ++i )
87	{
88	AliMUONVTrackerData* data = reg->DataSource(i);
89	DataSourceWasRegistered(data);
90	}
91
92	fDataSourceNames->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",
93	this,
94	"SourceButtonWasClicked(Int_t)");
95
96	AddFrame(fTypes);
97	AddFrame(fDataSourceNames);
98	AddFrame(fDataSourceDimensions);
99	}
100
101	//_____________________________________________________________________________
102	AliMUONPainterPlotSelector::~AliMUONPainterPlotSelector()
103	{
104	/// dtor
105	}
106
107	//_____________________________________________________________________________
108	void
109	AliMUONPainterPlotSelector::BackupDimensionButtons()
110	{
111	/// Backup the dimension button group
112
113	TString name = fDataSourceDimensions->GetTitle();
114
115	AliDebug(1,Form("name %s",name.Data()));
116
117	if ( name != fgkDefaultSourceName )
118	{
119	TGButtonGroup* group = static_cast<TGButtonGroup*>(fDimensionButtonMap->GetValue(name));
120	if (!group)
121	{
122	AliError(Form("Did not find group %s",name.Data()));
123	}
124	else
125	{
126	AliMUONPainterInterfaceHelper::Copy(fDataSourceDimensions,group);
127	}
128
129	}
130
131	fDataSourceDimensions->Disconnect("Clicked(Int_t)",
132	this,
133	"DimensionButtonWasClicked(Int_t)");
134	}
135
136
137	//_____________________________________________________________________________
138	void
139	AliMUONPainterPlotSelector::CreateDimensionButtons(const char* dataSourceName)
140	{
141	/// Create the dimension button group for a given data source
142
143	AliDebug(1,Form("Creating dimension buttons for dataSource %s",dataSourceName));
144
49419555	145	AliMUONVTrackerData* data = AliMUONPainterRegistry::Instance()->DataSource(dataSourceName);
0145e89a	146
	147	TGButtonGroup* bg = new TGButtonGroup(this,0,3,5,0,dataSourceName);
	148
	149	if ( data )
	150	{
	151	for ( Int_t i = 0; i < data->NumberOfDimensions(); ++i )
	152	{
	153	AliMUONPainterInterfaceHelper::AddRadioButton(*bg,
	154	data->DimensionName(i),
	155	reinterpret_cast<void*>(i));
	156	}
	157	}
	158
	159	fDimensionButtonMap->Add(new TObjString(dataSourceName),bg);
	160
	161	AliDebug(1,Form("bg is %p Count=%d",bg,bg->GetCount()));
	162	StdoutToAliDebug(1,AliMUONPainterInterfaceHelper::Dump(*bg));
	163
	164	bg->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",this,
	165	"DimensionButtonWasClicked(Int_t)");
	166	}
	167
	168	//_____________________________________________________________________________
	169	void
	170	AliMUONPainterPlotSelector::CreateTypeButtons(const TObjArray& types)
	171	{
	172	/// Create the type button group
	173
	174	AliMUONPainterInterfaceHelper::ClearButtons(*fTypes);
	175
	176	TIter nextType(&types);
	177	TObjString* str;
	178
	179	while ( ( str = static_cast<TObjString*>(nextType()) ) )
	180	{
	181	AliMUONPainterInterfaceHelper::AddRadioButton(*fTypes,str->String());
	182	}
	183
	184	fTypes->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",this,
	185	"TypeButtonWasClicked(Int_t)");
	186
	187	fTypes->Show();
	188	}
	189
	190	//_____________________________________________________________________________
	191	void
	192	AliMUONPainterPlotSelector::DataSourceWasChanged()
	193	{
	194	/// Data source was changed
	195	DataSourceWasChanged(fCurrentType.Data(),fCurrentData,fCurrentDimension);
	196	}
	197
	198	//_____________________________________________________________________________
	199	void
	200	AliMUONPainterPlotSelector::DataSourceWasChanged(const char* type,
	201	AliMUONVTrackerData* data,
	202	Int_t dataIndex)
	203	{
	204	/// Emit a signal to tell data source was changed
	205	AliDebug(1,Form("type=%s data=%s (%s)",
	206	type,
	207	( data ? data->GetName() : "" ),
	208	( ( data && dataIndex >= 0 ) ? data->DimensionName(dataIndex).Data() :
	209	"")));
210
ede0d590	211	UpdateTypeButton();
ede0d590	212
0145e89a	213	Long_t param[] = { (Long_t)type, (Long_t)data,
	214	(Long_t)dataIndex };
	215
	216	Emit("DataSourceWasChanged(const char,AliMUONVTrackerData,Int_t)",param);
	217	}
	218
	219	//_____________________________________________________________________________
	220	void
	221	AliMUONPainterPlotSelector::DataSourceWasRegistered(AliMUONVTrackerData* data)
	222	{
	223	/// A new data source has been registered : add it to the interface
	224
	225	AliDebug(1,Form("Registering %s",data->GetName()));
	226
	227	AliMUONPainterInterfaceHelper::AddRadioButton(*fDataSourceNames,
	228	data->GetName(),
	229	data);
	230
	231	data->Connect("NumberOfEventsChanged()",
	232	"AliMUONPainterPlotSelector",
	233	this,
	234	"NumberOfEventsChanged()");
	235
	236	CreateDimensionButtons(data->GetName());
	237
	238	fDataSourceNames->Show();
	239
	240	Layout();
	241	}
	242
	243	//_____________________________________________________________________________
	244	void
	245	AliMUONPainterPlotSelector::NumberOfEventsChanged()
	246	{
	247	/// Change the tool tip of the corresponding data source button
	248
	249	// find first the sender of the signal
	250
49419555	251	// AliMUONVTrackerData* data = reinterpret_cast<AliMUONVTrackerData*>(gTQSender);
	252	//
	253	// TGButton* button = AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceNames,data);
	254	//
	255	// if (button)
	256	// {
	257	// button->SetToolTipText(Form("%d events",data->NumberOfEvents()),250);
	258	// }
0145e89a	259	}
	260
	261	//_____________________________________________________________________________
	262	void
	263	AliMUONPainterPlotSelector::DataSourceWasUnregistered(AliMUONVTrackerData* data)
	264	{
	265	/// A data source has been unregistered : remove it from the interface
	266
49419555	267	TGButton* button = AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceNames,data);
0145e89a	268
49419555	269	TGButton* bd = AliMUONPainterInterfaceHelper::FindDownButton(*fDataSourceNames);
	270
	271	if ( bd == button )
0145e89a	272	{
49419555	273	// selected data source is the one we are removing...
	274	// revert to "none" before actually removing it.
	275	SourceButtonWasClicked(1);
0145e89a	276	}
0145e89a	277
49419555	278	AliMUONPainterInterfaceHelper::RemoveButton(*fDataSourceNames,button);
	279
	280	// do not forget to re-connect things
	281	fDataSourceNames->Connect("Clicked(Int_t)","AliMUONPainterPlotSelector",
	282	this,
	283	"SourceButtonWasClicked(Int_t)");
0145e89a	284
49419555	285
0145e89a	286	TObject* o = fDimensionButtonMap->Remove(new TObjString(data->GetName()));
	287
	288	if (!o)
	289	{
	290	AliError("Remove failed. Please check");
	291	}
49419555	292
49419555	293	fDataSourceNames->Show();
0145e89a	294
	295	Layout();
	296	}
	297
	298	//_____________________________________________________________________________
	299	void
	300	AliMUONPainterPlotSelector::DimensionButtonWasClicked(Int_t id)
	301	{
	302	/// One dim button was clicked
	303
	304	AliDebug(1,Form("id=%d",id));
	305
	306	TGTextButton* button = (TGTextButton*)fDataSourceDimensions->GetButton(id);
	307
c9756e69	308	SetCurrentDimension(reinterpret_cast<Long_t>(button->GetUserData()));
0145e89a	309
	310	if ( fCurrentDimension >= 0 )
	311	{
	312	AliMUONPainterInterfaceHelper::SetState(*fTypes,kTRUE);
	313	AliMUONPainterInterfaceHelper::Select(*fTypes,fCurrentType.Data(),kFALSE);
	314	fTypes->Show();
	315	}
	316
c9756e69	317	AliDebug(1,Form("fCurrentDimension=%ld fCurrentData=%p fCurrentType=%s",
0145e89a	318	fCurrentDimension,fCurrentData,fCurrentType.Data()));
	319
	320	DataSourceWasChanged();
	321	}
	322
	323	//_____________________________________________________________________________
	324	void
	325	AliMUONPainterPlotSelector::ResetDimensionButtonMap()
	326	{
	327	/// Reset the button group map
	328
	329	TIter next(fDimensionButtonMap);
	330	TObjString* str;
	331
	332	while ( ( str = static_cast<TObjString*>(next()) ) )
	333	{
	334	TGButtonGroup* bg = static_cast<TGButtonGroup*>(fDimensionButtonMap->GetValue(str->String()));
	335	AliMUONPainterInterfaceHelper::Unselect(bg,"");
	336	}
	337	}
	338
	339	//_____________________________________________________________________________
	340	void
	341	AliMUONPainterPlotSelector::RestoreDimensionButtons(const char* dataSourceName,
	342	Bool_t updateCurrentDimension)
	343	{
	344	/// Restore (i.e. contrary of Backup) a given dimension button group
	345
	346	AliDebug(1,Form("name %s",dataSourceName));
	347	TGButtonGroup* group = static_cast<TGButtonGroup*>(fDimensionButtonMap->GetValue(dataSourceName));
	348
	349	AliMUONPainterInterfaceHelper::Copy(group,fDataSourceDimensions);
	350
	351	fDataSourceDimensions->Connect("Clicked(Int_t)",
	352	"AliMUONPainterPlotSelector",this,
	353	"DimensionButtonWasClicked(Int_t)");
	354
	355	if ( updateCurrentDimension )
	356	{
	357	TGButton* button = AliMUONPainterInterfaceHelper::FindDownButton(*fDataSourceDimensions);
	358	if ( button )
	359	{
c9756e69	360	SetCurrentDimension(reinterpret_cast<Long_t>(button->GetUserData()));
0145e89a	361	}
	362	else
	363	{
	364	SetCurrentDimension(-1);
	365	}
	366	}
	367
	368	fDataSourceDimensions->Show();
	369	}
	370
	371	//_____________________________________________________________________________
	372	void
	373	AliMUONPainterPlotSelector::SetCurrentData(AliMUONVTrackerData* data)
	374	{
	375	/// Set the current data pointer
	376	AliDebug(1,Form("fCurrentData %p -> %p",fCurrentData,data));
	377	fCurrentData = data;
	378	}
	379
	380	//_____________________________________________________________________________
	381	void
c9756e69	382	AliMUONPainterPlotSelector::SetCurrentDimension(Long_t i)
0145e89a	383	{
0145e89a	384	/// Set the current dimension
c9756e69	385	AliDebug(1,Form("fCurrentDimension %ld -> %ld",fCurrentDimension,i));
0145e89a	386	fCurrentDimension = i;
	387	}
	388
	389	//_____________________________________________________________________________
	390	void
	391	AliMUONPainterPlotSelector::SetCurrentType(const char* type)
	392	{
	393	/// Set the current type
	394	AliDebug(1,Form("fCurrentType %s -> %s",fCurrentType.Data(),type));
	395	fCurrentType = type;
	396	}
	397
	398	//_____________________________________________________________________________
	399	void
	400	AliMUONPainterPlotSelector::SourceButtonWasClicked(Int_t id)
	401	{
	402	/// A source button was clicked
c9756e69	403	AliDebug(1,Form("BEGIN id %d fCurrentDimension=%ld fCurrentData=%p fCurrentType=%s",
0145e89a	404	id,
	405	fCurrentDimension,fCurrentData,fCurrentType.Data()));
	406
	407	BackupDimensionButtons();
	408
	409	TGButton* button = fDataSourceNames->GetButton(id);
	410	if ( !button )
	411	{
	412	AliError(Form("Could not get DataSource button id=%d",id));
	413	StdoutToAliDebug(1,AliMUONPainterInterfaceHelper::Dump(*fDataSourceNames));
	414	button->GetUserData(); // to trigger a crash so gdb is possible ;-)
	415	}
	416
	417	AliMUONVTrackerData* data = reinterpret_cast<AliMUONVTrackerData*>(button->GetUserData());
	418
	419	TString name = data ? data->GetName() : fgkDefaultSourceName;
	420
	421	RestoreDimensionButtons(name,kTRUE);
	422
	423	if ( data != 0 &&
	424	fCurrentDimension >= 0 &&
c9756e69	425	fCurrentDimension < (Long_t)(data->NumberOfDimensions()) )
0145e89a	426	{
	427	AliMUONPainterInterfaceHelper::SetState(*fTypes,kTRUE);
	428	}
	429	else
	430	{
	431	AliMUONPainterInterfaceHelper::SetState(*fTypes,kFALSE);
	432	}
	433
	434	SetCurrentData(data);
	435
	436	UpdateTypeButton();
	437
	438	fDataSourceNames->Show();
	439	fDataSourceDimensions->Show();
	440	fTypes->Show();
	441
	442	Resize();
	443	Layout();
	444
c9756e69	445	AliDebug(1,Form("END fCurrentDimension=%ld fCurrentData=%p fCurrentType=%s",
0145e89a	446	fCurrentDimension,fCurrentData,fCurrentType.Data()));
	447
	448	DataSourceWasChanged();
	449	}
	450
	451	//_____________________________________________________________________________
	452	void
	453	AliMUONPainterPlotSelector::TypeButtonWasClicked(Int_t id)
	454	{
	455	/// A type button was clicked
c9756e69	456	AliDebug(1,Form("fCurrentDimension=%ld fCurrentData=%p",
0145e89a	457	fCurrentDimension,fCurrentData));
	458
	459	TGTextButton* button = (TGTextButton*)fTypes->GetButton(id);
	460	SetCurrentType(button->GetTitle());
	461
	462	AliDebug(1,Form("fCurrentType=%s",fCurrentType.Data()));
	463
	464	DataSourceWasChanged();
	465	}
	466
	467	//_____________________________________________________________________________
	468	void AliMUONPainterPlotSelector::Update(const AliMUONPainterMatrix& painterMatrix)
	469	{
	470	/// Update ourselves from a new painter matrix
	471
	472	AliDebug(1,"BEGIN");
	473
	474	SetCurrentType("");
	475	SetCurrentData(0x0);
	476	SetCurrentDimension(-1);
	477
	478	AliMUONPainterInterfaceHelper::Unselect(fDataSourceNames,"");
	479	AliMUONPainterInterfaceHelper::Unselect(fDataSourceDimensions,"");
	480
	481	ResetDimensionButtonMap();
	482
	483	TObjArray types;
	484	types.SetOwner(kTRUE);
	485	painterMatrix.GetTypes(types);
	486	CreateTypeButtons(types);
	487
	488	if ( painterMatrix.Size() > 0 )
	489	{
	490	AliMUONVPainter* painter = painterMatrix.Painter(painterMatrix.Size()-1);
	491
	492	AliMUONPainterGroup* plotterGroup = painter->PlotterGroup();
	493
	494	if ( plotterGroup )
	495	{
	496	// the group have some data to plot, so update our internal pointers
	497	// to reflect that
	498	SetCurrentData(plotterGroup->Data());
	499	SetCurrentDimension(plotterGroup->DataIndex());
	500	SetCurrentType(plotterGroup->Type());
	501	}
	502	}
	503
c9756e69	504	AliDebug(1,Form("After update type=%s data=%p dim=%ld",
0145e89a	505	fCurrentType.Data(),fCurrentData,fCurrentDimension));
	506
	507	// the order of the 3 following lines is very important
	508
	509	AliDebug(1,"Will update source buttons");
	510	UpdateSourceButton();
	511	AliDebug(1,"Will update dimension buttons");
	512	UpdateDimensionButton();
	513	AliDebug(1,"Will update type buttons");
	514	UpdateTypeButton();
	515
	516	Resize();
	517	Layout();
	518
c9756e69	519	AliDebug(1,Form("END fCurrentType=%s fCurrentData=%p fCurrentDimension=%ld",
0145e89a	520	fCurrentType.Data(),fCurrentData,
	521	fCurrentDimension));
	522	}
	523
	524	//_____________________________________________________________________________
	525	void
	526	AliMUONPainterPlotSelector::UpdateDimensionButton()
	527	{
	528	/// Update the dim buttons
	529
	530	TGTextButton* button = static_cast<TGTextButton*>
	531	(AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceDimensions,
	532	reinterpret_cast<void*>(fCurrentDimension)));
	533
	534	if ( button )
	535	{
	536	// set this button as "ON"
	537	AliMUONPainterInterfaceHelper::Select(*fDataSourceDimensions,button->GetTitle());
	538	}
	539	else
	540	{
	541	AliMUONPainterInterfaceHelper::Unselect(fDataSourceDimensions,"");
	542	}
	543
	544	fDataSourceDimensions->Show();
	545	}
	546
	547	//_____________________________________________________________________________
	548	void
	549	AliMUONPainterPlotSelector::UpdateSourceButton()
	550	{
	551	/// Update the source buttons
	552
	553	TGTextButton* button = static_cast<TGTextButton*>
	554	(AliMUONPainterInterfaceHelper::FindButtonByUserData(*fDataSourceNames,
	555	fCurrentData));
	556
1ffbeb9d	557	if ( button )
	558	{
	559	AliMUONPainterInterfaceHelper::Select(*fDataSourceNames,button->GetTitle());
0145e89a	560
1ffbeb9d	561	RestoreDimensionButtons(button->GetTitle(),kFALSE);
1ffbeb9d	562	}
0145e89a	563
	564	fDataSourceNames->Show();
	565	}
	566
	567	//_____________________________________________________________________________
	568	void
	569	AliMUONPainterPlotSelector::UpdateTypeButton()
	570	{
	571	/// Update the type buttons
ede0d590	572
0145e89a	573	AliDebug(1,Form("fCurrentType=%s",fCurrentType.Data()));
0145e89a	574
ede0d590	575	if (!fCurrentData)
	576	{
	577	AliMUONPainterInterfaceHelper::SetState(*fTypes,kFALSE);
	578	}
	579	else
	580	{
	581	// disable levels that cannot be handled by this data
	582	TGTextButton* padButton = static_cast<TGTextButton*>
	583	(AliMUONPainterInterfaceHelper::FindButtonByName(*fTypes,"PAD"));
	584	if (padButton)
	585	{
	586	padButton->SetEnabled(fCurrentData->IsChannelLevelEnabled());
	587	}
0edb62c4	588	TGTextButton* manuButton = static_cast<TGTextButton*>
	589	(AliMUONPainterInterfaceHelper::FindButtonByName(*fTypes,"MANU"));
	590	if (manuButton)
	591	{
	592	manuButton->SetEnabled(fCurrentData->IsManuLevelEnabled());
	593	}
	594
ede0d590	595	}
ede0d590	596
0145e89a	597	TGTextButton* button = static_cast<TGTextButton*>
	598	(AliMUONPainterInterfaceHelper::FindButtonByName(*fTypes,fCurrentType));
	599
	600	if ( button )
	601	{
	602	AliMUONPainterInterfaceHelper::Select(*fTypes,button->GetTitle());
	603	}
	604	else
	605	{
	606	AliMUONPainterInterfaceHelper::Unselect(fTypes,"");
	607	}
	608
ede0d590	609
0145e89a	610	fTypes->Show();
	611	}
	612