[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 <TGFileDialog.h>
#include <TGLabel.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TGButtonGroup.h>
#include <TGMsgBox.h>
#include <TSystem.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, AliMUONPainterMatrix* matrix)
: TGCompositeFrame(p,w,h,kVerticalFrame),
fNavigationFrame(0x0),
fPainterMatrixFrame(0x0),
fBackButton(0x0),
fForwardButton(0x0),
fGroupTitle(0x0),
fPrintMeButton(0x0),
fPrintAsButton(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"));    

  fPrintMeButton = new TGTextButton(fNavigationFrame,"Print");
  fPrintAsButton = new TGTextButton(fNavigationFrame,"Print As...");

  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));

  fNavigationFrame->AddFrame(fPrintMeButton,new TGLayoutHints(kLHintsCenterY,10));
  fNavigationFrame->AddFrame(fPrintAsButton,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()");
    
  fPrintMeButton->Connect("Clicked()","AliMUONPainterMasterFrame",
                        this,
                        "PrintMe()");

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

  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(matrix->DataPattern().Data(),matrix->Data(),matrix->DataIndex());
}

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

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

  AliDebug(1,Form("matrix=%p %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=%p %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::PrintAs() const
{
  /// Handle the PrintAs button
  
  TGFileInfo fileInfo;
  
  new TGFileDialog(gClient->GetRoot(),gClient->GetRoot(),
                   kFDSave,&fileInfo);
  
  if ( fileInfo.fFilename ) 
  {
    SaveAs(gSystem->ExpandPathName(Form("%s",fileInfo.fFilename)),"RECREATE");
  }
}

//_____________________________________________________________________________
void
AliMUONPainterMasterFrame::PrintMe() const
{
  /// Handle the PrintMe button
  
  SaveAs(gSystem->ExpandPathName(Form("%s.png",fPainterMatrixFrame->Matrix()->GetName())),"RECREATE");
}

//_____________________________________________________________________________
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(currentMatrix->Whatname(),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();
  fPainterMatrixFrame->UpdateInterface(kFALSE);
}

//_____________________________________________________________________________
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, AliMUONPainterMatrix* matrix)
{
  /// Create the first painter matrix that appears when we are create
  /// FIXME: how to make this more flexible ?
  
  fPainterMatrixFrame = new AliMUONPainterMatrixFrame(this,w,h);

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