mchview related changes.
[u/mrichter/AliRoot.git] / MUON / AliMUONVPainter.h
1 #ifndef ALIMUONVPAINTER_H
2 #define ALIMUONVPAINTER_H
3
4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 * See cxx source for full Copyright notice                               */
6
7 // $Id$
8
9 /// \ingroup graphics
10 /// \class AliMUONVPainter
11 /// \brief Base class for a graphical object representing some part of the
12 /// MUON tracking system
13 /// 
14 // Author Laurent Aphecetche, Subatech
15
16 #ifndef ALIMUONATTPAINTER_H
17 #  include "AliMUONAttPainter.h"
18 #endif
19 #ifndef ROOT_TQObject
20 #  include <TQObject.h>
21 #endif
22 #ifndef ROOT_TString
23 #  include "TString.h"
24 #endif
25 #ifndef ROOT_TObject
26 #  include "TObject.h"
27 #endif
28 #ifndef AL_MP_AREA_H
29 #  include "AliMpArea.h"
30 #endif
31 #include <float.h>
32
33 class AliMUONPainterContour;
34 class AliMUONPainterGroup;
35 class AliMUONVTrackerData;
36 class AliMpArea;
37 class TCollection;
38 class TH1;
39 class TList;
40 class TMap;
41 class TObjArray;
42 class TVirtualPad;
43
44 class AliMUONVPainter : public TObject, public TQObject
45 {
46 public:  
47
48   AliMUONVPainter(TRootIOCtor*);
49   AliMUONVPainter(const char* type="");
50   AliMUONVPainter(const AliMUONVPainter& rhs);
51   AliMUONVPainter& operator=(const AliMUONVPainter& rhs);
52   virtual ~AliMUONVPainter();
53
54   /// Add a painter to our list of children. We adopt this painter (i.e. we become owner).
55   void Add(AliMUONVPainter* painter);
56   
57   /// Return the area containing this painter
58   AliMpArea Area() const;
59   
60   virtual void SetAttributes(const AliMUONAttPainter& attributes);
61   
62   /// Convert attributes so they are valid ones for us.
63   virtual AliMUONAttPainter Validate(const AliMUONAttPainter& attributes) const { return attributes; }
64   
65   /// Get our attributes
66   const AliMUONAttPainter& Attributes() const { return fAttributes; }
67   
68   virtual void ComputeDataRange(const AliMUONVTrackerData& data, Int_t dataIndex, 
69                                 Double_t& dataMin, Double_t& dataMax) const;
70   
71   virtual void Copy(TObject& object) const;
72   
73   AliMUONVPainter* Detach() const;
74   
75   /// Whether this painter can be detached from the current view.
76   virtual Bool_t CanBeDetached() const { return kTRUE; }
77   
78   /// Whether we are valid or not
79   virtual Bool_t IsValid() const { return fIsValid; }
80   
81   /// Mark us as not valid
82   void Invalidate() { fIsValid = kFALSE; }
83   
84   Int_t Depth() const;
85   
86   virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
87   
88   virtual void Draw(Option_t* opt="");
89   
90   virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
91   
92   /// Return the contour representing the outline of this object
93   AliMUONPainterContour* Contour() const { return fContour; }
94
95   /// Get our name
96   virtual const char* GetName() const { return Name().Data(); }
97   
98   /// Get our name
99   virtual TString Name() const { return fName; }
100   
101   /// Get our path name (aka fullname)
102   virtual TString PathName() const { return fPathName; }
103   
104   virtual TString ContourName() const;
105
106   virtual char* GetObjectInfo(Int_t px, Int_t py) const;
107   
108   void GetTypes(TObjArray& types) const;
109
110   /// Return our mother group
111   AliMUONPainterGroup* MotherGroup() const { return fGroup; }
112   
113   /// Return specific name at a given position, if needed.
114   virtual TString NameAtPosition(Double_t /*x*/, Double_t /*y*/) const { return GetName(); }
115   
116   AliMUONPainterGroup* Group(const char* type) const;
117   
118   AliMUONPainterGroup* Group(Int_t depth) const;
119   
120   /// Whether we handle mouse motion or not
121   virtual Bool_t HandleMouseMotion() const { return kFALSE; }
122   
123   Bool_t IsResponder() const;
124   
125   Bool_t IsInside(Double_t x, Double_t y) const;
126
127   /// Return our mother (0 if we're the top node)
128   AliMUONVPainter* Mother() const { return fMother; }
129
130   virtual void Paint(Option_t* opt="");
131
132   virtual void Print(Option_t* opt="") const;
133
134   /// Return the plotter group
135   AliMUONPainterGroup* PlotterGroup() const { return fPlotterGroup; }
136   
137   /// Return the responder group
138   AliMUONPainterGroup* ResponderGroup() const { return fResponderGroup; }
139
140   /// Set out contour
141   void SetContour(AliMUONPainterContour* contour);
142   
143   void SetData(const char* pattern, AliMUONVTrackerData* data, Int_t dataIndex);
144
145   void SetLine(Int_t depth, Int_t lineColor, Int_t lineWidth);
146   
147   /// Set our mother group
148   void SetMotherGroup(AliMUONPainterGroup* group) { fGroup = group; }
149   
150   void SetMother(AliMUONVPainter* painter);
151   
152   void SetOutlined(const char* pattern, Bool_t flag);
153   
154   void SetResponder(const char* pattern);
155   
156   void SetResponder(Int_t depth);
157   
158   void SetVisible(const char* pattern, Bool_t flag);
159   
160   /// Return our type (e.g. PCB, Chamber, DE, MANU, etc...)
161   const char* Type() const { return fType.Data(); }
162
163   // SIGNALS
164   
165   void Clicked(AliMUONVPainter* painter, Double_t* pos); // *SIGNAL*
166
167   void ShiftClicked(AliMUONVPainter* painter, Double_t* pos); // *SIGNAL*
168
169   void DoubleClicked(AliMUONVPainter* painter, Double_t* pos); // *SIGNAL*
170     
171   static void PixelToPad(Int_t px, Int_t py, Double_t& x, Double_t& y);
172
173   virtual void PaintOutline(Int_t color=-1, Int_t width=-1, Double_t x=FLT_MAX, Double_t y=FLT_MAX);
174
175   virtual void PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex,
176                          Double_t min, Double_t max);
177     
178   /// Get the pad in which we are plotted
179   TVirtualPad* Pad() const { return fPad; }
180   
181   /// Get our line color
182   Int_t GetLineColor() const { return fLineColor; }
183   
184   /// Get our line width
185   Int_t GetLineWidth() const { return fLineWidth; }
186   
187   /// Set our line color
188   void SetLineColor(Int_t lineColor) { fLineColor = lineColor; }
189   
190   /// Set our line width
191   void SetLineWidth(Int_t lineWidth) { fLineWidth = lineWidth; }
192   
193   /// Set our name
194   void SetName(const char* name) { fName = name; }
195   
196   /// Set our path name (aka fullname)
197   void SetPathName(const char* pathName) { fPathName = pathName; }
198   
199   static AliMUONVPainter* CreatePainter(const char* className, 
200                                         const AliMUONAttPainter& att,
201                                         Int_t id1, Int_t id2);
202     
203   /// Get our first ID
204   Int_t ID0() const { return fID[0]; }
205   /// Get our second ID
206   Int_t ID1() const { return fID[1]; }
207   
208   /// Set our IDs
209   void SetID(Int_t id0, Int_t id1) { fID[0] = id0; fID[1] = id1; }
210   
211   virtual TString Describe(const AliMUONVTrackerData& data, Int_t dataIndex,
212                            Double_t x=FLT_MAX, Double_t y=FLT_MAX);
213
214   void UpdateGroupsFrom(const AliMUONVPainter& painter);
215
216   AliMUONVPainter* Master() const;
217   
218   virtual void DrawHistogram(Double_t* values=0x0) const;
219
220   /// To avoid getting a popup asking for the parameter in the GUI...
221   void DrawHistogram0() const { DrawHistogram(0x0); }
222   /// To avoid getting a popup asking for the parameter in the GUI...
223   void DrawHistogramClone0() const { DrawHistogramClone(0x0); }
224
225   virtual void DrawHistogramClone(Double_t* values=0x0) const;
226   
227   virtual void DrawInternalHistogram(Int_t dim) const;
228
229   virtual void DrawInternalHistogramClone(Int_t dim) const;
230
231   /// Append (i.e. don't have the right to clear the array !) our list of manus to manuList
232   virtual void FillManuList(TObjArray& manuList) const;
233   
234   /// following kind of stupid lines (SL), because I don't know how to
235   /// pass parameters to TClassMenuItem for context menu (don't even
236   /// know if that's possible at all)
237   /// SL
238   void DrawInternalHistogramClone0() { DrawInternalHistogramClone(0); }
239   /// SL
240   void DrawInternalHistogramClone1() { DrawInternalHistogramClone(1); }
241   /// SL
242   void DrawInternalHistogramClone2() { DrawInternalHistogramClone(2); }
243   /// SL
244   void DrawInternalHistogramClone3() { DrawInternalHistogramClone(3); }
245   /// SL
246   void DrawInternalHistogramClone4() { DrawInternalHistogramClone(4); }
247   /// SL
248   void DrawInternalHistogramClone5() { DrawInternalHistogramClone(5); }
249   /// SL
250   void DrawInternalHistogramClone6() { DrawInternalHistogramClone(6); }
251   /// SL
252   void DrawInternalHistogramClone7() { DrawInternalHistogramClone(7); }
253   /// SL
254   void DrawInternalHistogramClone8() { DrawInternalHistogramClone(8); }
255   /// SL
256   void DrawInternalHistogramClone9() { DrawInternalHistogramClone(9); }
257   
258   /// Whether or not the part of the detector represented by this painter should be included in readout.
259   virtual Bool_t IsIncluded() const = 0;
260   
261   /// Whether or not the part of the detector represented by this painter should be excluded from readout.
262   Bool_t IsExcluded() const { return ! IsIncluded(); }
263
264   virtual void Include();
265   
266   virtual void Exclude();
267
268 protected:
269     
270   virtual TCollection* Children() const;
271
272   mutable TH1* fHistogram; //!< histogram
273   
274   AliMUONVTrackerData* InteractiveReadOutConfig() const;
275   
276 private:
277   
278     void FlatList(TList& list);
279
280   AliMUONPainterGroup* CreateGroup(const char* type, Int_t depth);
281   
282   void CreateGroups();
283   
284   void GetBoundingBox(Double_t& x1, Double_t& y1, 
285                       Double_t& x2, Double_t& y2) const;
286   
287   AliMUONVPainter* GetPainter(Int_t px, Int_t py, Double_t& x, Double_t& y) const;
288   
289   void WriteIROC(Double_t value);
290   
291   void GetIROCManuList(TObjArray& manuList);
292
293 private:
294   
295   TString fName; ///< our (short) name
296   TString fPathName; ///< our long name
297   TString fType; ///< our type (DE, Chamber, MANU, etc...)
298   AliMUONVPainter* fMother;  ///< our mother
299   AliMUONPainterGroup* fGroup; ///< our group
300   AliMUONPainterContour* fContour;  ///< our contour
301   TMap* fPainterGroups; ///< map of groups
302   TObjArray* fChildren; ///< our children
303   AliMUONPainterGroup* fResponderGroup; ///< the responder group
304   AliMUONPainterGroup* fPlotterGroup; ///< the plotter group
305   Double_t fBorderFactor; ///< border factor for visu 
306   TVirtualPad* fPad; ///< the pad we're drawn in
307   AliMUONAttPainter fAttributes; ///< our attributes (e.g. view type)
308   Int_t fLineColor; ///< our outline color
309   Int_t fLineWidth; ///< our outline width
310   Int_t fID[2]; ///< our ids
311   Bool_t fIsValid; ///< whether we were properly initialized
312   
313   ClassDef(AliMUONVPainter,3) // Base class of a graphical object for MUON spectrometer
314 };
315
316 #endif