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