[u/mrichter/AliRoot.git] / MUON / AliMUONPainterMasterFrame.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$

#include "AliMUONPainterMasterFrame.h"

#include "AliMUONChamberPainter.h"
#include "AliMUONPainterGroup.h"
#include "AliMUONPainterMatrix.h"
#include "AliMUONPainterMatrixFrame.h"
#include "AliMUONPainterInterfaceHelper.h"
#include "AliMUONPainterRegistry.h"
#include "AliMUONAttPainterSelectorFrame.h"
#include "AliMUONVPainter.h"
#include "AliCodeTimer.h"
#include "AliLog.h"
#include <Riostream.h>
#include <TApplication.h>
#include <TCanvas.h>
#include <TEnv.h>
#include <TGComboBox.h>
#include <TGLabel.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TGButtonGroup.h>
#include <TGMsgBox.h>

/// \class AliMUONPainterMasterFrame
///
/// Main window of the 2D display
///
/// \author Laurent Aphecetche, Subatech

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

namespace
{
  UInt_t UniqueID(Int_t nx, Int_t ny)
  {
    return ny | (nx << 8);
  }
  
  Int_t Nx(UInt_t uniqueID)
  {
    return ( uniqueID & 0xFF00 ) >> 8;
  }

  Int_t Ny(UInt_t uniqueID)
  {
    return uniqueID & 0xFF;
  }

}

const Int_t AliMUONPainterMasterFrame::fgkBorderSize = 10;

//_____________________________________________________________________________
AliMUONPainterMasterFrame::AliMUONPainterMasterFrame(const TGWindow* p, 
                                                     UInt_t w, UInt_t h)
: TGCompositeFrame(p,w,h,kVerticalFrame),
  fNavigationFrame(0x0),
  fPainterMatrixFrame(0x0),
  fBackButton(0x0),
  fForwardButton(0x0),
  fGroupTitle(0x0),
  fNavigation(),
  fCurrentNavigationPosition(-1),
  fAttPainterSelectorFrame(0x0)
{  
  /// ctor
    
  UInt_t wi = w - fgkBorderSize*2;
  UInt_t hi = h - fgkBorderSize*3;
  
  fNavigationFrame = new TGHorizontalFrame(this,wi);
  
  AddFrame(fNavigationFrame,new TGLayoutHints(kLHintsExpandX|kLHintsTop,
                                              fgkBorderSize,fgkBorderSize,
                                              fgkBorderSize,fgkBorderSize));
    
  fBackButton = new TGPictureButton(fNavigationFrame,
                                       gClient->GetPicture("tb_back.xpm"));
  
  fForwardButton = new TGPictureButton(fNavigationFrame,
                                       gClient->GetPicture("tb_forw.xpm"));

  fAttPainterSelectorFrame = new AliMUONAttPainterSelectorFrame(fNavigationFrame,w/2,20);
  
  fGroupTitle = new TGLabel(fNavigationFrame,"");
  
  fNavigationFrame->AddFrame(fBackButton,new TGLayoutHints(kLHintsCenterY));
  fNavigationFrame->AddFrame(fForwardButton,new TGLayoutHints(kLHintsCenterY));
  
  fNavigationFrame->AddFrame(fAttPainterSelectorFrame,new TGLayoutHints(kLHintsCenterY,10));
  
  fAttPainterSelectorFrame->Connect("Clicked(AliMUONAttPainter*)",
                                    "AliMUONPainterMasterFrame",
                                    this,
                                    "AttributesChanged(AliMUONAttPainter*)");
  
  fNavigationFrame->AddFrame(fGroupTitle,new TGLayoutHints(kLHintsExpandX|kLHintsCenterX|kLHintsCenterY,10));
  
  fForwardButton->Connect("Clicked()","AliMUONPainterMasterFrame",
                          this,
                          "Forward()");

  fBackButton->Connect("Clicked()","AliMUONPainterMasterFrame",
                          this,
                          "Backward()");
    
  
                                                                   
  UInt_t w1 = wi;
  //  UInt_t h1 = hi - fNavigationFrame->GetHeight() - 3*fgkBorderSize;
  UInt_t h1 = hi - 7*12;
  
  MakeTopPainterMatrix(w1,h1);

  AddFrame(fPainterMatrixFrame,new TGLayoutHints(kLHintsExpandX,
                                                fgkBorderSize,fgkBorderSize,
                                                0,fgkBorderSize));
  
  AliMUONPainterInterfaceHelper::SetBackgroundColor("MasterFrame.Navigation",*fNavigationFrame);
  AliMUONPainterInterfaceHelper::SetBackgroundColor("MasterFrame.Main",*this);
  
  AliDebug(1,Form("fNavigation=%p",&fNavigation));
  
  AliMUONPainterRegistry::Instance()->Connect("PainterMatrixWantToShow(AliMUONPainterMatrix*)",
                                              "AliMUONPainterMasterFrame",
                                              this,
                                              "PainterMatrixWantToShow(AliMUONPainterMatrix*)");
  
  fPainterMatrixFrame->DataSourceWasChanged("*",0x0,-1);
}

