Coding convention correction and warning removal
[u/mrichter/AliRoot.git] / TGeant3 / TGeant3GUI.cxx
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 /*
17 $Log$
18 Revision 1.7  2000/06/28 21:27:45  morsch
19 Most coding rule violations corrected.
20 Still to do: Split the file (on file per class) ? Avoid the global variables.
21 Copy constructors and assignment operators (dummy ?)
22
23 Revision 1.6  2000/04/14 11:07:46  morsch
24 Correct volume to medium assignment in case several media are asigned to the
25 same material.
26
27 Revision 1.5  2000/03/20 15:11:03  fca
28 Mods to make the code compile on HP
29
30 Revision 1.4  2000/01/18 16:12:08  morsch
31 Bug in calculation of number of volume divisions and number of positionings corrected
32 Browser for Material and Media properties added
33
34 Revision 1.3  1999/11/14 14:31:14  fca
35 Correct small error and remove compilation warnings on HP
36
37 Revision 1.2  1999/11/10 16:53:35  fca
38 The new geometry viewer from A.Morsch
39
40 */
41
42 /* 
43  *  Version: 0
44  *  Written by Andreas Morsch
45  *  
46  * 
47  *
48  * For questions critics and suggestions to this part of the code
49  * contact andreas.morsch@cern.ch
50  * 
51  **************************************************************************/
52 #include <stdlib.h>
53 #include <TROOT.h>
54 #include <AliRun.h>
55 #include <AliMC.h>
56 #include <TGeant3.h>
57 #include <THIGZ.h>
58 #include <TApplication.h>
59 #include <TVirtualX.h>
60 #include <TGListBox.h>
61 #include <TGListTree.h>
62 #include <TGClient.h>
63 #include <TGFrame.h>
64 #include <TGIcon.h>
65 #include <TGLabel.h>
66 #include <TGButton.h>
67 #include <TGTextEntry.h>
68 #include <TGMsgBox.h>
69 #include <TGMenu.h>
70 #include <TGCanvas.h>
71 #include <TGComboBox.h>
72 #include <TGTab.h>
73 #include <TGSlider.h>
74 #include <TGDoubleSlider.h>
75 #include <TGFileDialog.h>
76 #include <TRootEmbeddedCanvas.h>
77 #include <TCanvas.h>
78 #include <TH1.h>
79 #include <TH2.h>
80 #include <TRandom.h>
81 #include <TSystem.h>
82 #include <TEnv.h>
83 #include <TGPicture.h>
84 #include <TGraph.h>
85
86 #include "TGeant3GUI.h"
87
88 static AliDrawVolume  *gCurrentVolume   = new AliDrawVolume("NULL");
89 static AliGUIMaterial *gCurrentMaterial = new AliGUIMaterial();
90 static AliGUIMedium   *gCurrentMedium   = new AliGUIMedium();
91 static Int_t           gCurrentParticle = 1;
92 static Int_t           gCurrentProcess  = 1;
93
94 ClassImp(AliGeant3GeometryGUI)
95
96     AliGeant3GeometryGUI::AliGeant3GeometryGUI()
97 {
98 // Constructor
99     fPanel  =   new AliGuiGeomMain(gClient->GetRoot(), 500, 500);
100     fNstack = 0;
101     fVolumes =   new TClonesArray("AliDrawVolume",1000);
102     fMaterials = new TClonesArray("AliGUIMaterial",1000);
103     fMedia =     new TClonesArray("AliGUIMedium",1000);
104 //  Store local copy of zebra bank entries
105     TGeant3 *geant3 = (TGeant3*) gMC;
106     if (geant3) {
107         fZlq=geant3->Lq();
108         fZq=geant3->Q();
109         fZiq=geant3->Iq();
110         fGclink=geant3->Gclink();
111         fGcnum=geant3->Gcnum();
112 //
113         ReadGeometryTree();
114         ReadMaterials();
115     }
116 }
117 void AliGeant3GeometryGUI::Streamer(TBuffer &)
118 {
119 // Dummy Streamer
120 ;
121 }
122
123
124 void AliGeant3GeometryGUI::ReadGeometryTree()
125 {
126 //
127 // Copy zebra volume tree into ROOT LisTree
128 //
129     char *vname;
130     char /* *namec, */ *tmp;
131     char namec[30];
132 //  Icons for 
133 //  Closed folder (=volume containing children)
134     const TGPicture* kFolder     = gClient->GetPicture("folder_t.xpm");
135 //  Open folder   (=volume containing children)
136     const TGPicture* kOpenFolder = gClient->GetPicture("ofolder_t.xpm");
137 //  Empty object
138     const TGPicture* kDocument   = gClient->GetPicture("doc_t.xpm");
139
140     AliDrawVolume  *volume;
141
142     Int_t nst=0;
143     Int_t nlevel=1;
144     Int_t newlevel=nlevel;
145
146     volume = new AliDrawVolume("ALIC");
147     volume->SetIdVolume(((TGeant3*)gMC)->VolId("ALIC"));
148     volume->SetIdCopy(0);
149     volume->SetItem(NULL);
150     (*fVolumes)[0]=volume;
151 //
152 //  Loop over volumes for which information has been collected
153     while(nlevel>nst) {
154         for (Int_t i=nst; i<nlevel; i++) 
155         {
156             TGListTreeItem *itemi, *item2;
157 // GEANT3 volume number
158             Int_t ivol=TMath::Abs(Volume(i)->GetIdVolume());
159 // Copy number
160 // icopy=1 normal positioning
161 // icopy>1 positioning with parposp
162 // icopy<0 division
163             Int_t icopy = Volume(i)->GetIdCopy();
164 // Medium and material number, handle special case of divisions
165             Int_t imat, imed;
166             
167             if (icopy <0) {
168                 imed=Medium(-ivol);
169                 imat=Material(-ivol);
170             } else {
171                 imed=Medium(ivol);
172                 imat=Material(ivol);
173             }
174 //
175 // Number of children
176             Int_t nch = NChildren(ivol);
177             strcpy(namec,((TGeant3*)gMC)->VolName(ivol));
178             if (nch >= 0) {
179                 printf("\n %s has %d children  \n ", namec,  nch);
180             } else {
181                 printf("\n %s has  divisions \n ", namec);
182             }
183 //
184 // Name to be used in ListTree
185             vname = new char[5];
186             strncpy(vname,namec, 4);
187             vname[4]='\0';
188
189             if (icopy >1) {
190                 sprintf(namec,"%s*%3dPos",namec,icopy);
191             } else if (icopy <0) {
192                 sprintf(namec,"%s*%3dDiv",namec,-icopy);
193             }
194             if (i>0) {
195                 itemi=Volume(i)->GetItem();
196             } else {
197                 itemi=NULL;
198             }
199             
200 //
201 // Add volume to list tree
202             
203             if (nch!=0) {
204                 item2 = fPanel->AddItem(new AliDrawVolume(vname), 
205                                     itemi, namec, kOpenFolder, kFolder);
206             } else {
207                 item2 = fPanel->AddItem(new AliDrawVolume(vname), 
208                                     itemi, namec, kDocument, kDocument);
209             }
210 //
211 // Add medium information to list tree item
212             ((AliDrawVolume *) item2->GetUserData())->SetIdVolume(ivol);
213             ((AliDrawVolume *) item2->GetUserData())->SetIdMaterial(imat);
214             ((AliDrawVolume *) item2->GetUserData())->SetIdMedium(imed);
215 //
216 // Set current volume to first list tree entry
217             if (!i) gCurrentVolume= ((AliDrawVolume *) item2->GetUserData());
218             
219 //
220 // Collect children information
221 //
222 // nch < 0: Children by division            
223             if (nch < 0) {
224 //
225 // Geant volume number
226                 Int_t icvol=Child(ivol,1);
227 // Name
228                 strcpy(namec,((TGeant3*)gMC)->VolName(-icvol));
229                 tmp = new char[4];
230                 strncpy(tmp,(char *) &namec, 4);
231                 volume = new AliDrawVolume(namec);
232                 volume->SetIdVolume(-icvol);
233 // Number of divisions
234                 Int_t jvo  = fZlq[fGclink->jvolum-ivol];
235                 Int_t jdiv = fZlq[jvo-1];
236                 Int_t ndiv = Int_t (fZq[jdiv+3]);
237                 volume->SetIdCopy(-ndiv);
238 // Link to mother
239                 volume->SetItem(item2);
240                 (*fVolumes)[newlevel]=volume;
241                 printf("\n volume %s %d %d %d", namec, icvol, nch, ndiv);
242                 newlevel++;
243 //
244 // Children by positioning
245             } else {
246                 Int_t nnew=0;
247 // Loop over children 
248                 for (Int_t j=0; j<nch; j++) 
249                 {
250 //
251 // Find out if this volume was already positioned and count copies 
252                     Int_t icvol=Child(ivol,j+1);
253                     icvol = TMath::Abs(icvol);
254                     Bool_t inList=kFALSE;
255                     for (Int_t k=0; k<nnew; k++) {
256                         if (icvol==
257                             Volume(newlevel-k-1)->GetIdVolume()) 
258                         {
259                             Volume(newlevel-k-1)->AddCopy();
260                             inList=kTRUE;
261                         }
262                     }
263 //
264 // New child
265                     if (!inList) {
266 //
267 // Name
268                         strcpy(namec,((TGeant3*)gMC)->VolName(icvol));
269                         tmp = new char[4];
270                         strncpy(tmp,(char *) &namec, 4);
271                         volume = new AliDrawVolume(namec);
272                         volume->SetIdVolume(icvol);
273                         volume->SetIdCopy(1);
274 // Link to mother
275                         volume->SetItem(item2);
276                         (*fVolumes)[newlevel]=volume;
277                         printf("\n volume %s %d %d", namec, icvol, nch);
278                         newlevel++;
279                         nnew++;
280                     }
281                 }
282             }
283         }
284 // Move one level deaper
285         nst=nlevel;
286         nlevel=newlevel;
287     }
288 }
289
290 void AliGeant3GeometryGUI::ReadMaterials()
291 {
292 //
293 // Puts media and material names into ComboBox and 
294 // collects material information
295 // 
296     Float_t a, z, dens, radl, absl;
297     a=z=dens=radl=absl=-1;
298     Int_t npar=0;
299     Int_t imat, isvol, ifield;
300     Float_t fieldm, tmaxfd, stemax, deemax, epsil, stmin;
301     Float_t par[50];
302     Float_t ubuf[50];
303     Int_t nwbuf;
304     
305     char natmed[21], namate[21];
306 //
307 // Loop over media
308     Int_t nEntries=0;
309     
310     for(Int_t itm=1;itm<=fGcnum->ntmed;itm++) {
311         Int_t jtm  = fZlq[fGclink->jtmed-itm];
312         if (jtm > 0) {
313             nEntries++;
314 // 
315 // Get medium parameters
316             ((TGeant3*)(gMC))->Gftmed(itm, natmed, imat, isvol, ifield, fieldm, 
317                                       tmaxfd, stemax, deemax, epsil, stmin, ubuf, &nwbuf);
318             strncpy(natmed,(char*)&fZiq[jtm+1],20);
319             natmed[20]='\0';
320 //
321 // Create new medium object 
322             AliGUIMedium * medium = 
323                 new AliGUIMedium(itm, imat, natmed, isvol, ifield, fieldm, 
324                                       tmaxfd, stemax, deemax, epsil, stmin);
325             (*fMedia)[nEntries-1]=medium;
326         { //Begin local scope for j
327           for (Int_t j=1; j<=22; j++) {
328             medium->SetPar(j,Cut(itm,j));
329           }
330         } //End local scope for j
331         { //Begin local scope for j
332           for (Int_t j=23; j<=26; j++) {
333             medium->SetPar(j,Cut(itm,j+3));
334           }
335         } //End local scope for j
336         { //Begin local scope for j
337           for (Int_t j=27; j<=29; j++) {
338             medium->SetPar(j,Cut(itm,j+4));
339           }
340         } //End local scope for j
341 //
342 // Add to ComboBox
343             fPanel->AddMedium(medium, nEntries);
344 //
345 // Associated material
346             imat =  Int_t (fZq[jtm+6]);
347             Int_t jma  =  Int_t (fZlq[fGclink->jmate-imat]);
348 //
349 // Get material parameters
350             ((TGeant3*)(gMC))->Gfmate (imat,namate,a,z,dens,radl,absl,par,npar);
351             strncpy(namate,(char *)&fZiq[jma+1],20);
352             namate[20]='\0';
353 //
354 // Create new material object
355             AliGUIMaterial * material = 
356                 new AliGUIMaterial(imat,namate,a,z,dens,radl,absl);
357             (*fMaterials)[nEntries-1]=material;
358             material->Dump();
359 //
360 // Add to combo box
361             fPanel->AddMaterial(material, nEntries);
362             gCurrentMaterial=material;
363         }
364     }
365     fPanel->SetComboEntries(fMaterials);
366     fPanel->SetMediaComboEntries(fMedia);
367     fPanel->Update();
368 }
369
370 Int_t AliGeant3GeometryGUI::NChildren(Int_t idvol)
371 {
372 //
373 // Return number of children for volume idvol
374     Int_t jvo = fZlq[fGclink->jvolum-idvol];
375     Int_t nin = Int_t(fZq[jvo+3]);
376     return nin;
377 }
378
379 Int_t AliGeant3GeometryGUI::Child(Int_t idvol, Int_t idc)
380 {
381 //
382 // Return GEANT id of child number idc of volume idvol
383     Int_t jvo = fZlq[fGclink->jvolum-idvol];
384     Int_t nin=idc;
385     Int_t jin = fZlq[jvo-nin];
386     Int_t numb =  Int_t (fZq[jin +3]);
387     if (numb > 1) {
388         return -Int_t(fZq[jin+2]);
389     } else {
390         return Int_t(fZq[jin+2]);
391     }
392 }
393
394 Int_t AliGeant3GeometryGUI::Medium(Int_t idvol)
395 {
396 //
397 // Return medium number for volume idvol.
398 // If idvol is negative the volume results from a division.
399     Int_t imed;
400     if (idvol > 0) {
401         Int_t jvo = fZlq[fGclink->jvolum-idvol];
402         imed = Int_t(fZq[jvo+4]);
403     } else {
404         idvol=-idvol;
405         Int_t jdiv = fZlq[fGclink->jvolum-idvol];
406         Int_t ivin = Int_t ( fZq[jdiv+2]);
407         Int_t jvin = fZlq[fGclink->jvolum-ivin];
408         imed = Int_t (fZq[jvin+4]);
409     }
410     return imed;
411 }
412
413 Int_t AliGeant3GeometryGUI::Material(Int_t idvol)
414 {
415 // Return material number for volume idvol.
416 // If idvol is negative the volume results from a division.
417
418     Int_t imed=Medium(idvol);
419     Int_t jtm  = fZlq[fGclink->jtmed-imed];
420     return Int_t (fZq[jtm+6]);
421 }
422
423
424 Float_t AliGeant3GeometryGUI::Cut(Int_t imed, Int_t icut)
425 {
426 // Return cuts icut for medium idmed 
427 // 
428     Int_t jtm  = fZlq[fGclink->jtmed-imed];
429 //
430 //  Have the defaults been modified ??
431     Int_t jtmn = fZlq[jtm];
432     if (jtmn >0) {
433         jtm=jtmn;
434         
435     } else {
436         jtm=fGclink->jtmed;
437     }
438     
439     return Float_t (fZq[jtm+icut]);
440 }
441
442 ClassImp(AliDrawVolume)
443 //
444 // Drawing parameter tags
445 enum AliDrawParamId {
446    kTheta,
447    kPhi,
448    kPsi,
449    kU,
450    kV,
451    kUscale,
452    kVscale,
453    kShadow,
454    kHide,
455    kFill,
456    kSeen,
457    kClip,
458    kClipXmin,
459    kClipXmax,
460    kClipYmin,
461    kClipYmax,
462    kClipZmin,
463    kClipZmax
464 };
465
466
467 AliDrawVolume::AliDrawVolume(char* name)
468 {
469 // Constructor
470     fName   = name;
471     fTheta  = 30;
472     fPhi    = 30;
473     fPsi    = 0;
474     fU      = 10;
475     fV      = 10;
476     fUscale = 0.01;
477     fVscale = 0.01;
478     fHide=0;
479     fShadow=0;
480     fFill=1;
481     fSeen=1;
482     fClip=0;
483     fClipXmin=0.;
484     fClipXmax=2000.;
485     fClipYmin=0.;
486     fClipYmax=2000.;
487     fClipZmin=0.;
488     fClipZmax=2000.;
489 }
490
491 char* AliDrawVolume::Name()
492 {
493 //
494 // Return volume name
495     return fName;
496 }
497
498     
499 void AliDrawVolume::Streamer(TBuffer &)
500 {
501 // Dummy Streamer
502 ;
503 }
504
505
506
507 void AliDrawVolume::Draw(Option_t *)
508 {
509 // Wraps the geant Gdraw
510     gMC->Gsatt(fName,"seen", fSeen);
511     
512     if (fHide) {
513         gMC->Gdopt("hide", "on");
514     } else {
515         gMC->Gdopt("hide", "off");
516     }
517
518     if (fShadow) {
519         gMC->Gdopt("shad", "on");
520         gMC->Gsatt("*", "fill", fFill);
521     } else {
522         gMC->Gdopt("shad", "off");
523     }
524
525         gMC->SetClipBox(".");
526     if (fClip) {
527         gMC->SetClipBox("*", fClipXmin, fClipXmax, 
528                         fClipYmin, fClipYmax, fClipZmin, fClipZmax);
529     } else {
530         gMC->SetClipBox(".");
531     }
532     
533
534     gMC->Gdraw(fName, fTheta, fPhi, fPsi, fU, fV, fUscale, fVscale);
535     THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
536     if (higz) higz->Update();
537 }
538
539 void AliDrawVolume::DrawSpec()
540 {
541 // Wraps the Geant DrawSpec
542     gMC->Gsatt(fName,"seen", fSeen);
543     
544     if (fHide) {
545         gMC->Gdopt("hide", "on");
546     } else {
547         gMC->Gdopt("hide", "off");
548     }
549
550     if (fShadow) {
551         gMC->Gdopt("shad", "on");
552         gMC->Gsatt("*", "fill", fFill);
553     } else {
554         gMC->Gdopt("shad", "off");
555     }
556
557     gMC->SetClipBox(".");
558     if (fClip) {
559         gMC->SetClipBox("*", fClipXmin, fClipXmax, fClipYmin, fClipYmax, fClipZmin, fClipZmax);
560     } else {
561         gMC->SetClipBox(".");
562     }
563     
564
565     ((TGeant3*) gMC)->DrawOneSpec(fName);
566     THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
567     if (higz) higz->Update();
568 }
569
570 void AliDrawVolume::SetParam(Int_t ip, Float_t param)
571 {
572 // Set drawing parameters
573     switch (ip) {
574     case kTheta:
575         fTheta=param;
576         break;
577     case kPhi:
578         fPhi=param;
579         break;
580     case kPsi:
581         fPsi=param;
582         break;
583     case kU:
584         fU=param;
585         break;
586     case kV:
587         fV=param;
588         break;
589     case kUscale:
590         fUscale=param;
591         break;
592     case kVscale:
593         fVscale=param;
594         break;
595     case kHide:
596         fHide=Int_t(param);
597         break;
598     case kShadow:
599         fShadow=Int_t(param);
600         break;
601     case kFill:
602         fFill=Int_t(param);
603         break;
604     case kSeen:
605         fSeen=Int_t(param);
606         break;
607     case kClip:
608         fClip=Int_t(param);
609         break;
610     case kClipXmin:
611         fClipXmin=param;
612         break;
613     case kClipXmax:
614         fClipXmax=param;
615         break;
616     case kClipYmin:
617         fClipYmin=param;
618         break;
619     case kClipYmax:
620         fClipYmax=param;
621         break;
622     case kClipZmin:
623         fClipZmin=param;
624         break;
625     case kClipZmax:
626         fClipZmax=param;
627         break;
628     }
629 }
630
631 Float_t  AliDrawVolume::GetParam(Int_t ip)
632 {
633 // Get drawing parameters
634     switch (ip) {
635     case kTheta:
636         return fTheta;
637     case kPhi:
638         return fPhi;
639     case kPsi:
640         return fPsi;
641     case kU:
642         return fU;
643     case kV:
644         return fV;
645     case kUscale:
646         return fUscale;
647     case kVscale:
648         return fVscale;
649     case kHide:
650         return Float_t(fHide);
651     case kShadow:
652         return Float_t(fShadow);
653     case kFill:
654         return Float_t(fFill);
655     case kSeen:
656         return Float_t(fSeen);
657     case kClip:
658         return Float_t(fClip);
659     case kClipXmin:
660         return fClipXmin;
661     case kClipXmax:
662         return fClipXmax;
663     case kClipYmin:
664         return fClipYmin;
665     case kClipYmax:
666         return fClipYmax;
667     case kClipZmin:
668         return fClipZmin;
669     case kClipZmax:
670         return fClipZmax;
671     default:
672         return 0.;
673     }
674     return 0.;
675 }
676
677
678 ClassImp(AliGuiGeomMain)
679
680  const Text_t* kLabelTextP[19]  = 
681 {"PAIR  ", "COMP  ", "PHOT  ", "PFIS  ", "DRAY  ", "ANNI  ", "BREM  ", 
682  "HADR  ", "MUNU  ", "DCAY  ", "LOSS  ", "MULS  ", "GHCOR1", "BIRK1 ", 
683  "BIRK2 ", "BIRK3 ", "LABS  ", "SYNC  ", "STRA  "};
684
685
686  const Text_t* kLabelTextC[10]  = 
687  {"CUTGAM", "CUTELE", "CUTNEU", "CUTHAD", "CUTMUO", "BCUTE", "BCUTM",
688   "DCUTE ", "DCUTM ", "PPCUTM"};
689
690 const Text_t* kLabelTextPart[24]  = 
691 {"Photon", "Positron", "Electron", "Neutrino", "Muon+", "Muon-", 
692  "Pi0", "Pi+", "Pi-", "Kaon_L", "Kaon+", "Kaon-", "Neutron", "Proton", 
693  "Anti Proton", "Kaon_S", "Eta", "Lambda", "Sigma+", "Sigma0", "Sigma-",
694  "Xi0", "Xi-", "Omega-"};
695
696 const Text_t* kLabelTextMechanism[24]  = 
697 {"HADF", "INEF", "ELAF", "FISF", "CAPF",
698  "HADG", "INEG", "ELAG", "FISG", "CAPG",
699  "LOSS", "PHOT", "ANNI", "COMP", "BREM",
700  "PAIR", "DRAY", "PFIS", "RAYL", "HADG",
701  "MUNU", "RANG", "STEP", "MUON"};
702
703
704
705
706 enum ETestCommandIdentifiers {
707    kFileOpen,
708    kFileSave,
709    kFileSaveAs,
710    kFileExit,
711
712    kTestDlg,
713
714    kHelpContents,
715    kHelpSearch,
716    kHelpAbout,
717
718
719    kVId1,
720    kHId1,
721    kVId2,
722    kHId2,
723
724    kVSId1,
725    kHSId1,
726    kVSId2,
727    kHSId2
728 };
729
730
731 Int_t mbButtonId[9] = { kMBYes, kMBNo, kMBOk, kMBApply,
732                           kMBRetry, kMBIgnore, kMBCancel,
733                           kMBClose, kMBDismiss };
734
735 EMsgBoxIcon mbIcon[4] = { kMBIconStop, kMBIconQuestion,
736                            kMBIconExclamation, kMBIconAsterisk };
737
738 const char *kFileTypes[] = { "All files",     "*",
739                             "ROOT files",    "*.root",
740                             "ROOT macros",   "*.C",
741                             0,               0 };
742
743
744
745
746 TGListTreeItem*  AliGuiGeomMain::
747 AddItem(TObject * obj, TGListTreeItem *parent, const char* name, const TGPicture *open, const TGPicture *closed)
748 {
749 // Add item to the list tree
750     return fLt->AddItem(parent, name, obj, open, closed);
751 }
752
753 AliGuiGeomMain::AliGuiGeomMain(const TGWindow *p, UInt_t w, UInt_t h)
754       : TGMainFrame(p, w, h)
755 {
756     // Create test main frame. A TGMainFrame is a top level window.
757     // Create menubar and popup menus. The hint objects are used to place
758     // and group the different menu widgets with respect to eachother.
759     
760     fDialog=0;
761     fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,
762                                        0, 0, 1, 1);
763     fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
764     fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);
765     
766     fMenuFile = new TGPopupMenu(gClient->GetRoot());
767     fMenuFile->AddEntry("&Open...", kFileOpen);
768     fMenuFile->AddEntry("&Save", kFileSave);
769     fMenuFile->AddEntry("S&ave as...", kFileSaveAs);
770     fMenuFile->AddEntry("&Close", -1);
771     fMenuFile->AddSeparator();
772     fMenuFile->AddEntry("E&xit", kFileExit);
773     
774     fMenuFile->DisableEntry(kFileSaveAs);
775     fMenuFile->DisableEntry(kFileOpen);
776     fMenuFile->DisableEntry(kFileSave);
777     
778
779
780    fMenuTest = new TGPopupMenu(this);
781    fMenuTest->AddLabel("Draw");
782    fMenuTest->AddSeparator();
783    fMenuTest->AddEntry("&Volume Draw Control", kTestDlg);
784    fMenuTest->AddSeparator();
785    fMenuTest->Associate(this);
786    
787    
788    fMenuHelp = new TGPopupMenu(gClient->GetRoot());
789    fMenuHelp->AddEntry("&Contents", kHelpContents);
790    fMenuHelp->AddEntry("&Search...", kHelpSearch);
791    fMenuHelp->AddSeparator();
792    fMenuHelp->AddEntry("&About", kHelpAbout);
793
794    fMenuFile->DisableEntry(kHelpContents);
795    fMenuFile->DisableEntry(kHelpSearch);
796    fMenuFile->DisableEntry(kHelpAbout);
797    // Menu button messages are handled by the main frame (i.e. "this")
798    // ProcessMessage() method.
799    fMenuFile->Associate(this);
800    fMenuTest->Associate(this);
801    fMenuHelp->Associate(this);
802
803    fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame);
804    fMenuBar->AddPopup("&File", fMenuFile, fMenuBarItemLayout);
805    fMenuBar->AddPopup("&Draw Control", fMenuTest, fMenuBarItemLayout);
806    fMenuBar->AddPopup("&Help", fMenuHelp, fMenuBarHelpLayout);
807
808    AddFrame(fMenuBar, fMenuBarLayout);
809
810 // 
811 // Volumes
812 //
813    fTab = new TGTab(this, 400, 400);
814    TGCompositeFrame *tf = fTab->AddTab("Volumes");
815    TGLayoutHints *lTab = new TGLayoutHints(kLHintsBottom | kLHintsExpandX |
816                                           kLHintsExpandY, 2, 2, 5, 1);
817    AddFrame(fTab, lTab);
818
819 // Create TGCanvas and a canvas container which uses a tile layout manager
820    fCanvasWindow = new TGCanvas(tf, 400, 240);
821 // Create TreeList
822    fLt = new TGListTree(fCanvasWindow->GetViewPort(), 10, 10, kHorizontalFrame,
823                         fgWhitePixel);
824    fLt->Associate(this);
825    fCanvasWindow->SetContainer(fLt);
826
827     
828    TGLayoutHints *lo = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);
829    tf->AddFrame(fCanvasWindow, lo);
830 //
831 // Materials
832 //
833    tf = fTab->AddTab("Materials");
834    fF2 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
835    fL2 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
836 // ComboBox for materials
837    fMaterialCombo = new TGComboBox(fF2, 1);
838    fF2->AddFrame(fMaterialCombo, fL2);
839 // 
840 // text labels with material properties 
841 //
842    Text_t* labelText[6]  = 
843    {"Material Number  ", 
844     "Atomic Weight    ",
845     "Atomic Number    ", 
846     "Density          ",
847     "Radiation Length ", 
848     "Absorption Length"};
849
850    TGLayoutHints* bly   = 
851        new TGLayoutHints(kLHintsTop | kLHintsExpandY, 5, 5, 5, 5);
852    TGLayoutHints* bFly1 = 
853        new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
854    fF21 = new TGCompositeFrame(fF2, 60, 20, kVerticalFrame);
855    fF2->AddFrame(fF21,fL2);
856    { //Begin local scope for i
857      for (Int_t i=0; i<6; i++) {
858        Int_t idT=i+1;       
859        fHframe[i] = new TGHorizontalFrame(fF21, 400, 100, kFixedWidth);
860        fF21->AddFrame(fHframe[i], bly);
861        fTbh[i] = new TGTextBuffer(10);
862        fTeh[i] = new TGTextEntry(fHframe[i], fTbh[i],idT);
863        fTeh[i]->Associate(this);
864        fLabel[i] = new TGLabel(fHframe[i], labelText[i]);
865        fHframe[i]->AddFrame(fLabel[i], bFly1);
866        fHframe[i]->AddFrame(fTeh[i], bFly1);
867      }
868    } //End local scope for i
869    tf->AddFrame(fF2, fL2);
870    fMaterialCombo->Resize(200, 20);
871    fMaterialCombo->Associate(this);
872    
873
874 // Media Combo
875 //   
876    tf = fTab->AddTab("Media");
877    fF3 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
878 // ComboBox for tracking media
879    fMediaCombo = new TGComboBox(fF3, 2);
880    fF3->AddFrame(fMediaCombo, fL2);
881 // 
882 // text labels with material properties 
883 //
884    Text_t* labelTextM[8]  = 
885    {"Sensitivity Flag      ", 
886     "Magnetic Field Flag   ",
887     "Maximum Field         ", 
888     "Max. Ang. Deviation   ",
889     "Maximum Step          ", 
890     "Max. Frac. Energy Loss",
891     "Crossing Precission   ",
892     "Minimum Step Size     "};
893
894    fF31 = new TGCompositeFrame(fF3, 60, 20, kVerticalFrame);
895    fF3->AddFrame(fF31,fL2);
896    { //Begin local scope for i
897      for (Int_t i=0; i<8; i++) {
898        Int_t idT=i+1;       
899        fHframeM[i] = new TGHorizontalFrame(fF31, 400, 100, kFixedWidth);
900        fF31->AddFrame(fHframeM[i], bly);
901        fTbhM[i] = new TGTextBuffer(10);
902        fTehM[i] = new TGTextEntry(fHframeM[i], fTbhM[i],idT);
903        fTehM[i]->Associate(this);
904        fLabelM[i] = new TGLabel(fHframeM[i], labelTextM[i]);
905        fHframeM[i]->AddFrame(fLabelM[i], bFly1);
906        fHframeM[i]->AddFrame(fTehM[i], bFly1);
907      }
908    } //End local scope for i
909    tf->AddFrame(fF3, fL2);
910    fMediaCombo->Resize(200, 20);
911    fMediaCombo->Associate(this);
912 //
913 // Processes
914    tf = fTab->AddTab("Processes");
915    fF4 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
916    fProcessLB = new TGListBox(fF4, 1);
917    fF4->AddFrame(fProcessLB, fL2);
918    tf->AddFrame(fF4, fL2);
919    fProcessLB->Resize(150, 350);
920    fProcessLB->Associate(this);
921    
922 //
923 // Cuts
924    tf = fTab->AddTab("Cuts");
925    fF5 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
926    fCutsLB = new TGListBox(fF5, 1);
927    fF5->AddFrame(fCutsLB, fL2);
928    tf->AddFrame(fF5, fL2);
929    fCutsLB->Resize(150, 350);
930
931 //
932 // de/dx and cross-sections
933    tf = fTab->AddTab("DE/DX and X-Sections");
934    fF6 = new TGCompositeFrame(tf, 60, 20, kHorizontalFrame);
935
936 // ComboBox for particles
937    fF61 = new TGCompositeFrame(fF6, 60, 20, kVerticalFrame);
938    fF6->AddFrame(fF61, fL2);
939    fParticleCombo = new TGComboBox(fF61, 3);
940    fF61->AddFrame(fParticleCombo, fL2);
941    { //Begin local scope for i
942      for (Int_t i = 0; i < 24; i++) {
943        char tmp[20];
944        sprintf(tmp, "%s", kLabelTextPart[i]);
945        fParticleCombo->AddEntry(tmp, i+1);
946      }
947    } //End local scope for i
948    fParticleCombo->Select(1);
949    fParticleCombo->Resize(100, 20);
950    fParticleCombo->Associate(this);
951
952 // ComboBox for mechanisms
953    fF63 = new TGCompositeFrame(fF6, 60, 20, kVerticalFrame);
954    fF6->AddFrame(fF63, fL2);
955    fMechanismCombo = new TGComboBox(fF63, 4);
956    fF63->AddFrame(fMechanismCombo, fL2);
957    { //Begin local scope for i
958      for (Int_t i = 0; i < 24; i++) {
959        char tmp[20];
960        sprintf(tmp, "%s", kLabelTextMechanism[i]);
961        fMechanismCombo->AddEntry(tmp, i+1);
962      }
963    } //End local scope for i
964    fMechanismCombo->Select(1);
965    fMechanismCombo->Resize(100, 20);
966    fMechanismCombo->Associate(this);
967
968 //
969 // Energy Range
970 //
971    fTbh61 = new TGTextBuffer(10);
972    fTeh61 = new TGTextEntry(fF61, fTbh61,10);
973    fTbh61->AddText(0, "  100");
974    fTeh61->Associate(this);
975
976    fTbh62 = new TGTextBuffer(10);
977    fTeh62 = new TGTextEntry(fF61, fTbh62,11);
978    fTbh62->AddText(0, "0.001");
979    fTeh62->Associate(this);
980     
981    fTbh63 = new TGTextBuffer(10);
982    fTeh63 = new TGTextEntry(fF61, fTbh63,12);
983    fTbh63->AddText(0, "10.");
984    fTeh63->Associate(this);
985
986    fEmin=0.001;
987    fEmax=10.;
988    fNbins=100;
989    
990    fSLabel61 = new TGLabel(fF61, "Nbins-Emin-Emax");
991    bFly1 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
992    fF61->AddFrame(fSLabel61, bFly1);
993    fF61->AddFrame(fTeh61, bFly1);
994    fF61->AddFrame(fTeh62, bFly1);
995    fF61->AddFrame(fTeh63, bFly1);
996 //
997 // Plot Button
998    fF62 = new TGCompositeFrame(fF6, 60, 20, kHorizontalFrame);
999    fF6->AddFrame(fF62, fL2);
1000    fPlotButton = new TGTextButton(fF62, "Plot", 1);
1001    fPlotButton -> Associate(this);
1002    fF62->AddFrame(fPlotButton);
1003
1004    tf->AddFrame(fF6, fL2);
1005 // Window name and final mapping
1006 //
1007    SetWindowName("AliRoot Geometry Browser");
1008    MapSubwindows();
1009    // We need to use GetDefault...() to initialize the layout algorithm...
1010    Resize(GetDefaultSize());
1011    MapWindow();
1012 }
1013
1014 AliGuiGeomMain::~AliGuiGeomMain()
1015 {
1016    // Delete all created widgets.
1017
1018    delete fCanvasWindow;
1019
1020    delete fMenuBarLayout;
1021    delete fMenuBarItemLayout;
1022    delete fMenuBarHelpLayout;
1023
1024    delete fMenuFile;
1025    delete fMenuTest;
1026    delete fMenuHelp;
1027 }
1028
1029 void AliGuiGeomMain::Streamer(TBuffer &)
1030 {
1031 // Dummy streamer
1032 ;
1033 }
1034
1035 void AliGuiGeomMain::Plot()
1036 {
1037 // plot de/dx or cross-sections
1038     const Float_t kAvo=0.60221367;
1039     Float_t *tkin  = new Float_t[fNbins];
1040     Float_t *value = new Float_t[fNbins];
1041     Float_t *pcut  = new Float_t[fNbins];
1042     Int_t ixst;
1043     Int_t imate=gCurrentMaterial->Id();
1044     Float_t z=gCurrentMaterial->Z();
1045     Float_t a=gCurrentMaterial->A();
1046     Float_t density=gCurrentMaterial->Density();
1047     
1048     Int_t ipart=gCurrentParticle;
1049     const char *kChMeca= kLabelTextMechanism[gCurrentProcess-1];
1050     char* tmp;
1051     tmp = new char[5];
1052     strncpy(tmp, kChMeca, 4);
1053     tmp[4]='\0';
1054     Int_t kdim=fNbins;
1055     Float_t de=(fEmax-fEmin)/fNbins;
1056     { //Begin local scope for i
1057       for (Int_t i=0; i<kdim; i++) {
1058         tkin[i]=fEmin+Float_t(i)*de;
1059         value[i]=0.;
1060       }
1061     } //End local scope for i
1062     if (kChMeca!="MUON") {
1063         ((TGeant3*) gMC)->Gftmat(imate, ipart, tmp, kdim, tkin, value, pcut, ixst);
1064     } else {
1065         for (Int_t i=0; i<kdim; i++) {
1066             Float_t ekin=tkin[i];
1067             value[i]+=((TGeant3*) gMC)->Gbrelm(z,ekin,1.e10);
1068             value[i]+=((TGeant3*) gMC)->Gprelm(z,ekin,1.e10);
1069             value[i]*=1000.*kAvo*density/a;
1070         }
1071     }
1072     
1073     
1074     printf("\n %d %d %s %d \n",imate, ipart, kChMeca, kdim);
1075     if (ixst) {
1076         TGraph *graph = new TGraph(kdim,tkin,value);
1077         TCanvas *c1 = new TCanvas("c1"," ",400,10,600,700);
1078         c1->Divide(1,1);
1079         c1->cd(1);
1080         
1081         graph->SetFillColor(42);
1082         graph->SetMarkerColor(4);
1083         graph->SetMarkerStyle(21);
1084         graph->Draw("AC");
1085         graph->GetHistogram()->SetXTitle("Energy (GeV)");
1086         if (kChMeca == "RANG" || kChMeca == "STEP") {
1087             graph->GetHistogram()->SetYTitle
1088                 ("Distance (cm)");   
1089         } else if (kChMeca == "LOSS" || kChMeca == "MUON") {
1090             graph->GetHistogram()->SetYTitle("dE/dx (MeV/cm)");   
1091         } else {
1092             graph->GetHistogram()->SetYTitle
1093                 ("Macroscopic X-Section (1/cm)"); 
1094         }
1095     }
1096     
1097     delete tkin;
1098     delete value;
1099     delete pcut;
1100     
1101     
1102 }
1103
1104 void AliGuiGeomMain::Update()
1105 {
1106 // Update widgets
1107     if (fDialog) {
1108         fDialog->Update();
1109     }
1110
1111     Int_t imat=gCurrentVolume->Material();
1112     Int_t nmat=fComboEntries->GetEntriesFast();
1113     Int_t i=0;
1114     for (i=0; i<nmat; i++) {
1115         gCurrentMaterial = (AliGUIMaterial*) 
1116             (fComboEntries->UncheckedAt(i));
1117         if (gCurrentMaterial->Id()==imat) break;
1118     }
1119     Int_t imed = gCurrentVolume->Medium();
1120     Int_t nmed=fComboMediaEntries->GetEntriesFast();
1121     for (i=0; i<nmed; i++) {
1122         gCurrentMedium = (AliGUIMedium*) 
1123             (fComboMediaEntries->UncheckedAt(i));
1124         if (gCurrentMedium->Id()==imed) break;
1125     }
1126
1127     UpdateCombo();
1128     UpdateListBox();
1129     
1130 }
1131
1132 void AliGuiGeomMain::UpdateCombo()
1133 {
1134 // Update combos
1135
1136     Int_t   imat = gCurrentMaterial->Id();
1137     Float_t    a = gCurrentMaterial->A();
1138     Float_t    z = gCurrentMaterial->Z();    
1139     Float_t dens = gCurrentMaterial->Density();
1140     Float_t radl = gCurrentMaterial->RadiationLength();
1141     Float_t absl = gCurrentMaterial->AbsorptionLength();
1142     Int_t entry=gCurrentMaterial->ItemId();
1143 //    
1144 //
1145     fMaterialCombo->Select(entry);
1146     fMediaCombo->Select(entry);    
1147     char buf[10];
1148      
1149     sprintf(buf, "%10i", imat);
1150     fTbh[0]->Clear();
1151     fTbh[0]->AddText(0, buf);
1152     gClient->NeedRedraw(fTeh[0]);
1153     sprintf(buf, "%10.2e", a);
1154     fTbh[1]->Clear();
1155     fTbh[1]->AddText(0, buf);
1156     gClient->NeedRedraw(fTeh[1]);
1157
1158     sprintf(buf, "%10.2e", z);
1159     fTbh[2]->Clear();
1160     fTbh[2]->AddText(0, buf);
1161     gClient->NeedRedraw(fTeh[2]);
1162
1163     sprintf(buf, "%10.2e", dens);
1164     fTbh[3]->Clear();
1165     fTbh[3]->AddText(0, buf);
1166     gClient->NeedRedraw(fTeh[3]);
1167
1168     sprintf(buf, "%10.2e", radl);
1169     fTbh[4]->Clear();
1170     fTbh[4]->AddText(0, buf);
1171     gClient->NeedRedraw(fTeh[4]);
1172
1173     sprintf(buf, "%10.2e", absl);
1174     fTbh[5]->Clear();
1175     fTbh[5]->AddText(0, buf);
1176     gClient->NeedRedraw(fTeh[5]);
1177
1178 //  Media Combo
1179     sprintf(buf, "%10i", gCurrentMedium->Isvol());
1180     fTbhM[0]->Clear();
1181     fTbhM[0]->AddText(0, buf);
1182     gClient->NeedRedraw(fTehM[0]);
1183
1184
1185     sprintf(buf, "%10i", gCurrentMedium->Ifield());
1186     fTbhM[1]->Clear();
1187     fTbhM[1]->AddText(0, buf);
1188     gClient->NeedRedraw(fTehM[1]);
1189
1190     sprintf(buf, "%10.2e", gCurrentMedium->Fieldm());
1191     fTbhM[2]->Clear();
1192     fTbhM[2]->AddText(0, buf);
1193     gClient->NeedRedraw(fTehM[2]);
1194
1195     sprintf(buf, "%10.2e", gCurrentMedium->Tmaxfd());
1196     fTbhM[3]->Clear();
1197     fTbhM[3]->AddText(0, buf);
1198     gClient->NeedRedraw(fTehM[3]);
1199
1200     sprintf(buf, "%10.2e", gCurrentMedium->Stemax());
1201     fTbhM[4]->Clear();
1202     fTbhM[4]->AddText(0, buf);
1203     gClient->NeedRedraw(fTehM[4]);
1204
1205     sprintf(buf, "%10.2e", gCurrentMedium->Deemax());
1206     fTbhM[5]->Clear();
1207     fTbhM[5]->AddText(0, buf);
1208     gClient->NeedRedraw(fTehM[5]);
1209
1210     sprintf(buf, "%10.2e", gCurrentMedium->Epsil());
1211     fTbhM[6]->Clear();
1212     fTbhM[6]->AddText(0, buf);
1213     gClient->NeedRedraw(fTehM[6]);
1214
1215     sprintf(buf, "%10.2e", gCurrentMedium->Stmin());
1216     fTbhM[7]->Clear();
1217     fTbhM[7]->AddText(0, buf);
1218     gClient->NeedRedraw(fTehM[7]);
1219 }
1220
1221 void AliGuiGeomMain::UpdateListBox()
1222 {
1223 // Update the list box
1224     Int_t i;
1225     fProcessLB->RemoveEntries(1,19);
1226     for (i=11; i < 30; i++) {
1227         Float_t p=gCurrentMedium->GetPar(i);
1228         char tmp[20];
1229         sprintf(tmp, "%6s%5d", kLabelTextP[i-11], Int_t(p));
1230         fProcessLB->AddEntry(tmp, i-10);
1231     }
1232     fProcessLB->MapSubwindows();
1233     fProcessLB->Layout();
1234
1235     fCutsLB->RemoveEntries(1,10);
1236     for (i=1; i < 11; i++) {
1237         Float_t p=gCurrentMedium->GetPar(i);
1238         char tmp[20];
1239         sprintf(tmp, "%6s%10.3e", kLabelTextC[i-1], p);
1240         fCutsLB->AddEntry(tmp,i);
1241     }
1242     fCutsLB->MapSubwindows();
1243     fCutsLB->Layout();
1244 }
1245
1246
1247 void AliGuiGeomMain::CloseWindow()
1248 {
1249    // Got close message for this MainFrame. Calls parent CloseWindow()
1250    // (which destroys the window) and terminate the application.
1251    // The close message is generated by the window manager when its close
1252    // window menu item is selected.
1253
1254    TGMainFrame::CloseWindow();
1255    gApplication->Terminate(0);
1256 }
1257
1258 Bool_t AliGuiGeomMain::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
1259 {
1260 // Process messages to widgets
1261     switch (GET_MSG(msg)) {
1262 //
1263 //  Text entries for binning of cross-section plots
1264     case kC_TEXTENTRY:
1265         switch (GET_SUBMSG(msg)) {
1266         case kTE_TEXTCHANGED:
1267             switch (parm1) {
1268             case 10:
1269                 fNbins=(Int_t) atof(fTbh61->GetString());
1270                 break;
1271             case 11:
1272                 fEmin= atof(fTbh62->GetString());
1273                 break;
1274             case 12:
1275                 fEmax= atof(fTbh63->GetString());
1276                 break;
1277             }
1278             printf("\n %d %f %f binning", fNbins, fEmin, fEmax);
1279         }
1280         break;
1281 //
1282 // ListTree for volumes
1283     case kC_LISTTREE:
1284         switch (GET_SUBMSG(msg)) {
1285 //
1286 // Handle mouse click 
1287         case kCT_ITEMCLICK:
1288 //
1289 // Button 1: Select volume
1290             if (parm1 == kButton1) {
1291               TGListTreeItem *item;
1292               if ((item = fLt->GetSelected())) 
1293                 {
1294                   gCurrentVolume=((AliDrawVolume *) item->GetUserData());
1295                   Update();
1296                 }
1297             }
1298 //
1299 // Button 2: Draw volume specifications
1300
1301             if (parm1 == kButton2) {
1302                 TGListTreeItem *item;
1303                 if ((item = fLt->GetSelected())) 
1304                 {
1305
1306                     ((AliDrawVolume *) item->GetUserData())->DrawSpec();
1307
1308                     gCurrentVolume=((AliDrawVolume *) item->GetUserData());
1309                     Update();
1310                 }
1311             }
1312 //
1313 // Button 3: Draw Volume
1314             if (parm1 == kButton3) {
1315                 TGListTreeItem *item;
1316                 if ((item = fLt->GetSelected())) 
1317                 {
1318                     ((AliDrawVolume *) item->GetUserData())->Draw();
1319                     gCurrentVolume=((AliDrawVolume *) item->GetUserData());
1320                     Update();
1321                 }
1322             }
1323             
1324             
1325             break;
1326         case kCT_ITEMDBLCLICK:
1327             if (parm1 == kButton1) {
1328                 if (fLt->GetSelected() != 0) {
1329                     gClient->NeedRedraw(fLt);
1330                 }
1331             }
1332             break;
1333         default:
1334             break;
1335         }
1336         break;
1337     case kC_COMMAND:
1338         switch (GET_SUBMSG(msg)) {
1339         case kCM_BUTTON:
1340             switch(parm1) {
1341             case 1:
1342                 Plot();
1343                 break;
1344             }
1345             break;
1346         case kCM_COMBOBOX:
1347 //
1348 // Combo box bindings
1349             switch(parm1) {
1350 //
1351 // Material Combo
1352             case 1:
1353                 gCurrentMaterial=(AliGUIMaterial*) 
1354                     (fComboEntries->UncheckedAt(Int_t(parm2-1)));
1355                 gCurrentMedium=(AliGUIMedium*) 
1356                     (fComboMediaEntries->UncheckedAt(Int_t(parm2-1)));
1357                 UpdateCombo();
1358                 UpdateListBox();
1359                 break;
1360 //
1361 // Media Combo
1362             case 2:
1363                 gCurrentMedium=(AliGUIMedium*) 
1364                     (fComboMediaEntries->UncheckedAt(Int_t(parm2-1)));
1365                 gCurrentMaterial=(AliGUIMaterial*) 
1366                     (fComboEntries->UncheckedAt(Int_t(parm2-1)));
1367                 UpdateCombo();
1368                 UpdateListBox();
1369                 break;
1370 //
1371 // Particle Combo
1372             case 3:
1373                 gCurrentParticle=Int_t(parm2);
1374                 break;
1375 //
1376 // Mechanism Combo
1377             case 4:
1378                 gCurrentProcess=Int_t(parm2);
1379                 printf("\n Process %d", gCurrentProcess);
1380                 break;
1381             }
1382             break;
1383         case kCM_MENUSELECT:
1384             break;
1385             
1386         case kCM_MENU:
1387             switch (parm1) {
1388                 
1389             case kFileOpen:
1390             {
1391                 TGFileInfo fi;
1392                 fi.fFileTypes = (char **)kFileTypes;
1393                 new TGFileDialog(gClient->GetRoot(), this, kFDOpen,&fi);
1394             }
1395             break;
1396             
1397             case kTestDlg:
1398                 fDialog = new AliGuiGeomDialog
1399                     (gClient->GetRoot(), this, 400, 200);
1400                 break;
1401                 
1402             case kFileSave:
1403                 printf("kFileSave\n");
1404                 break;
1405                 
1406             case kFileExit:
1407                 CloseWindow();   // this also terminates theApp
1408                 break;
1409             default:
1410                 break;
1411             }
1412         default:
1413             break;
1414         }
1415     default:
1416         break;
1417     }
1418     return kTRUE;
1419 }
1420
1421 void AliGuiGeomMain::AddMaterial(AliGUIMaterial *Material, Int_t i)
1422 {
1423 // Add material to material combo
1424     char* tmp;
1425     tmp=Material->Name();
1426     Material->SetItemId(i);
1427     fMaterialCombo->AddEntry(tmp, i);
1428     fMaterialCombo->Select(i);
1429     fMaterialCombo->Resize(200, 20);
1430 }
1431
1432 void AliGuiGeomMain::AddMedium(AliGUIMedium *Medium, Int_t i)
1433 {
1434 // Add medium to medium combo
1435     char* tmp;
1436     tmp=Medium->Name();
1437     Medium->SetItemId(i);
1438     
1439     fMediaCombo->AddEntry(tmp, i);
1440     fMediaCombo->Select(i);
1441     fMediaCombo->Resize(200, 20);
1442 }
1443
1444
1445 AliGuiGeomDialog::AliGuiGeomDialog(const TGWindow *p, const TGWindow *main, UInt_t w,
1446                        UInt_t h, UInt_t options)
1447     : TGTransientFrame(p, main, w, h, options)
1448 {
1449    // Create a dialog window. A dialog window pops up with respect to its
1450    // "main" window.
1451
1452    fFrame1 = new TGHorizontalFrame(this, 60, 20, kFixedWidth);
1453
1454    fOkButton = new TGTextButton(fFrame1, "&Ok", 1);
1455    fOkButton->Associate(this);
1456    fCancelButton = new TGTextButton(fFrame1, "&Cancel", 2);
1457    fCancelButton->Associate(this);
1458
1459    fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,
1460                            2, 2, 2, 2);
1461    fL2 = new TGLayoutHints(kLHintsBottom | kLHintsRight, 2, 2, 5, 1);
1462
1463    fFrame1->AddFrame(fOkButton, fL1);
1464    fFrame1->AddFrame(fCancelButton, fL1); 
1465
1466    fFrame1->Resize(150, fOkButton->GetDefaultHeight());
1467    AddFrame(fFrame1, fL2);
1468
1469    //--------- create Tab widget and some composite frames for Tab testing
1470
1471    fTab = new TGTab(this, 300, 300);
1472    fL3 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
1473 //
1474 // Tab1: Sliders
1475 //
1476    TGCompositeFrame *tf = fTab->AddTab("Draw");
1477    fF1 = new AliGUISliders(tf, this, 60, 20);
1478    tf->AddFrame(fF1,fL3);
1479    
1480 // 
1481 // Tab2: Drawing Options
1482 //
1483    tf = fTab->AddTab("Options");
1484    fL1 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX,
1485                            200, 2, 2, 2);
1486    fF2 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
1487
1488    fF2->AddFrame(fChk1 = new TGCheckButton(fF2, "Shadow", 86), fL3);
1489    fF2->AddFrame(fChk2 = new TGCheckButton(fF2, "Hide  ", 87), fL3);
1490    fF2->AddFrame(fChk3 = new TGCheckButton(fF2, "Clip  ", 88), fL3);
1491
1492    fF2->AddFrame(fLabel1 = new TGLabel(fF2, "Fill"),fL3);
1493    
1494    fCombo = new TGComboBox(fF2, 89);
1495    fF2->AddFrame(fCombo, fL3);
1496
1497    tf->AddFrame(fF2, fL3);
1498
1499    int i;
1500    for (i = 0; i < 8; i++) {
1501       char tmp[20];
1502
1503       sprintf(tmp, "%i", i+1);
1504       fCombo->AddEntry(tmp, i+1);
1505    }
1506    fCombo->Select(1);
1507    fCombo->Resize(50, 20);
1508    fCombo->Associate(this);
1509
1510    fChk1->Associate(this);
1511    fChk2->Associate(this);
1512    fChk3->Associate(this);
1513 // 
1514 // Tab3: Seen Option
1515 //
1516    tf = fTab->AddTab("Seen");
1517    fF3 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
1518    fF3->AddFrame(fLabel2 = new TGLabel(fF3, "Seen"),fL3);
1519    fCombo2 = new TGComboBox(fF3, 90);
1520    fF3->AddFrame(fCombo2, fL3);
1521    tf->AddFrame(fF3, fL3);
1522
1523    for (i = 0; i < 4; i++) {
1524       char tmp[20];
1525
1526       sprintf(tmp, "%i", i-2);
1527       fCombo2->AddEntry(tmp, i+1);
1528    }
1529    fCombo2->Select(4);
1530    fCombo2->Resize(50, 20);
1531    fCombo2->Associate(this);
1532 // 
1533 // Tab4: Clip Box
1534 //
1535    tf = fTab->AddTab("ClipBox");
1536    //--- layout for buttons: top align, equally expand horizontally
1537    fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandY, 5, 5, 5, 5);
1538
1539    //--- layout for the frame: place at bottom, right aligned
1540    fBfly1 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
1541 //
1542 //  Frames
1543 //
1544 //  Slider1
1545    fF4 = new TGCompositeFrame(tf, 60, 20, kVerticalFrame);
1546        
1547    fHSframe1 = new TGHorizontalFrame(fF4, 400, 100, kFixedWidth);
1548
1549    fTbh11 = new TGTextBuffer(10);
1550    fTeh11 = new TGTextEntry(fHSframe1, fTbh11,1);
1551    fTbh11->AddText(0, "   0");
1552    fTeh11->Associate(this);
1553
1554    fTbh12 = new TGTextBuffer(10);
1555    fTeh12 = new TGTextEntry(fHSframe1, fTbh12,1);
1556    fTbh12->AddText(0, "2000");
1557    fTeh12->Associate(this);
1558     
1559    fDslider1 = new TGDoubleHSlider(fHSframe1, 400, kSlider1 | kScaleBoth, 1);
1560    fDslider1->Associate(this);
1561    fDslider1->SetRange(-2000, 2000);
1562    fDslider1->SetPosition(0, 2000);
1563    
1564    fSLabel1 = new TGLabel(fHSframe1, "xmin-xmax");
1565
1566    fHSframe1->AddFrame(fSLabel1, fBfly1);
1567    fHSframe1->AddFrame(fTeh11, fBfly1);
1568    fHSframe1->AddFrame(fTeh12, fBfly1);
1569    fHSframe1->AddFrame(fDslider1, fBfly1);
1570    
1571    fF4->AddFrame(fHSframe1, fBly);
1572
1573 //
1574    fHSframe2 = new TGHorizontalFrame(fF4, 400, 100, kFixedWidth);
1575
1576    fTbh21 = new TGTextBuffer(10);
1577    fTeh21 = new TGTextEntry(fHSframe2, fTbh21,1);
1578    fTbh21->AddText(0, "   0");
1579    fTeh21->Associate(this);
1580
1581    fTbh22 = new TGTextBuffer(10);
1582    fTeh22 = new TGTextEntry(fHSframe2, fTbh22,1);
1583    fTbh22->AddText(0, "2000");
1584    fTeh22->Associate(this);
1585
1586    fDslider2 = new TGDoubleHSlider(fHSframe2, 400, kSlider1 | kScaleBoth, 2);
1587    fDslider2->Associate(this);
1588    fDslider2->SetRange(-2000, 2000);
1589    fDslider2->SetPosition(0, 2000);
1590    
1591    fSLabel2 = new TGLabel(fHSframe2, "ymin-ymax");
1592
1593    fHSframe2->AddFrame(fSLabel2, fBfly1);
1594    fHSframe2->AddFrame(fTeh21, fBfly1);
1595    fHSframe2->AddFrame(fTeh22, fBfly1);
1596    fHSframe2->AddFrame(fDslider2, fBfly1);
1597    
1598    fF4->AddFrame(fHSframe2, fBly);
1599
1600 //
1601    fHSframe3 = new TGHorizontalFrame(fF4, 400, 100, kFixedWidth);
1602
1603    fTbh31 = new TGTextBuffer(10);
1604    fTeh31 = new TGTextEntry(fHSframe3, fTbh31,1);
1605    fTbh31->AddText(0, "   0");
1606    fTeh31->Associate(this);
1607
1608    fTbh32 = new TGTextBuffer(10);
1609    fTeh32 = new TGTextEntry(fHSframe3, fTbh32,1);
1610    fTbh32->AddText(0, "2000");
1611    fTeh32->Associate(this);
1612
1613    fDslider3 = new TGDoubleHSlider(fHSframe3, 400, kSlider1 | kScaleBoth, 3);
1614    fDslider3->Associate(this);
1615    fDslider3->SetRange(-2000, 2000);
1616    fDslider3->SetPosition(0, 2000);
1617    
1618    fSLabel3 = new TGLabel(fHSframe3, "zmin-zmax");
1619
1620    fHSframe3->AddFrame(fSLabel3, fBfly1);
1621    fHSframe3->AddFrame(fTeh31, fBfly1);
1622    fHSframe3->AddFrame(fTeh32, fBfly1);
1623    fHSframe3->AddFrame(fDslider3, fBfly1);
1624    
1625    fF4->AddFrame(fHSframe3, fBly);
1626    tf->AddFrame(fF4, fL3);
1627 //
1628 //
1629    TGLayoutHints *fL5 = new TGLayoutHints(kLHintsBottom | kLHintsExpandX |
1630                                           kLHintsExpandY, 2, 2, 5, 1);
1631    AddFrame(fTab, fL5);
1632
1633    MapSubwindows();
1634    Resize(GetDefaultSize());
1635
1636    // position relative to the parent's window
1637    Window_t wdum;
1638    int ax, ay;
1639    gVirtualX->TranslateCoordinates(main->GetId(), GetParent()->GetId(),
1640                           (((TGFrame *) main)->GetWidth() - fWidth) >> 1,
1641                           (((TGFrame *) main)->GetHeight() - fHeight) >> 1,
1642                           ax, ay, wdum);
1643    Move(ax, ay);
1644
1645    SetWindowName("Dialog");
1646
1647    MapWindow();
1648    //gClient->WaitFor(this);    // otherwise canvas contextmenu does not work
1649 }
1650
1651 AliGuiGeomDialog::~AliGuiGeomDialog()
1652 {
1653    // Delete test dialog widgets.
1654
1655    delete fOkButton;
1656    delete fCancelButton;
1657    delete fFrame1;
1658    delete fChk1; delete fChk2;
1659    delete fF1; delete fF2; delete fF3; delete fF4;
1660    delete fCombo;
1661    delete fTab;
1662    delete fL3; delete fL4;
1663    delete fL1; delete fL2;
1664    delete fBly; delete fBfly1;
1665    delete fTbh11; delete fTbh12; delete fTbh21; delete fTbh22; 
1666    delete fTbh31; delete fTbh32; delete fTeh11; delete fTeh12; 
1667    delete fTeh21; delete fTeh22; delete fTeh31; delete fTeh32;
1668    delete fDslider1; delete fDslider2; delete fDslider3;
1669    delete fSLabel1;  delete fSLabel2;  delete fSLabel3;
1670 }
1671
1672 void AliGuiGeomDialog::Update()
1673 {
1674 // Update widgets
1675     
1676     Float_t param;
1677 //  Update Sliders
1678     if (fF1) {
1679         fF1->Update();
1680     }
1681 //  Seen
1682     if (fCombo2) {
1683         param=gCurrentVolume->GetParam(kSeen);
1684         fCombo2->Select(Int_t(param)+3);
1685     }
1686 //  Hide, Shadow, Clip
1687     if (fChk1) {
1688         if (Int_t(gCurrentVolume->GetParam(kShadow))) {
1689             fChk1->SetState(kButtonDown);
1690         } else {
1691             fChk1->SetState(kButtonUp);
1692         }
1693     }
1694
1695     if (fChk2) {
1696         if (Int_t(gCurrentVolume->GetParam(kHide))) {
1697             fChk2->SetState(kButtonDown);
1698         } else {
1699             fChk2->SetState(kButtonUp);
1700         }
1701     }
1702
1703     if (fChk3) {
1704         if (Int_t(gCurrentVolume->GetParam(kClip))) {
1705             fChk3->SetState(kButtonDown);
1706         } else {
1707             fChk3->SetState(kButtonUp);
1708         }
1709     }
1710     
1711 }
1712
1713 void AliGuiGeomDialog::CloseWindow()
1714 {
1715    // Called when window is closed via the window manager.
1716    delete this;
1717 }
1718
1719 Bool_t AliGuiGeomDialog::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
1720 {
1721    // Process messages coming from widgets associated with the dialog.
1722     char buf[10];
1723     Float_t min,max;
1724     switch (GET_MSG(msg)) {
1725     case kC_HSLIDER:
1726         switch (GET_SUBMSG(msg)) {
1727         case kSL_POS:
1728             switch (Int_t(parm1)) {
1729             case 1:
1730                 min=fDslider1->GetMinPosition();
1731                 max=fDslider1->GetMaxPosition();
1732                 sprintf(buf, "%6.2f", min);
1733                 fTbh11->Clear();
1734                 fTbh11->AddText(0, buf);
1735                 sprintf(buf, "%6.2f", max);
1736                 fTbh12->Clear();
1737                 fTbh12->AddText(0, buf);
1738                 gClient->NeedRedraw(fTeh11);
1739                 gClient->NeedRedraw(fTeh12);
1740                 gCurrentVolume->SetParam(kClipXmin,min);
1741                 gCurrentVolume->SetParam(kClipXmax,max);
1742                 break;
1743             case 2:
1744                 min=fDslider2->GetMinPosition();
1745                 max=fDslider2->GetMaxPosition();
1746                 sprintf(buf, "%6.2f", min);
1747                 fTbh21->Clear();
1748                 fTbh21->AddText(0, buf);
1749                 sprintf(buf, "%6.2f", max);
1750                 fTbh22->Clear();
1751                 fTbh22->AddText(0, buf);
1752                 gClient->NeedRedraw(fTeh21);
1753                 gClient->NeedRedraw(fTeh22);
1754                 gCurrentVolume->SetParam(kClipYmin,min);
1755                 gCurrentVolume->SetParam(kClipYmax,max);
1756                 break;
1757             case 3:
1758                 min=fDslider3->GetMinPosition();
1759                 max=fDslider3->GetMaxPosition();
1760                 sprintf(buf, "%6.2f", min);
1761                 fTbh31->Clear();
1762                 fTbh31->AddText(0, buf);
1763                 sprintf(buf, "%6.2f", max);
1764                 fTbh32->Clear();
1765                 fTbh32->AddText(0, buf);
1766                 gClient->NeedRedraw(fTeh31);
1767                 gClient->NeedRedraw(fTeh32);
1768                 gCurrentVolume->SetParam(kClipZmin,min);
1769                 gCurrentVolume->SetParam(kClipZmax,max);
1770                 break;
1771             default:
1772                 break;
1773             }
1774         }
1775         break;
1776     case kC_COMMAND:
1777         switch (GET_SUBMSG(msg)) {
1778         case kCM_BUTTON:
1779             switch(parm1) {
1780             case 1:
1781             case 2:
1782                 printf("\nTerminating dialog: %s pressed\n",
1783                        (parm1 == 1) ? "OK" : "Cancel");
1784                 CloseWindow();
1785                 break;
1786             }
1787             break;
1788         case kCM_COMBOBOX:
1789             switch(parm1) {
1790             case 89:
1791                 gCurrentVolume->SetParam(kFill, Float_t(parm2));
1792                 gCurrentVolume->Draw();
1793                 break;
1794             case 90:
1795                 gCurrentVolume->SetParam(kSeen, Float_t(parm2-3));
1796                 gCurrentVolume->Draw();
1797                 break;
1798             }
1799             break;
1800         case kCM_CHECKBUTTON:
1801             switch (parm1) {
1802             case 86:
1803                 if (Int_t(gCurrentVolume->GetParam(kShadow))) {
1804                     gCurrentVolume->SetParam(kShadow, 0.);
1805                 } else {
1806                     gCurrentVolume->SetParam(kShadow, 1.);
1807                 }
1808                 gCurrentVolume->Draw();
1809                 break;
1810             case 87:
1811                 if (Int_t(gCurrentVolume->GetParam(kHide))) {
1812                     gCurrentVolume->SetParam(kHide, 0.);
1813                 } else {
1814                     gCurrentVolume->SetParam(kHide, 1.);
1815                 }
1816                 gCurrentVolume->Draw();
1817                 break;
1818             case 88:
1819                 if (Int_t(gCurrentVolume->GetParam(kClip))) {
1820                     gCurrentVolume->SetParam(kClip, 0.);
1821                 } else {
1822                     gCurrentVolume->SetParam(kClip, 1.);
1823                 }
1824                 gCurrentVolume->Draw();
1825                 break;
1826
1827             default:
1828                 break;
1829             }
1830             break;
1831         case kCM_TAB:
1832             break;
1833         default:
1834             break;
1835         }
1836         break;
1837     default:
1838         break;
1839     }
1840     return kTRUE;
1841 }
1842
1843 static Text_t* kLabelText[7]  = 
1844 {"Theta  ", "Phi    ", "Psi    ", "U      ", "V      ", "UScale", "VScale"};
1845 static Int_t   IRangeMin[7]  = {    0,     0,     0,    0,    0,   0,   0};
1846 static Int_t   IRangeMax[7]  = {36000, 36000, 36000, 2000, 2000, 10, 10};
1847 static Int_t   DefaultPos[7] = { 3000,  4000,     0, 1000, 1000,   1,   1};
1848
1849 AliGUISliders::AliGUISliders(const TGWindow *p, const TGWindow *,
1850                          UInt_t w, UInt_t h) :
1851     TGCompositeFrame(p, w, h,kVerticalFrame)
1852 {
1853 // Constructor
1854     ChangeOptions((GetOptions() & ~kHorizontalFrame) | kVerticalFrame);
1855    //--- layout for buttons: top align, equally expand horizontally
1856     fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandY, 5, 5, 5, 5);
1857
1858    //--- layout for the frame: place at bottom, right aligned
1859     fBfly1 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX );
1860 //
1861 // Frames
1862
1863    for (Int_t i=0; i<7; i++) {
1864        Int_t idT=i+1;
1865        Int_t idS=i+8;       
1866        fHframe[i] = new TGHorizontalFrame(this, 400, 100, kFixedWidth);
1867        fTbh[i] = new TGTextBuffer(10);
1868        fTeh[i] = new TGTextEntry(fHframe[i], fTbh[i],idT);
1869        char buf[10];
1870        sprintf(buf, "%6.2f", Float_t(DefaultPos[i])/100);
1871        fTbh[i]->AddText(0, buf);
1872        fTeh[i]->Associate(this);
1873        
1874        fHslider[i] = new TGHSlider(fHframe[i], 400, kSlider1 | kScaleBoth, idS);
1875        fHslider[i]->Associate(this);
1876        fHslider[i]->SetRange(IRangeMin[i], IRangeMax[i]);
1877        fHslider[i]->SetPosition(DefaultPos[i]);
1878
1879        fLabel[i] = new TGLabel(fHframe[i], kLabelText[i]);
1880        
1881        
1882        fHframe[i]->AddFrame(fLabel[i], fBfly1);
1883        fHframe[i]->AddFrame(fTeh[i], fBfly1);
1884        fHframe[i]->AddFrame(fHslider[i], fBfly1);
1885        AddFrame(fHframe[i], fBly);
1886    }
1887 }
1888
1889 AliGUISliders::~AliGUISliders()
1890 {
1891 // Destructor
1892     delete fBfly1; delete fBly;
1893    // Delete dialog.
1894     for (Int_t i=1; i<7; i++) {
1895         delete fHframe[i];
1896         delete fHslider[i];
1897         delete fTeh[i];
1898         delete fTbh[i]; 
1899     }
1900 }
1901
1902 void AliGUISliders::Update()
1903 {
1904 // Update sliders
1905     char buf[10];
1906     
1907     for (Int_t i=0; i<7; i++) {
1908         Float_t param = gCurrentVolume->GetParam(i);
1909 //
1910         fHslider[i]->SetPosition(Int_t(param*100.));
1911         gClient->NeedRedraw(fHslider[i]);
1912 //
1913         sprintf(buf, "%6.2f", param);
1914         fTbh[i]->Clear();
1915         fTbh[i]->AddText(0, buf);
1916         gClient->NeedRedraw(fTeh[i]);
1917 //
1918     }
1919
1920     
1921 }
1922
1923 void AliGUISliders::CloseWindow()
1924 {
1925    // Called when window is closed via the window manager.
1926
1927    delete this;
1928 }
1929
1930 Bool_t AliGUISliders::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
1931 {
1932    // Process slider messages.
1933
1934    char buf[10];
1935
1936    switch (GET_MSG(msg)) {
1937    case kC_TEXTENTRY:
1938        switch (GET_SUBMSG(msg)) {
1939        case kTE_TEXTCHANGED:
1940            Int_t idT=Int_t(parm1)-1;
1941            fHslider[idT]->SetPosition((Int_t)atof(fTbh[idT]->GetString())*100);
1942            gClient->NeedRedraw(fHslider[idT]);
1943            gCurrentVolume->SetParam(idT,atof(fTbh[idT]->GetString()));
1944            gCurrentVolume->Draw();
1945        }
1946        break;
1947    case kC_HSLIDER:
1948        switch (GET_SUBMSG(msg)) {
1949        case kSL_POS:
1950            sprintf(buf, "%6.2f", Float_t(parm2)/100);
1951            Int_t idS=Int_t(parm1)-8;
1952            fTbh[idS]->Clear();
1953            fTbh[idS]->AddText(0, buf);
1954            gClient->NeedRedraw(fTeh[idS]);
1955            gCurrentVolume->SetParam(idS, Float_t(parm2)/100.);
1956            gCurrentVolume->Draw();
1957        }
1958        break;
1959    }
1960    return kTRUE;
1961 }
1962
1963 ClassImp(AliGUIMaterial)
1964
1965 AliGUIMaterial::AliGUIMaterial()
1966
1967 // Constructor
1968     fId=-1;
1969     fName = 0; 
1970     fA=-1; 
1971     fZ=-1; 
1972     fDensity=-1;
1973     fRadl=-1;   
1974     fAbsl=-1;    
1975 }
1976
1977 AliGUIMaterial::AliGUIMaterial(Int_t imat, char* name, Float_t a, Float_t z,
1978                    Float_t dens, Float_t radl, Float_t absl)
1979
1980 // Constructor
1981     fId=imat;
1982     fName=name;
1983     fA=a; 
1984     fZ=z; 
1985     fDensity=dens;
1986     fRadl=radl;   
1987     fAbsl=absl;    
1988 }
1989 void AliGUIMaterial::Dump()
1990 {
1991 // Dump material information
1992     printf("\n *****************************************");
1993     printf("\n Material Number:   %10d", fId);
1994     printf("\n %s", fName);
1995     printf("\n Mass   Number:     %10.2f", fA);    
1996     printf("\n Charge Number:     %10.2f", fZ);
1997     printf("\n Density:           %10.2f", fDensity);
1998     printf("\n Radiation  Length: %10.2f", fRadl);
1999     printf("\n Absorption Length: %10.2f", fAbsl);              
2000 }
2001
2002 Int_t AliGUIMaterial::Id()
2003 {
2004 // return material id
2005     return fId;
2006 }
2007
2008 char*  AliGUIMaterial::Name()
2009 {
2010 // return material name 
2011     return fName;
2012 }
2013
2014 Float_t  AliGUIMaterial::A()
2015 {
2016 // return atomic number
2017     return fA;
2018 }
2019
2020 Float_t  AliGUIMaterial::Z()
2021 {
2022 // return charge number
2023     return fZ;
2024 }
2025
2026 Float_t  AliGUIMaterial::Density()
2027 {
2028 // return density
2029     return fDensity;
2030 }
2031
2032 Float_t  AliGUIMaterial::RadiationLength()
2033 {
2034 // return radiation length
2035     return fRadl;
2036 }
2037
2038 Float_t  AliGUIMaterial::AbsorptionLength()
2039 {
2040 // return absorption length
2041     return fAbsl;
2042 }
2043
2044
2045 void AliGUIMaterial::Plot()
2046 {
2047 // dummy plot routine
2048     ;
2049 }
2050
2051 void AliGUIMaterial::Streamer(TBuffer &)
2052 {
2053 // dummy streamner
2054 ;
2055 }
2056
2057 ClassImp(AliGUIMedium)
2058
2059 AliGUIMedium::AliGUIMedium()
2060
2061 // constructor
2062     fId=-1;
2063     fName = 0; 
2064 }
2065
2066 AliGUIMedium::AliGUIMedium(Int_t imed, Int_t imat, char* name, Int_t isvol, 
2067                            Int_t ifield,
2068                            Float_t fieldm, Float_t tmaxfd, Float_t stemax, Float_t deemax,
2069                            Float_t epsil, Float_t stmin)
2070 {
2071 // constructor
2072     fId=imed;
2073     fIdMat=imat;
2074     fName=name;
2075     fIsvol=isvol;
2076     fIfield=ifield;
2077     fFieldm=fieldm;
2078     fTmaxfd=tmaxfd;
2079     fStemax=stemax;
2080     fDeemax=deemax;
2081     fEpsil=epsil;
2082     fStmin=stmin;
2083 }
2084
2085 void AliGUIMedium::Dump()
2086 {
2087 // Dummy dump
2088     ;
2089 }
2090
2091 Int_t AliGUIMedium::Id()
2092 {
2093 // return medium id
2094     return fId;
2095 }
2096
2097 char*  AliGUIMedium::Name()
2098 {
2099 // return medium name
2100     return fName;
2101 }
2102
2103 Float_t AliGUIMedium::GetPar(Int_t ipar)
2104
2105 // Get parameter number ipar
2106     Float_t p;
2107     if (ipar < 23) {
2108         p= fPars[ipar-1];   
2109     } else if(ipar >=23 && ipar <27) {
2110         p= fPars[ipar-1+3];   
2111     } else {
2112         p= fPars[ipar-1+4];   
2113     }
2114     
2115     return p;
2116 }
2117  
2118 void AliGUIMedium::Streamer(TBuffer &)
2119 {
2120 // dummy streamer
2121 ;
2122 }
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137