//_____________________________________________________________________________
AliMUONPainterMasterFrame::~AliMUONPainterMasterFrame()
{
  /// dtor
  Cleanup();
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::AddPainterMatrix(AliMUONPainterMatrix* painterMatrix)
{
  /// array is adopted (by the registry)

  AliDebug(1,Form("matrix=%x %s",painterMatrix,painterMatrix->GetName()));
  
  Int_t i = AliMUONPainterRegistry::Instance()->Register(painterMatrix);

  SetNavigation(i);
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::PainterMatrixWantToShow(AliMUONPainterMatrix* group)
{
  /// FIXME: should check whether we are the active window before
  /// responding to this message ?

  AliDebug(1,Form("group=%x %s",group,group->GetName()));
  
  Int_t i = AliMUONPainterRegistry::Instance()->FindIndexOf(group);

  Int_t alreadyThere(-1);
  
  for ( Int_t j = 0; j < fNavigation.GetSize(); ++j )
  {
    if ( fNavigation[j] == i ) alreadyThere = j;
  }
  
  if (alreadyThere<0) 
  {
    SetNavigation(i);
  }
  else
  {
    fCurrentNavigationPosition = alreadyThere;
  }
  
  ShowPainterMatrix(group);  
}
                                                
//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::SetNavigation(Int_t i)
{
  /// Change navigation position
  
  ++fCurrentNavigationPosition;
  fNavigation.Set(fCurrentNavigationPosition+1);
  fNavigation[fCurrentNavigationPosition] = i;
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::ShowPainterMatrix(AliMUONPainterMatrix* painterMatrix)
{
  /// Change the painter matrix we show
  
  fPainterMatrixFrame->Use(painterMatrix);
  
  painterMatrix->Connect("Clicked(AliMUONVPainter*,Double_t*)",
                         "AliMUONPainterMasterFrame",this,
                         "Clicked(AliMUONVPainter*,Double_t*)");

  painterMatrix->Connect("ShiftClicked(AliMUONVPainter*,Double_t*)",
                         "AliMUONPainterMasterFrame",this,
                         "ShiftClicked(AliMUONVPainter*,Double_t*)");
  
  fPainterMatrixFrame->Connect("TitleHasChanged(const char*)",
                              "AliMUONPainterMasterFrame",this,
                              "ChangeTitle(const char*)");
  UpdateNavigation();
  
  UpdateAttributes(*(fPainterMatrixFrame->Matrix()));
  
  AliMUONPainterRegistry::Instance()->AddToHistory(painterMatrix);
  
  Layout();
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::ChangeTitle(const char* newTitle)
{
  /// Change the top title
  
  fGroupTitle->SetText(newTitle);
  fGroupTitle->Resize();
  Layout();
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::Backward()
{
  /// Move back one step in the history
  --fCurrentNavigationPosition;
  
  AliMUONPainterMatrix* group = 
    AliMUONPainterRegistry::Instance()->PainterMatrix(fNavigation[fCurrentNavigationPosition]);
  
  ShowPainterMatrix(group);
  
  UpdateNavigation();
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::Forward()
{
  /// Move forward one step in history
  
  ++fCurrentNavigationPosition;
  
  AliMUONPainterMatrix* group = 
    AliMUONPainterRegistry::Instance()->PainterMatrix(fNavigation[fCurrentNavigationPosition]);
  
  ShowPainterMatrix(group);
  
  UpdateNavigation();
}

//_____________________________________________________________________________
void 
AliMUONPainterMasterFrame::Clicked(AliMUONVPainter* painter, Double_t* values)
{
  /// A given painter was (singly) clicked

  if ( painter->CanBeDetached() )
  {
    fPainterMatrixFrame->MouseLeave(painter);
  
    AliMUONPainterMatrix* matrix = new AliMUONPainterMatrix(painter->Name().Data());

    AliMUONVPainter* p = painter->Detach();

    p->SetResponder(1);

    matrix->Adopt(p);
  
    AddPainterMatrix(matrix);
    ShowPainterMatrix(matrix);
  }
  else
  {
    painter->DrawHistogram(values);
  }
}

//_____________________________________________________________________________
void 
AliMUONPainterMasterFrame::ShiftClicked(AliMUONVPainter* painter, Double_t*)
{
  /// A given painter was shift-clicked
  
  if ( !painter->CanBeDetached() ) return;
  
  AliMUONPainterMatrix* currentMatrix = fPainterMatrixFrame->Matrix();
  
  AliMUONAttPainter a = painter->Attributes();
  
  TString basename(Form("%s-DUAL",painter->GetName()));
  
  TString newName = AliMUONPainterMatrix::NameIt(basename.Data(),a);
  
  AliMUONPainterMatrix* matrix = AliMUONPainterRegistry::Instance()->PainterMatrix(newName.Data());
  
  if (!matrix)
  {
    // No. So we must make a new matrix painter from the existing one,
    // and add to this new matrix the painters of the other one, but
    // using the new attributes...
    
    // create "opposite" attributes
    AliMUONAttPainter a1(a);
    AliMUONAttPainter a2(a);
  
    a2.Invert();
    
    a1.SetCathodeAndPlaneDisabled(kTRUE);
    a2.SetCathodeAndPlaneDisabled(kTRUE);
    
    AliMUONVPainter* p1 = AliMUONVPainter::CreatePainter(painter->ClassName(),
                                                         a1,
                                                         painter->ID0(),
                                                         painter->ID1());
    
    AliMUONVPainter* p2 = AliMUONVPainter::CreatePainter(painter->ClassName(),
                                                         a2,
                                                         painter->ID0(),
                                                         painter->ID1());
    
    if (!p1 || !p2)
    {
      Int_t ret;
      new TGMsgBox(gClient->GetRoot(), this,
                   "Invalid combination", "Cannot create 2 views from this painter",
                   kMBIconExclamation, kMBOk, &ret);
      PainterMatrixWantToShow(currentMatrix);
      delete p1;
      delete p2;
      return;
    }
    
    p1->UpdateGroupsFrom(*(painter->Master()));
    p2->UpdateGroupsFrom(*(painter->Master()));
    
    p1->SetResponder(1);
    p2->SetResponder(1);
    
    Int_t nx(2);
    Int_t ny(1);
    
    AliMpArea area(painter->Area());
    
    if ( area.GetDimensionX() > 1.2*area.GetDimensionY() ) 
    {
      nx = 1;
      ny = 2;
    }
    
    matrix = new AliMUONPainterMatrix(basename.Data(),nx,ny);
    
    matrix->Adopt(p1);
    matrix->Adopt(p2);
    
    AddPainterMatrix(matrix);
  }
  
  matrix->SetData(currentMatrix->DataPattern(),
                  currentMatrix->Data(),
                  currentMatrix->DataIndex());
  
  fPainterMatrixFrame->MouseLeave(painter);
  
  PainterMatrixWantToShow(matrix);
}

//_____________________________________________________________________________
void 
AliMUONPainterMasterFrame::SaveAs(const char* filename, Option_t* option) const
{
  /// Save painter matrix (in the sense of "print") in filename
  fPainterMatrixFrame->SaveAs(filename,option);
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::Update()
{
  /// Update ourselves
  
  fPainterMatrixFrame->Update();
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::UpdateAttributes(const AliMUONPainterMatrix& painterMatrix)
{
  /// Update the view buttons from the matrix we actually plot
  
  fAttPainterSelectorFrame->Update(painterMatrix.Attributes());
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::MakeTopPainterMatrix(UInt_t w, UInt_t h)
{
  /// Create the first painter matrix that appears when we are create
  /// FIXME: how to make this more flexible ?
  
  fPainterMatrixFrame = new AliMUONPainterMatrixFrame(this,w,h);

  AliMUONAttPainter att;
  
  att.SetPlane(kTRUE,kFALSE);
//  att.SetCathode(kTRUE,kFALSE);
  att.SetViewPoint(kTRUE,kFALSE);
    
  TString name = AliMUONPainterMatrix::NameIt("Tracker",att);
  
  AliMUONPainterMatrix* painterMatrix = AliMUONPainterRegistry::Instance()->PainterMatrix(name);
  
  if (!painterMatrix)
  {
    AliError(Form("Could not get pre-defined painter matrix %s : check that !",name.Data()));
  }
  else
  {
    PainterMatrixWantToShow(painterMatrix);
//    fPainterMatrixFrame->Use(painterMatrix);
//    ShowPainterMatrix(painterMatrix);
  }
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::UpdateNavigation()
{
  /// Update navigation frame

  fBackButton->SetEnabled(kTRUE);
  fForwardButton->SetEnabled(kTRUE);

  if ( fCurrentNavigationPosition == 0 ) 
  {
    fBackButton->SetEnabled(kFALSE);
  }
  if ( fCurrentNavigationPosition == fNavigation.GetSize()-1 ) 
  {
    fForwardButton->SetEnabled(kFALSE);
  }
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::AttributesChanged(AliMUONAttPainter* newValues)
{
  /// Attributes changed (e.g. from cath0 to cath1 or bending to nonbending, etc...)
  
  AliMUONPainterMatrix* currentMatrix = fPainterMatrixFrame->Matrix();
  
  AliMUONAttPainter a = currentMatrix->Validate(*newValues);
  
  if (!a.IsValid())
  {
    Int_t ret;
    new TGMsgBox(gClient->GetRoot(), this,
                 "Invalid combination", "Change of attributes not possible for this object",
                 kMBIconExclamation, kMBOk, &ret);
    PainterMatrixWantToShow(currentMatrix);
    return;
  }
  
  // First check if we already have this matrix available
  
  TString newName = AliMUONPainterMatrix::NameIt(currentMatrix->Basename(),a);
  
  AliMUONPainterMatrix* matrix = AliMUONPainterRegistry::Instance()->PainterMatrix(newName.Data());

  if (!matrix)
  {
    // No. So we must make a new matrix painter from the existing one,
    // and add to this new matrix the painters of the other one, but
    // using the new attributes...
    
    matrix = currentMatrix->Clone(a);
  
    AddPainterMatrix(matrix);
  }
  
  matrix->SetData(currentMatrix->DataPattern(),
                  currentMatrix->Data(),
                  currentMatrix->DataIndex());
  
  PainterMatrixWantToShow(matrix);
}
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	#include "AliMUONPainterMasterFrame.h"
	19
	20	#include "AliMUONChamberPainter.h"
	21	#include "AliMUONPainterGroup.h"
	22	#include "AliMUONPainterMatrix.h"
	23	#include "AliMUONPainterMatrixFrame.h"
	24	#include "AliMUONPainterInterfaceHelper.h"
	25	#include "AliMUONPainterRegistry.h"
	26	#include "AliMUONAttPainterSelectorFrame.h"
	27	#include "AliMUONVPainter.h"
	28	#include "AliCodeTimer.h"
	29	#include "AliLog.h"
	30	#include <Riostream.h>
	31	#include <TApplication.h>
	32	#include <TCanvas.h>
	33	#include <TEnv.h>
	34	#include <TGComboBox.h>
	35	#include <TGLabel.h>
	36	#include <TObjArray.h>
	37	#include <TObjString.h>
	38	#include <TGButtonGroup.h>
	39	#include <TGMsgBox.h>
	40
	41	/// \class AliMUONPainterMasterFrame
	42	///
	43	/// Main window of the 2D display
	44	///
	45	/// \author Laurent Aphecetche, Subatech
	46
	47	///\cond CLASSIMP
	48	ClassImp(AliMUONPainterMasterFrame)
	49	///\endcond
	50
	51	namespace
	52	{
	53	UInt_t UniqueID(Int_t nx, Int_t ny)
	54	{
	55	return ny \| (nx << 8);
	56	}
	57
	58	Int_t Nx(UInt_t uniqueID)
	59	{
	60	return ( uniqueID & 0xFF00 ) >> 8;
	61	}
	62
	63	Int_t Ny(UInt_t uniqueID)
	64	{
65	return uniqueID & 0xFF;
66	}
67
68	}
69
70	const Int_t AliMUONPainterMasterFrame::fgkBorderSize = 10;
71
72	//_____________________________________________________________________________
73	AliMUONPainterMasterFrame::AliMUONPainterMasterFrame(const TGWindow* p,
74	UInt_t w, UInt_t h)
75	: TGCompositeFrame(p,w,h,kVerticalFrame),
76	fNavigationFrame(0x0),
77	fPainterMatrixFrame(0x0),
78	fBackButton(0x0),
79	fForwardButton(0x0),
80	fGroupTitle(0x0),
81	fNavigation(),
82	fCurrentNavigationPosition(-1),
83	fAttPainterSelectorFrame(0x0)
84	{
85	/// ctor
86
87	UInt_t wi = w - fgkBorderSize*2;
88	UInt_t hi = h - fgkBorderSize*3;
89
90	fNavigationFrame = new TGHorizontalFrame(this,wi);
91
92	AddFrame(fNavigationFrame,new TGLayoutHints(kLHintsExpandX\|kLHintsTop,
93	fgkBorderSize,fgkBorderSize,
94	fgkBorderSize,fgkBorderSize));
95
96	fBackButton = new TGPictureButton(fNavigationFrame,
97	gClient->GetPicture("tb_back.xpm"));
98
99	fForwardButton = new TGPictureButton(fNavigationFrame,
100	gClient->GetPicture("tb_forw.xpm"));
101
102	fAttPainterSelectorFrame = new AliMUONAttPainterSelectorFrame(fNavigationFrame,w/2,20);
103
104	fGroupTitle = new TGLabel(fNavigationFrame,"");
105
106	fNavigationFrame->AddFrame(fBackButton,new TGLayoutHints(kLHintsCenterY));
107	fNavigationFrame->AddFrame(fForwardButton,new TGLayoutHints(kLHintsCenterY));
108
109	fNavigationFrame->AddFrame(fAttPainterSelectorFrame,new TGLayoutHints(kLHintsCenterY,10));
110
111	fAttPainterSelectorFrame->Connect("Clicked(AliMUONAttPainter*)",
112	"AliMUONPainterMasterFrame",
113	this,
114	"AttributesChanged(AliMUONAttPainter*)");
115
116	fNavigationFrame->AddFrame(fGroupTitle,new TGLayoutHints(kLHintsExpandX\|kLHintsCenterX\|kLHintsCenterY,10));
117
118	fForwardButton->Connect("Clicked()","AliMUONPainterMasterFrame",
119	this,
120	"Forward()");
121
122	fBackButton->Connect("Clicked()","AliMUONPainterMasterFrame",
123	this,
124	"Backward()");
125
126
127
128	UInt_t w1 = wi;
9016a84e	129	// UInt_t h1 = hi - fNavigationFrame->GetHeight() - 3*fgkBorderSize;
9016a84e	130	UInt_t h1 = hi - 7*12;
0145e89a	131
	132	MakeTopPainterMatrix(w1,h1);
	133
	134	AddFrame(fPainterMatrixFrame,new TGLayoutHints(kLHintsExpandX,
	135	fgkBorderSize,fgkBorderSize,
	136	0,fgkBorderSize));
	137
	138	AliMUONPainterInterfaceHelper::SetBackgroundColor("MasterFrame.Navigation",*fNavigationFrame);
	139	AliMUONPainterInterfaceHelper::SetBackgroundColor("MasterFrame.Main",*this);
	140
	141	AliDebug(1,Form("fNavigation=%p",&fNavigation));
	142
	143	AliMUONPainterRegistry::Instance()->Connect("PainterMatrixWantToShow(AliMUONPainterMatrix*)",
	144	"AliMUONPainterMasterFrame",
	145	this,
	146	"PainterMatrixWantToShow(AliMUONPainterMatrix*)");
	147
	148	fPainterMatrixFrame->DataSourceWasChanged("*",0x0,-1);
	149	}
	150
	151	//_____________________________________________________________________________
	152	AliMUONPainterMasterFrame::~AliMUONPainterMasterFrame()
	153	{
	154	/// dtor
	155	Cleanup();
	156	}
	157
	158	//_____________________________________________________________________________
	159	void
	160	AliMUONPainterMasterFrame::AddPainterMatrix(AliMUONPainterMatrix* painterMatrix)
	161	{
	162	/// array is adopted (by the registry)
	163
	164	AliDebug(1,Form("matrix=%x %s",painterMatrix,painterMatrix->GetName()));
	165
	166	Int_t i = AliMUONPainterRegistry::Instance()->Register(painterMatrix);
	167
	168	SetNavigation(i);
	169	}
	170
	171	//_____________________________________________________________________________
	172	void
	173	AliMUONPainterMasterFrame::PainterMatrixWantToShow(AliMUONPainterMatrix* group)
	174	{
9016a84e	175	/// FIXME: should check whether we are the active window before
9016a84e	176	/// responding to this message ?
0145e89a	177
	178	AliDebug(1,Form("group=%x %s",group,group->GetName()));
	179
	180	Int_t i = AliMUONPainterRegistry::Instance()->FindIndexOf(group);
	181
	182	Int_t alreadyThere(-1);
	183
	184	for ( Int_t j = 0; j < fNavigation.GetSize(); ++j )
	185	{
	186	if ( fNavigation[j] == i ) alreadyThere = j;
	187	}
	188
	189	if (alreadyThere<0)
	190	{
	191	SetNavigation(i);
	192	}
	193	else
	194	{
	195	fCurrentNavigationPosition = alreadyThere;
	196	}
	197
	198	ShowPainterMatrix(group);
	199	}
	200
	201	//_____________________________________________________________________________
	202	void
	203	AliMUONPainterMasterFrame::SetNavigation(Int_t i)
	204	{
	205	/// Change navigation position
	206
	207	++fCurrentNavigationPosition;
	208	fNavigation.Set(fCurrentNavigationPosition+1);
	209	fNavigation[fCurrentNavigationPosition] = i;
	210	}
	211
	212	//_____________________________________________________________________________
	213	void
	214	AliMUONPainterMasterFrame::ShowPainterMatrix(AliMUONPainterMatrix* painterMatrix)
	215	{
	216	/// Change the painter matrix we show
	217
	218	fPainterMatrixFrame->Use(painterMatrix);
	219
	220	painterMatrix->Connect("Clicked(AliMUONVPainter,Double_t)",
	221	"AliMUONPainterMasterFrame",this,
	222	"Clicked(AliMUONVPainter,Double_t)");
	223
	224	painterMatrix->Connect("ShiftClicked(AliMUONVPainter,Double_t)",
	225	"AliMUONPainterMasterFrame",this,
	226	"ShiftClicked(AliMUONVPainter,Double_t)");
	227
	228	fPainterMatrixFrame->Connect("TitleHasChanged(const char*)",
	229	"AliMUONPainterMasterFrame",this,
	230	"ChangeTitle(const char*)");
	231	UpdateNavigation();
	232
	233	UpdateAttributes(*(fPainterMatrixFrame->Matrix()));
	234
	235	AliMUONPainterRegistry::Instance()->AddToHistory(painterMatrix);
	236
	237	Layout();
	238	}
	239
	240	//_____________________________________________________________________________
241	void
242	AliMUONPainterMasterFrame::ChangeTitle(const char* newTitle)
243	{
244	/// Change the top title
245
246	fGroupTitle->SetText(newTitle);
247	fGroupTitle->Resize();
248	Layout();
249	}
250
251	//_____________________________________________________________________________
252	void
253	AliMUONPainterMasterFrame::Backward()
254	{
255	/// Move back one step in the history
256	--fCurrentNavigationPosition;
257
258	AliMUONPainterMatrix* group =
259	AliMUONPainterRegistry::Instance()->PainterMatrix(fNavigation[fCurrentNavigationPosition]);
260
261	ShowPainterMatrix(group);
262
263	UpdateNavigation();
264	}
265
266	//_____________________________________________________________________________
267	void
268	AliMUONPainterMasterFrame::Forward()
269	{
270	/// Move forward one step in history
271
272	++fCurrentNavigationPosition;
273
274	AliMUONPainterMatrix* group =
275	AliMUONPainterRegistry::Instance()->PainterMatrix(fNavigation[fCurrentNavigationPosition]);
276
277	ShowPainterMatrix(group);
278
279	UpdateNavigation();
280	}
281
282	//_____________________________________________________________________________
283	void
284	AliMUONPainterMasterFrame::Clicked(AliMUONVPainter* painter, Double_t* values)
285	{
286	/// A given painter was (singly) clicked
0145e89a	287
49419555	288	if ( painter->CanBeDetached() )
	289	{
	290	fPainterMatrixFrame->MouseLeave(painter);
0145e89a	291
49419555	292	AliMUONPainterMatrix* matrix = new AliMUONPainterMatrix(painter->Name().Data());
0145e89a	293
49419555	294	AliMUONVPainter* p = painter->Detach();
0145e89a	295
49419555	296	p->SetResponder(1);
0145e89a	297
49419555	298	matrix->Adopt(p);
0145e89a	299
49419555	300	AddPainterMatrix(matrix);
	301	ShowPainterMatrix(matrix);
	302	}
	303	else
	304	{
	305	painter->DrawHistogram(values);
	306	}
0145e89a	307	}
	308
	309	//_____________________________________________________________________________
	310	void
	311	AliMUONPainterMasterFrame::ShiftClicked(AliMUONVPainter* painter, Double_t*)
	312	{
	313	/// A given painter was shift-clicked
	314
49419555	315	if ( !painter->CanBeDetached() ) return;
49419555	316
0145e89a	317	AliMUONPainterMatrix* currentMatrix = fPainterMatrixFrame->Matrix();
	318
	319	AliMUONAttPainter a = painter->Attributes();
	320
	321	TString basename(Form("%s-DUAL",painter->GetName()));
	322
	323	TString newName = AliMUONPainterMatrix::NameIt(basename.Data(),a);
	324
49419555	325	AliMUONPainterMatrix* matrix = AliMUONPainterRegistry::Instance()->PainterMatrix(newName.Data());
0145e89a	326
	327	if (!matrix)
	328	{
	329	// No. So we must make a new matrix painter from the existing one,
	330	// and add to this new matrix the painters of the other one, but
	331	// using the new attributes...
	332
	333	// create "opposite" attributes
	334	AliMUONAttPainter a1(a);
	335	AliMUONAttPainter a2(a);
1ffbeb9d	336
1ffbeb9d	337	a2.Invert();
0145e89a	338
	339	a1.SetCathodeAndPlaneDisabled(kTRUE);
	340	a2.SetCathodeAndPlaneDisabled(kTRUE);
49419555	341
0145e89a	342	AliMUONVPainter* p1 = AliMUONVPainter::CreatePainter(painter->ClassName(),
	343	a1,
	344	painter->ID0(),
	345	painter->ID1());
	346
	347	AliMUONVPainter* p2 = AliMUONVPainter::CreatePainter(painter->ClassName(),
49419555	348	a2,
	349	painter->ID0(),
	350	painter->ID1());
0145e89a	351
	352	if (!p1 \|\| !p2)
	353	{
	354	Int_t ret;
	355	new TGMsgBox(gClient->GetRoot(), this,
	356	"Invalid combination", "Cannot create 2 views from this painter",
	357	kMBIconExclamation, kMBOk, &ret);
	358	PainterMatrixWantToShow(currentMatrix);
	359	delete p1;
	360	delete p2;
	361	return;
	362	}
	363
0145e89a	364	p1->UpdateGroupsFrom(*(painter->Master()));
	365	p2->UpdateGroupsFrom(*(painter->Master()));
	366
	367	p1->SetResponder(1);
	368	p2->SetResponder(1);
	369
	370	Int_t nx(2);
	371	Int_t ny(1);
	372
	373	AliMpArea area(painter->Area());
49419555	374
6e97fbb8	375	if ( area.GetDimensionX() > 1.2*area.GetDimensionY() )
0145e89a	376	{
	377	nx = 1;
	378	ny = 2;
	379	}
	380
	381	matrix = new AliMUONPainterMatrix(basename.Data(),nx,ny);
	382
	383	matrix->Adopt(p1);
	384	matrix->Adopt(p2);
	385
	386	AddPainterMatrix(matrix);
	387	}
	388
	389	matrix->SetData(currentMatrix->DataPattern(),
	390	currentMatrix->Data(),
	391	currentMatrix->DataIndex());
	392
	393	fPainterMatrixFrame->MouseLeave(painter);
	394
	395	PainterMatrixWantToShow(matrix);
	396	}
	397
10eb3d17	398	//_____________________________________________________________________________
	399	void
	400	AliMUONPainterMasterFrame::SaveAs(const char* filename, Option_t* option) const
	401	{
	402	/// Save painter matrix (in the sense of "print") in filename
	403	fPainterMatrixFrame->SaveAs(filename,option);
	404	}
	405
0145e89a	406	//_____________________________________________________________________________
	407	void
	408	AliMUONPainterMasterFrame::Update()
	409	{
	410	/// Update ourselves
	411
	412	fPainterMatrixFrame->Update();
	413	}
	414
	415	//_____________________________________________________________________________
	416	void
	417	AliMUONPainterMasterFrame::UpdateAttributes(const AliMUONPainterMatrix& painterMatrix)
	418	{
	419	/// Update the view buttons from the matrix we actually plot
	420
	421	fAttPainterSelectorFrame->Update(painterMatrix.Attributes());
	422	}
	423
	424	//_____________________________________________________________________________
	425	void
	426	AliMUONPainterMasterFrame::MakeTopPainterMatrix(UInt_t w, UInt_t h)
	427	{
	428	/// Create the first painter matrix that appears when we are create
	429	/// FIXME: how to make this more flexible ?
	430
	431	fPainterMatrixFrame = new AliMUONPainterMatrixFrame(this,w,h);
	432
	433	AliMUONAttPainter att;
	434
49419555	435	att.SetPlane(kTRUE,kFALSE);
49419555	436	// att.SetCathode(kTRUE,kFALSE);
0145e89a	437	att.SetViewPoint(kTRUE,kFALSE);
	438
	439	TString name = AliMUONPainterMatrix::NameIt("Tracker",att);
	440
49419555	441	AliMUONPainterMatrix* painterMatrix = AliMUONPainterRegistry::Instance()->PainterMatrix(name);
0145e89a	442
	443	if (!painterMatrix)
	444	{
	445	AliError(Form("Could not get pre-defined painter matrix %s : check that !",name.Data()));
	446	}
	447	else
	448	{
	449	PainterMatrixWantToShow(painterMatrix);
	450	// fPainterMatrixFrame->Use(painterMatrix);
	451	// ShowPainterMatrix(painterMatrix);
	452	}
	453	}
	454
	455	//_____________________________________________________________________________
	456	void
	457	AliMUONPainterMasterFrame::UpdateNavigation()
	458	{
	459	/// Update navigation frame
	460
	461	fBackButton->SetEnabled(kTRUE);
	462	fForwardButton->SetEnabled(kTRUE);
	463
	464	if ( fCurrentNavigationPosition == 0 )
	465	{
	466	fBackButton->SetEnabled(kFALSE);
	467	}
	468	if ( fCurrentNavigationPosition == fNavigation.GetSize()-1 )
	469	{
	470	fForwardButton->SetEnabled(kFALSE);
	471	}
	472	}
	473
	474	//_____________________________________________________________________________
	475	void
	476	AliMUONPainterMasterFrame::AttributesChanged(AliMUONAttPainter* newValues)
	477	{
	478	/// Attributes changed (e.g. from cath0 to cath1 or bending to nonbending, etc...)
	479
	480	AliMUONPainterMatrix* currentMatrix = fPainterMatrixFrame->Matrix();
	481
	482	AliMUONAttPainter a = currentMatrix->Validate(*newValues);
	483
	484	if (!a.IsValid())
	485	{
	486	Int_t ret;
	487	new TGMsgBox(gClient->GetRoot(), this,
	488	"Invalid combination", "Change of attributes not possible for this object",
	489	kMBIconExclamation, kMBOk, &ret);
	490	PainterMatrixWantToShow(currentMatrix);
	491	return;
	492	}
	493
	494	// First check if we already have this matrix available
	495
	496	TString newName = AliMUONPainterMatrix::NameIt(currentMatrix->Basename(),a);
	497
49419555	498	AliMUONPainterMatrix* matrix = AliMUONPainterRegistry::Instance()->PainterMatrix(newName.Data());
0145e89a	499
	500	if (!matrix)
	501	{
	502	// No. So we must make a new matrix painter from the existing one,
	503	// and add to this new matrix the painters of the other one, but
	504	// using the new attributes...
	505
	506	matrix = currentMatrix->Clone(a);
	507
	508	AddPainterMatrix(matrix);
	509	}
	510
	511	matrix->SetData(currentMatrix->DataPattern(),
	512	currentMatrix->Data(),
	513	currentMatrix->DataIndex());
	514
	515	PainterMatrixWantToShow(matrix);
	516	}