Logo ROOT   6.08/07
Reference Guide
TGeoManagerEditor.cxx
Go to the documentation of this file.
1 // @(#):$Id$
2 // Author: M.Gheata
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 //////////////////////////////////////////////////////////////////////////
13 // //
14 // TGeoManagerEditor //
15 //
16 //////////////////////////////////////////////////////////////////////////
17 /*
18  Editor for TGeoManager class. Provides also builder functionality for the
19  main TGeo objects: TGeoVolume, TGeoShape - derived classes, TGeoMaterial,
20  TGeoMatrix - derived transformations and TGeoMedium.
21  The GUI represents the main entry point for editing geometry classes. It
22  can be started either by:
23  1. TGeoManager::Edit(). The method must be used when starting from a new
24  geometry.
25  2. Left-click on the 40x40 pixels top-right corner of a pad containing a
26  drawn volume. The region is always accesible when drawing geometry elements
27  and allows also restoring the manager editor in the "Style" tab of the GED
28  editor anytime.
29 
30  The TGeoManager editor is vertically split by a TGShutter widget into the
31  following categories:
32 
33  - General. This allows changing the name/title of the geometry, setting the
34  top volume, closing the geometry and saving the geometry in a file. The name
35  of the geometry file is formed by geometry_name.C/.root depending if the geometry
36  need to be saved as a C macro or a .root file.
37  - Shapes. The category provide buttons for creation of all supported shapes. The
38  new shape name is chosen by the interface, but can be changed from the shape
39  editor GUI. Existing shapes can be browsed and edited from the same category.
40  - Volumes. The category allows the creation of a new volume having a given name,
41  shape and medium. For creating a volume assembly only the name is relevant.
42  Existing volumes can be browsed or edited from this category.
43  - Materials. Allows creation of new materials/mixtures or editing existing ones.
44  - Media. The same for creation/editing of tracking media (materials having a set
45  of properties related to tracking)
46  - Matrices. Allows creation of translations, rotations or combined transformations.
47  Existing matrices can also be browser/edited.
48 */
49 
50 #include "TVirtualPad.h"
51 #include "TCanvas.h"
52 #include "TBaseClass.h"
53 #include "TGTab.h"
54 #include "TG3DLine.h"
55 #include "TGComboBox.h"
56 #include "TGButton.h"
57 #include "TGButtonGroup.h"
58 #include "TGTextEntry.h"
59 #include "TGNumberEntry.h"
60 #include "TGLabel.h"
61 #include "TGShutter.h"
62 
63 #include "TGeoVolumeEditor.h"
64 #include "TGeoNodeEditor.h"
65 #include "TGeoTabManager.h"
66 #include "TGeoVolume.h"
67 #include "TGeoManager.h"
68 #include "TGeoMatrix.h"
69 #include "TGeoBBox.h"
70 #include "TGeoPara.h"
71 #include "TGeoArb8.h"
72 #include "TGeoTube.h"
73 #include "TGeoEltu.h"
74 #include "TGeoHype.h"
75 #include "TGeoTorus.h"
76 #include "TGeoTrd1.h"
77 #include "TGeoTrd2.h"
78 #include "TGeoCone.h"
79 #include "TGeoSphere.h"
80 #include "TGeoPcon.h"
81 #include "TGeoPgon.h"
82 #include "TGeoElement.h"
83 #include "TGeoMaterial.h"
84 #include "TView.h"
85 
86 #include "TGeoManagerEditor.h"
87 #include "TGedEditor.h"
88 
89 ClassImp(TGeoManagerEditor)
90 
91 enum ETGeoVolumeWid {
92  kMANAGER_NAME, kMANAGER_TITLE,
93  kMANAGER_SHAPE_SELECT, kMANAGER_MEDIA_SELECT,kMANAGER_MATERIAL_SELECT, kMANAGER_ELEMENT_SELECT,
94  kMANAGER_SHAPE_SELECT2, kMANAGER_MEDIUM_SELECT2, kMANAGER_VOLUME_SELECT,
95  kMANAGER_EDIT_SHAPE, kMANAGER_EDIT_MEDIUM, kMANAGER_DENSITY_SELECT, kMANAGER_NELEM_SELECT,
96  kMANAGER_MATERIAL_SELECT2, kMANAGER_MEDIUM_SELECT, kMANAGER_MATRIX_SELECT, kMANAGER_TOP_SELECT,
97  kEXPORT_ROOT, kEXPORT_C, kEXPORT_GEOMETRY,
98  kCAT_GENERAL, kCAT_SHAPES, kCAT_VOLUMES, kCAT_MEDIA, kCAT_MATERIALS, kCAT_MATRICES,
99  kCREATE_BOX, kCREATE_PARA, kCREATE_TRD1, kCREATE_TRD2,
100  kCREATE_TRAP, kCREATE_GTRA, kCREATE_XTRU, kCREATE_ARB8,
101  kCREATE_TUBE, kCREATE_TUBS, kCREATE_CONE, kCREATE_CONS,
102  kCREATE_SPHE, kCREATE_CTUB, kCREATE_ELTU, kCREATE_TORUS,
103  kCREATE_PCON, kCREATE_PGON, kCREATE_HYPE, kCREATE_PARAB, kCREATE_COMP,
104  kCREATE_MATERIAL, kCREATE_MIXTURE, kCREATE_MEDIUM, kCREATE_VOLUME, kCREATE_ASSEMBLY,
105  kCREATE_TRANSLATION, kCREATE_ROTATION, kCREATE_COMBI,
106  kMEDIUM_NAME, kMEDIUM_ID, kMATRIX_NAME, kMATERIAL_NAME, kVOLUME_NAME,
107  kMANAGER_APPLY, kMANAGER_CANCEL, kMANAGER_UNDO
108 };
109 
110 ////////////////////////////////////////////////////////////////////////////////
111 /// Constructor for manager editor.
112 
113 TGeoManagerEditor::TGeoManagerEditor(const TGWindow *p, Int_t width,
114  Int_t height, UInt_t options, Pixel_t back)
115  : TGedFrame(p, width, height, options | kVerticalFrame, back)
116 {
117  fGeometry = gGeoManager;
118  fTabMgr = 0;
119  fTab = 0;
120  fConnectedCanvas = 0;
121 
122  fIsModified = kFALSE;
123  TGCompositeFrame *f1;
124  TGLabel *label;
125 
126  // TGShutter for categories
127  fCategories = new TGShutter(this, kSunkenFrame | kFixedHeight);
128 
129  TGCompositeFrame *container;
130  Pixel_t color;
131  // General settings
132  TGShutterItem *si = new TGShutterItem(fCategories, new TGHotString("General"),kCAT_GENERAL);
133  container = (TGCompositeFrame*)si->GetContainer();
134  container->SetBackgroundColor(GetDefaultFrameBackground());
135  fCategories->AddItem(si);
136  // TextEntry for manager name
137  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
138  f1->AddFrame(label = new TGLabel(f1, "Name/Title"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
139  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
140  gClient->GetColorByName("#ff0000", color);
141  label->SetTextColor(color);
142  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
143  fManagerName = new TGTextEntry(container, new TGTextBuffer(50), kMANAGER_NAME);
144  fManagerName->Resize(135, fManagerName->GetDefaultHeight());
145  fManagerName->SetToolTipText("Enter the geometry name");
146  container->AddFrame(fManagerName, new TGLayoutHints(kLHintsLeft, 3, 1, 0, 0));
147  fManagerTitle = new TGTextEntry(container, new TGTextBuffer(50), kMANAGER_TITLE);
148  fManagerTitle->Resize(135, fManagerTitle->GetDefaultHeight());
149  fManagerTitle->SetToolTipText("Enter the geometry name");
150  container->AddFrame(fManagerTitle, new TGLayoutHints(kLHintsLeft, 3, 1, 0, 0));
151  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
152  f1->AddFrame(label = new TGLabel(f1, "Export geometry"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
153  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
154  gClient->GetColorByName("#ff0000", color);
155  label->SetTextColor(color);
156  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 6, 0));
157  TString stitle = "Options";
158  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
159  TGButtonGroup *bg = new TGVButtonGroup(f1, stitle);
160  fExportOption[0] = new TGRadioButton(bg, ".root", kEXPORT_ROOT);
161  fExportOption[1] = new TGRadioButton(bg, ".C", kEXPORT_C);
162  fExportButton = new TGTextButton(f1, "Export", kEXPORT_GEOMETRY);
163  bg->SetRadioButtonExclusive();
164  bg->SetButton(kEXPORT_ROOT);
165  bg->Show();
166  f1->AddFrame(bg, new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
167  f1->AddFrame(fExportButton, new TGLayoutHints(kLHintsLeft, 20, 2, 22, 0));
168  container->AddFrame(f1, new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 2, 2));
169  // Close geometry
170  f7 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);
171  f1 = new TGCompositeFrame(f7, 155, 10, kHorizontalFrame | kFixedWidth);
172  f1->AddFrame(label = new TGLabel(f1, "Close geometry"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
173  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
174  gClient->GetColorByName("#ff0000", color);
175  label->SetTextColor(color);
176  f7->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
177  f1 = new TGCompositeFrame(f7, 155, 30, kHorizontalFrame | kFixedWidth);
178  fLSelTop = new TGLabel(f1, "Select top");
179  gClient->GetColorByName("#0000ff", color);
180  fLSelTop->SetTextColor(color);
181  fLSelTop->ChangeOptions(kSunkenFrame | kDoubleBorder);
182  f1->AddFrame(fLSelTop, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
183  fBSelTop = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_TOP_SELECT);
184  fBSelTop->SetToolTipText("Select the top volume");
185  fBSelTop->Associate(this);
186  f1->AddFrame(fBSelTop, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));
187  fCloseGeometry = new TGTextButton(f1, "Close");
188  f1->AddFrame(fCloseGeometry, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));
189  fCloseGeometry->SetToolTipText("Close geometry to make it ready for tracking");
190  fCloseGeometry->Associate(this);
191  f7->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
192  container->AddFrame(f7, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
193 
194 
195  si = new TGShutterItem(fCategories, new TGHotString("Shapes"),kCAT_SHAPES);
196  container = (TGCompositeFrame*)si->GetContainer();
197  container->SetBackgroundColor(GetDefaultFrameBackground());
198  fCategories->AddItem(si);
199 
200  // Shape creators
201  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
202  f1->AddFrame(label = new TGLabel(f1, "Create new shape"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
203  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
204  gClient->GetColorByName("#ff0000", color);
205  label->SetTextColor(color);
206  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
207  TGLayoutHints *lhb = new TGLayoutHints(kLHintsLeft, 0, 4, 0, 0);
208  TGLayoutHints *lhf1 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 2, 2);
209  Int_t ipict;
210  f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);
211  fShapeButton[0] = new TGPictureButton(f1, fClient->GetPicture("geobbox_t.xpm"), kCREATE_BOX);
212  fShapeButton[0]->SetToolTipText("Create a box");
213  fShapeButton[1] = new TGPictureButton(f1, fClient->GetPicture("geopara_t.xpm"), kCREATE_PARA);
214  fShapeButton[1]->SetToolTipText("Create a parallelipiped");
215  fShapeButton[2] = new TGPictureButton(f1, fClient->GetPicture("geotrd1_t.xpm"), kCREATE_TRD1);
216  fShapeButton[2]->SetToolTipText("Create a TRD1 trapezoid");
217  fShapeButton[3] = new TGPictureButton(f1, fClient->GetPicture("geotrd2_t.xpm"), kCREATE_TRD2);
218  fShapeButton[3]->SetToolTipText("Create a TRD2 trapezoid");
219  fShapeButton[4] = new TGPictureButton(f1, fClient->GetPicture("geotrap_t.xpm"), kCREATE_TRAP);
220  fShapeButton[4]->SetToolTipText("Create a general trapezoid");
221  fShapeButton[5] = new TGPictureButton(f1, fClient->GetPicture("geogtra_t.xpm"), kCREATE_GTRA);
222  fShapeButton[5]->SetToolTipText("Create a general twisted trapezoid");
223  for (ipict=0; ipict<6; ipict++) f1->AddFrame(fShapeButton[ipict],lhb);
224  container->AddFrame(f1, lhf1);
225  f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);
226  fShapeButton[6] = new TGPictureButton(f1, fClient->GetPicture("geoxtru_t.xpm"), kCREATE_XTRU);
227  fShapeButton[6]->SetToolTipText("Create a extruded polygone");
228  fShapeButton[7] = new TGPictureButton(f1, fClient->GetPicture("geoarb8_t.xpm"), kCREATE_ARB8);
229  fShapeButton[7]->SetToolTipText("Create an arbitrary trapezoid with 8 vertices");
230  fShapeButton[8] = new TGPictureButton(f1, fClient->GetPicture("geotube_t.xpm"), kCREATE_TUBE);
231  fShapeButton[8]->SetToolTipText("Create a cylindrical pipe");
232  fShapeButton[9] = new TGPictureButton(f1, fClient->GetPicture("geotubeseg_t.xpm"), kCREATE_TUBS);
233  fShapeButton[9]->SetToolTipText("Create a cylindrical pipe within a phi range");
234  fShapeButton[10] = new TGPictureButton(f1, fClient->GetPicture("geocone_t.xpm"), kCREATE_CONE);
235  fShapeButton[10]->SetToolTipText("Create a conical pipe");
236  fShapeButton[11] = new TGPictureButton(f1, fClient->GetPicture("geoconeseg_t.xpm"), kCREATE_CONS);
237  fShapeButton[11]->SetToolTipText("Create a conical pipe within a phi range");
238  for (ipict=0; ipict<6; ipict++) f1->AddFrame(fShapeButton[ipict+6],lhb);
239  container->AddFrame(f1, lhf1);
240  f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);
241  fShapeButton[12] = new TGPictureButton(f1, fClient->GetPicture("geosphere_t.xpm"), kCREATE_SPHE);
242  fShapeButton[12]->SetToolTipText("Create a spherical sector");
243  fShapeButton[13] = new TGPictureButton(f1, fClient->GetPicture("geoctub_t.xpm"), kCREATE_CTUB);
244  fShapeButton[13]->SetToolTipText("Create a cut tube");
245  fShapeButton[14] = new TGPictureButton(f1, fClient->GetPicture("geoeltu_t.xpm"), kCREATE_ELTU);
246  fShapeButton[14]->SetToolTipText("Create an eliptical tube");
247  fShapeButton[15] = new TGPictureButton(f1, fClient->GetPicture("geotorus_t.xpm"), kCREATE_TORUS);
248  fShapeButton[15]->SetToolTipText("Create a toroidal tube with a phi range");
249  fShapeButton[16] = new TGPictureButton(f1, fClient->GetPicture("geopcon_t.xpm"), kCREATE_PCON);
250  fShapeButton[16]->SetToolTipText("Create a polycone shape");
251  fShapeButton[17] = new TGPictureButton(f1, fClient->GetPicture("geopgon_t.xpm"), kCREATE_PGON);
252  fShapeButton[17]->SetToolTipText("Create a polygon shape");
253  for (ipict=0; ipict<6; ipict++) f1->AddFrame(fShapeButton[ipict+12],lhb);
254  container->AddFrame(f1, lhf1);
255  f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);
256  fShapeButton[18] = new TGPictureButton(f1, fClient->GetPicture("geohype_t.xpm"), kCREATE_HYPE);
257  fShapeButton[18]->SetToolTipText("Create a hyperboloid");
258  fShapeButton[19] = new TGPictureButton(f1, fClient->GetPicture("geoparab_t.xpm"), kCREATE_PARAB);
259  fShapeButton[19]->SetToolTipText("Create a paraboloid");
260  fShapeButton[20] = new TGPictureButton(f1, fClient->GetPicture("geocomposite_t.xpm"), kCREATE_COMP);
261  fShapeButton[20]->SetToolTipText("Create a composite shape");
262  for (ipict=0; ipict<3; ipict++) f1->AddFrame(fShapeButton[ipict+18],lhb);
263  container->AddFrame(f1, lhf1);
264 
265  // List of shapes
266  f2 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);
267  f1 = new TGCompositeFrame(f2, 155, 10, kHorizontalFrame | kFixedWidth);
268  f1->AddFrame(label = new TGLabel(f1, "Existing shapes"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
269  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
270  gClient->GetColorByName("#ff0000", color);
271  label->SetTextColor(color);
272  f2->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));
273  f1 = new TGCompositeFrame(f2, 155, 30, kHorizontalFrame | kFixedWidth);
274  fSelectedShape = 0;
275  fLSelShape = new TGLabel(f1, "Select shape");
276  gClient->GetColorByName("#0000ff", color);
277  fLSelShape->SetTextColor(color);
278  fLSelShape->ChangeOptions(kSunkenFrame | kDoubleBorder);
279  f1->AddFrame(fLSelShape, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
280  fBSelShape = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_SHAPE_SELECT);
281  fBSelShape->SetToolTipText("Select one of the existing shapes");
282  fBSelShape->Associate(this);
283  f1->AddFrame(fBSelShape, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));
284  fEditShape = new TGTextButton(f1, "Edit");
285  f1->AddFrame(fEditShape, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));
286  fEditShape->SetToolTipText("Edit selected shape");
287  fEditShape->Associate(this);
288  f2->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
289  container->AddFrame(f2, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));
290 
291  // Volumes category
292  si = new TGShutterItem(fCategories, new TGHotString("Volumes"),kCAT_VOLUMES);
293  container = (TGCompositeFrame*)si->GetContainer();
294  container->SetBackgroundColor(GetDefaultFrameBackground());
295  fCategories->AddItem(si);
296 
297  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
298  f1->AddFrame(label = new TGLabel(f1, "Create new volume"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
299  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
300  gClient->GetColorByName("#ff0000", color);
301  label->SetTextColor(color);
302  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
303 
304  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
305  f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
306  fVolumeName = new TGTextEntry(f1, new TGTextBuffer(50), kVOLUME_NAME);
307  fVolumeName->Resize(100, fVolumeName->GetDefaultHeight());
308  fVolumeName->SetToolTipText("Enter the name for the new volume");
309  f1->AddFrame(fVolumeName, new TGLayoutHints(kLHintsRight, 3, 1, 2, 5));
310  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));
311 
312  // ComboBox for shape component
313  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
314  fSelectedShape2 = 0;
315  fLSelShape2 = new TGLabel(f1, "Select shape");
316  gClient->GetColorByName("#0000ff", color);
317  fLSelShape2->SetTextColor(color);
318  fLSelShape2->ChangeOptions(kSunkenFrame | kDoubleBorder);
319  f1->AddFrame(fLSelShape2, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
320  fBSelShape2 = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_SHAPE_SELECT2);
321  fBSelShape2->SetToolTipText("Select one of the existing shapes");
322  fBSelShape2->Associate(this);
323  f1->AddFrame(fBSelShape2, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
324  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));
325 
326  // ComboBox for medium component
327  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
328  fSelectedMedium2 = 0;
329  fLSelMedium2 = new TGLabel(f1, "Select medium");
330  gClient->GetColorByName("#0000ff", color);
331  fLSelMedium2->SetTextColor(color);
332  fLSelMedium2->ChangeOptions(kSunkenFrame | kDoubleBorder);
333  f1->AddFrame(fLSelMedium2, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
334  fBSelMedium2 = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MEDIUM_SELECT2);
335  fBSelMedium2->SetToolTipText("Select one of the existing media");
336  fBSelMedium2->Associate(this);
337  f1->AddFrame(fBSelMedium2, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));
338  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));
339  // Picture buttons for different volumes
340  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
341  f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));
342  fVolumeButton[0] = new TGPictureButton(f1, fClient->GetPicture("geovolume_t.xpm"), kCREATE_VOLUME);
343  fVolumeButton[0]->SetToolTipText("Create a new volume from shape and medium");
344  fVolumeButton[1] = new TGPictureButton(f1, fClient->GetPicture("geoassembly_t.xpm"), kCREATE_ASSEMBLY);
345  fVolumeButton[1]->SetToolTipText("Create a new volume assemby having the selected name");
346  for (ipict=0; ipict<2; ipict++) f1->AddFrame(fVolumeButton[ipict],lhb);
347  container->AddFrame(f1, lhf1);
348  // List of volumes
349  f3 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);
350  f1 = new TGCompositeFrame(f3, 155, 10, kHorizontalFrame | kFixedWidth);
351  f1->AddFrame(label = new TGLabel(f1, "Existing volumes"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
352  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
353  gClient->GetColorByName("#ff0000", color);
354  label->SetTextColor(color);
355  f3->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));
356  f1 = new TGCompositeFrame(f3, 155, 30, kHorizontalFrame | kFixedWidth);
357  fSelectedVolume = 0;
358  fLSelVolume = new TGLabel(f1, "Select volume");
359  gClient->GetColorByName("#0000ff", color);
360  fLSelVolume->SetTextColor(color);
361  fLSelVolume->ChangeOptions(kSunkenFrame | kDoubleBorder);
362  f1->AddFrame(fLSelVolume, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
363  fBSelVolume = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_VOLUME_SELECT);
364  fBSelVolume->SetToolTipText("Select one of the existing volumes");
365  fBSelVolume->Associate(this);
366  f1->AddFrame(fBSelVolume, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));
367  f3->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));
368  f1 = new TGCompositeFrame(f3, 155, 30, kHorizontalFrame | kFixedWidth);
369  fEditVolume = new TGTextButton(f1, " Edit ");
370  f1->AddFrame(fEditVolume, new TGLayoutHints(kLHintsLeft, 20, 1, 2, 2));
371  fEditVolume->SetToolTipText("Edit selected volume");
372  fEditVolume->Associate(this);
373  fSetTopVolume = new TGTextButton(f1, "Set top");
374  f1->AddFrame(fSetTopVolume, new TGLayoutHints(kLHintsRight, 1, 20, 2, 2));
375  fSetTopVolume->SetToolTipText("Set top volume for geometry");
376  fSetTopVolume->Associate(this);
377  f3->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
378  container->AddFrame(f3, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));
379 
380  // Materials category
381  si = new TGShutterItem(fCategories, new TGHotString("Materials"),kCAT_MATERIALS);
382  container = (TGCompositeFrame*)si->GetContainer();
383  container->SetBackgroundColor(GetDefaultFrameBackground());
384  fCategories->AddItem(si);
385 
386  // Material creators
387  gGeoManager->BuildDefaultMaterials();
388  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
389  f1->AddFrame(label = new TGLabel(f1, "Create material/mixt."), new TGLayoutHints(kLHintsLeft, 2, 1, 0, 0));
390  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
391  gClient->GetColorByName("#ff0000", color);
392  label->SetTextColor(color);
393  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
394  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
395  f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
396  fMaterialName = new TGTextEntry(f1, new TGTextBuffer(50), kMATERIAL_NAME);
397  fMaterialName->Resize(100, fMaterialName->GetDefaultHeight());
398  fMaterialName->SetToolTipText("Enter the new material name");
399  f1->AddFrame(fMaterialName, new TGLayoutHints(kLHintsRight, 3, 1, 2, 5));
400  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
401 
402  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
403  f1->AddFrame(new TGLabel(f1, "Element"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
404  fElementList = new TGComboBox(f1, kMANAGER_ELEMENT_SELECT);
405  fElementList->Resize(100, fManagerName->GetDefaultHeight());
406  TGeoElementTable *table = gGeoManager->GetElementTable();
407  if (table) {
408  TGeoElement *element;
409  for (Int_t i=0; i<table->GetNelements(); i++) {
410  element = table->GetElement(i);
411  fElementList->AddEntry(element->GetTitle(),i);
412  }
413  }
414  fElementList->Select(0);
415  f1->AddFrame(fElementList, new TGLayoutHints(kLHintsRight, 2, 2, 4, 4));
416  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 2, 2));
417  // Number entry for density
418  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
419  f1->AddFrame(new TGLabel(f1, "Density"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
420  fEntryDensity = new TGNumberEntry(f1, 0., 5, kMANAGER_DENSITY_SELECT);
421  fEntryDensity->SetNumStyle(TGNumberFormat::kNESRealThree);
422  fEntryDensity->SetNumAttr(TGNumberFormat::kNEANonNegative);
423  fEntryDensity->Resize(100,fEntryDensity->GetDefaultHeight());
424  TGTextEntry *nef = (TGTextEntry*)fEntryDensity->GetNumberEntry();
425  nef->SetToolTipText("Enter material/mixture density");
426  fEntryDensity->SetNumber(0);
427  fEntryDensity->Associate(this);
428  f1->AddFrame(fEntryDensity, new TGLayoutHints(kLHintsRight, 2, 2, 2, 2));
429  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 2, 2));
430  // Buttons for creating materials/mixtures
431  // Picture buttons for different volumes
432  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
433  f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));
434  fMaterialButton[0] = new TGPictureButton(f1, fClient->GetPicture("geomaterial_t.xpm"), kCREATE_MATERIAL);
435  fMaterialButton[0]->SetToolTipText("Create a new material from element and density");
436  fMaterialButton[1] = new TGPictureButton(f1, fClient->GetPicture("geomixture_t.xpm"), kCREATE_MIXTURE);
437  fMaterialButton[1]->SetToolTipText("Create a new mixture with selected density");
438  for (ipict=0; ipict<2; ipict++) f1->AddFrame(fMaterialButton[ipict],lhb);
439  container->AddFrame(f1, lhf1);
440 
441  // List of materials
442  f4 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);
443  f1 = new TGCompositeFrame(f4, 155, 10, kHorizontalFrame | kFixedWidth);
444  f1->AddFrame(label = new TGLabel(f1, "Existing materials"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
445  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
446  gClient->GetColorByName("#ff0000", color);
447  label->SetTextColor(color);
448  f4->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));
449  f1 = new TGCompositeFrame(f4, 155, 30, kHorizontalFrame | kFixedWidth);
450  fSelectedMaterial = 0;
451  fLSelMaterial = new TGLabel(f1, "Select material");
452  gClient->GetColorByName("#0000ff", color);
453  fLSelMaterial->SetTextColor(color);
454  fLSelMaterial->ChangeOptions(kSunkenFrame | kDoubleBorder);
455  f1->AddFrame(fLSelMaterial, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
456  fBSelMaterial = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MATERIAL_SELECT);
457  fBSelMaterial->SetToolTipText("Select one of the existing materials");
458  fBSelMaterial->Associate(this);
459  f1->AddFrame(fBSelMaterial, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));
460  fEditMaterial = new TGTextButton(f1, "Edit");
461  f1->AddFrame(fEditMaterial, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));
462  fEditMaterial->SetToolTipText("Edit selected material");
463  fEditMaterial->Associate(this);
464  f4->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
465  container->AddFrame(f4, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));
466 
467  si = new TGShutterItem(fCategories, new TGHotString("Media"),kCAT_MEDIA);
468  container = (TGCompositeFrame*)si->GetContainer();
469  container->SetBackgroundColor(GetDefaultFrameBackground());
470  fCategories->AddItem(si);
471 
472  // Media category
473  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
474  f1->AddFrame(label = new TGLabel(f1, "Create new medium"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
475  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
476  gClient->GetColorByName("#ff0000", color);
477  label->SetTextColor(color);
478  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
479 
480  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
481  f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
482  fMediumName = new TGTextEntry(f1, new TGTextBuffer(50), kMEDIUM_NAME);
483  fMediumName->Resize(60, fMediumName->GetDefaultHeight());
484  fMediumName->SetToolTipText("Enter the new medium name");
485  f1->AddFrame(fMediumName, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 5));
486 
487  fMediumId = new TGNumberEntry(f1, 0., 5, kMEDIUM_ID);
488  fMediumId->SetNumStyle(TGNumberFormat::kNESInteger);
489  fMediumId->SetNumAttr(TGNumberFormat::kNEAPositive);
490  fMediumId->Resize(35,fMediumId->GetDefaultHeight());
491  nef = (TGTextEntry*)fMediumId->GetNumberEntry();
492  nef->SetToolTipText("Enter medium ID");
493  fMediumId->SetNumber(fGeometry->GetListOfMedia()->GetSize());
494  fMediumId->Associate(this);
495  f1->AddFrame(fMediumId, new TGLayoutHints(kLHintsRight, 2, 2, 2 ,2));
496  f1->AddFrame(new TGLabel(f1, "ID"), new TGLayoutHints(kLHintsRight, 1, 1, 6, 0));
497  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));
498  // ComboBox for materials
499  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
500  fSelectedMaterial2 = 0;
501  fLSelMaterial2 = new TGLabel(f1, "Select material");
502  gClient->GetColorByName("#0000ff", color);
503  fLSelMaterial2->SetTextColor(color);
504  fLSelMaterial2->ChangeOptions(kSunkenFrame | kDoubleBorder);
505  f1->AddFrame(fLSelMaterial2, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
506  fBSelMaterial2 = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MATERIAL_SELECT2);
507  fBSelMaterial2->SetToolTipText("Select one of the existing materials");
508  fBSelMaterial2->Associate(this);
509  f1->AddFrame(fBSelMaterial2, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));
510  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));
511  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
512  f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));
513  fMediumButton = new TGPictureButton(f1, fClient->GetPicture("geomedium_t.xpm"), kCREATE_MEDIUM);
514  fMediumButton->SetToolTipText("Create a new medium from selected material");
515  fMediumButton->Associate(this);
516  f1->AddFrame(fMediumButton, new TGLayoutHints(kLHintsLeft, 5, 2, 2, 2));
517  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 2, 2));
518 
519  // List of media
520  f5 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);
521  f1 = new TGCompositeFrame(f5, 145, 10, kHorizontalFrame | kLHintsExpandX | kFixedWidth | kOwnBackground);
522  f1->AddFrame(label = new TGLabel(f1, "Existing media"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
523  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
524  gClient->GetColorByName("#ff0000", color);
525  label->SetTextColor(color);
526  f5->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));
527  f1 = new TGCompositeFrame(f5, 155, 30, kHorizontalFrame | kFixedWidth);
528  fSelectedMedium = 0;
529  fLSelMedium = new TGLabel(f1, "Select medium");
530  gClient->GetColorByName("#0000ff", color);
531  fLSelMedium->SetTextColor(color);
532  fLSelMedium->ChangeOptions(kSunkenFrame | kDoubleBorder);
533  f1->AddFrame(fLSelMedium, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
534  fBSelMedium = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MEDIA_SELECT);
535  fBSelMedium->SetToolTipText("Select one of the existing media");
536  fBSelMedium->Associate(this);
537  f1->AddFrame(fBSelMedium, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));
538  fEditMedium = new TGTextButton(f1, "Edit");
539  f1->AddFrame(fEditMedium, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));
540  fEditMedium->SetToolTipText("Edit selected medium");
541  fEditMedium->Associate(this);
542  f5->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
543  container->AddFrame(f5, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));
544 
545  // Matrix category
546  si = new TGShutterItem(fCategories, new TGHotString("Matrices"),kCAT_MATRICES);
547  container = (TGCompositeFrame*)si->GetContainer();
548  container->SetBackgroundColor(GetDefaultFrameBackground());
549  fCategories->AddItem(si);
550  // Name entry
551  f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);
552  f1->AddFrame(label = new TGLabel(f1, "Create new matrix"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
553  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
554  gClient->GetColorByName("#ff0000", color);
555  label->SetTextColor(color);
556  container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
557 
558  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
559  f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
560  fMatrixName = new TGTextEntry(f1, new TGTextBuffer(50), kMATRIX_NAME);
561  fMatrixName->Resize(100, fMatrixName->GetDefaultHeight());
562  fMatrixName->SetToolTipText("Enter the new matrix name");
563  f1->AddFrame(fMatrixName, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 5));
564  container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));
565  // Picture buttons for different matrices
566  f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);
567  f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));
568  fMatrixButton[0] = new TGPictureButton(f1, fClient->GetPicture("geotranslation_t.xpm"), kCREATE_TRANSLATION);
569  fMatrixButton[0]->SetToolTipText("Create a translation");
570  fMatrixButton[1] = new TGPictureButton(f1, fClient->GetPicture("georotation_t.xpm"), kCREATE_ROTATION);
571  fMatrixButton[1]->SetToolTipText("Create a rotation");
572  fMatrixButton[2] = new TGPictureButton(f1, fClient->GetPicture("geocombi_t.xpm"), kCREATE_COMBI);
573  fMatrixButton[2]->SetToolTipText("Create a rotation + translation");
574  for (ipict=0; ipict<3; ipict++) f1->AddFrame(fMatrixButton[ipict],lhb);
575  container->AddFrame(f1, lhf1);
576  // List of matrices
577  f6 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);
578  f1 = new TGCompositeFrame(f6, 155, 10, kHorizontalFrame | kFixedWidth);
579  f1->AddFrame(label = new TGLabel(f1, "Existing matrices"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));
580  f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));
581  gClient->GetColorByName("#ff0000", color);
582  label->SetTextColor(color);
583  f6->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));
584  f1 = new TGCompositeFrame(f6, 155, 30, kHorizontalFrame | kFixedWidth);
585  fSelectedMatrix = 0;
586  fLSelMatrix = new TGLabel(f1, "Select matrix");
587  gClient->GetColorByName("#0000ff", color);
588  fLSelMatrix->SetTextColor(color);
589  fLSelMatrix->ChangeOptions(kSunkenFrame | kDoubleBorder);
590  f1->AddFrame(fLSelMatrix, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));
591  fBSelMatrix = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MATRIX_SELECT);
592  fBSelMatrix->SetToolTipText("Select one of the existing matrices");
593  fBSelMatrix->Associate(this);
594  f1->AddFrame(fBSelMatrix, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));
595  fEditMatrix = new TGTextButton(f1, "Edit");
596  f1->AddFrame(fEditMatrix, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));
597  fEditMatrix->SetToolTipText("Edit selected matrix");
598  fEditMatrix->Associate(this);
599  f6->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));
600  container->AddFrame(f6, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));
601 
602  fCategories->Resize(163,370);
603  AddFrame(fCategories, new TGLayoutHints(kLHintsLeft, 0, 0, 4, 4));
604 
605  fVolumeTab = CreateEditorTabSubFrame("Volume");
606 
607  // Set the fTab and dissconnect editor from the canvas.
608  fTab = fGedEditor->GetTab();
609  TCanvas* edCanvas = fGedEditor->GetCanvas();
610  fGedEditor->DisconnectFromCanvas();
611  if (edCanvas != fConnectedCanvas) {
612  DisconnectSelected();
613  if (edCanvas)
614  ConnectSelected(edCanvas);
615  fConnectedCanvas = edCanvas;
616  }
617 }
618 
619 ////////////////////////////////////////////////////////////////////////////////
620 /// Destructor.
621 
622 TGeoManagerEditor::~TGeoManagerEditor()
623 {
624  TGCompositeFrame *cont;
625  cont = (TGCompositeFrame*)fCategories->GetItem("General")->GetContainer();
626  TGeoTabManager::Cleanup(cont);
627  fCategories->GetItem("General")->SetCleanup(0);
628  cont = (TGCompositeFrame*)fCategories->GetItem("Shapes")->GetContainer();
629  TGeoTabManager::Cleanup(cont);
630  fCategories->GetItem("Shapes")->SetCleanup(0);
631  cont = (TGCompositeFrame*)fCategories->GetItem("Volumes")->GetContainer();
632  TGeoTabManager::Cleanup(cont);
633  fCategories->GetItem("Volumes")->SetCleanup(0);
634  cont = (TGCompositeFrame*)fCategories->GetItem("Materials")->GetContainer();
635  TGeoTabManager::Cleanup(cont);
636  fCategories->GetItem("Materials")->SetCleanup(0);
637  cont = (TGCompositeFrame*)fCategories->GetItem("Media")->GetContainer();
638  TGeoTabManager::Cleanup(cont);
639  fCategories->GetItem("Media")->SetCleanup(0);
640  cont = (TGCompositeFrame*)fCategories->GetItem("Matrices")->GetContainer();
641  TGeoTabManager::Cleanup(cont);
642  fCategories->GetItem("Matrices")->SetCleanup(0);
643 
644  delete fExportOption[0]; delete fExportOption[1];
645 
646  Cleanup();
647 
648  if (fTabMgr) {
649  fTabMgr->GetVolumeTab()->Cleanup();
650  delete fTabMgr;
651  }
652 }
653 
654 ////////////////////////////////////////////////////////////////////////////////
655 /// Connected to TCanvas::Selected. TGeoManagerEditor takes this
656 /// function from TGedEditor and only uses it if obj is a TGeoVolume.
657 
658 void TGeoManagerEditor::SelectedSlot(TVirtualPad* /*pad*/, TObject* obj, Int_t event)
659 {
660  if (event == kButton1 && obj->InheritsFrom(TGeoVolume::Class())) {
661  TGeoVolume* v = (TGeoVolume*) obj;
662  fTabMgr->SetVolTabEnabled();
663  fTabMgr->SetTab();
664  fTabMgr->GetVolumeEditor(v);
665  v->Draw();
666  }
667 }
668 
669 void TGeoManagerEditor::ConnectSelected(TCanvas *c)
670 {
671  // Connect to TCanvas::Selected.
672 
673  c->Connect("Selected(TVirtualPad*,TObject*,Int_t)", "TGeoManagerEditor",
674  this, "SelectedSlot(TVirtualPad*,TObject*,Int_t)");
675 }
676 
677 void TGeoManagerEditor::DisconnectSelected()
678 {
679  // Disconnect from TCanvas::Selected.
680 
681  if (fConnectedCanvas)
682  Disconnect(fConnectedCanvas, "Selected(TVirtualPad*,TObject*,Int_t)",
683  this, "SelectedSlot(TVirtualPad*,TObject*,Int_t)");
684 
685 }
686 
687 ////////////////////////////////////////////////////////////////////////////////
688 /// Connect signals to slots.
689 
690 void TGeoManagerEditor::ConnectSignals2Slots()
691 {
692  fManagerName->Connect("TextChanged(const char *)", "TGeoManagerEditor", this, "DoName()");
693  fManagerTitle->Connect("TextChanged(const char *)", "TGeoManagerEditor", this, "DoName()");
694  fExportButton->Connect("Clicked()", "TGeoManagerEditor", this, "DoExportGeometry()");
695  fCloseGeometry->Connect("Clicked()", "TGeoManagerEditor", this, "DoCloseGeometry()");
696  fShapeButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateBox()");
697  fShapeButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreatePara()");
698  fShapeButton[2]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTrd1()");
699  fShapeButton[3]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTrd2()");
700  fShapeButton[4]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTrap()");
701  fShapeButton[5]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateGtra()");
702  fShapeButton[6]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateXtru()");
703  fShapeButton[7]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateArb8()");
704  fShapeButton[8]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTube()");
705  fShapeButton[9]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTubs()");
706  fShapeButton[10]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCone()");
707  fShapeButton[11]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCons()");
708  fShapeButton[12]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateSphe()");
709  fShapeButton[13]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCtub()");
710  fShapeButton[14]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateEltu()");
711  fShapeButton[15]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTorus()");
712  fShapeButton[16]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreatePcon()");
713  fShapeButton[17]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreatePgon()");
714  fShapeButton[18]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateHype()");
715  fShapeButton[19]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateParab()");
716  fShapeButton[20]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateComposite()");
717  fMatrixButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTranslation()");
718  fMatrixButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateRotation()");
719  fMatrixButton[2]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCombi()");
720  fVolumeButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateVolume()");
721  fVolumeButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateAssembly()");
722  fBSelTop->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectTopVolume()");
723  fBSelVolume->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectVolume()");
724  fBSelShape->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectShape()");
725  fBSelShape2->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectShape2()");
726  fBSelMatrix->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMatrix()");
727  fBSelMaterial->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMaterial()");
728  fBSelMaterial2->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMaterial2()");
729  fBSelMedium->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMedium()");
730  fBSelMedium2->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMedium2()");
731  fSetTopVolume->Connect("Clicked()", "TGeoManagerEditor", this, "DoSetTopVolume()");
732  fEditShape->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditShape()");
733  fEditMedium->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditMedium()");
734  fEditMaterial->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditMaterial()");
735  fEditMatrix->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditMatrix()");
736  fEditVolume->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditVolume()");
737 
738  fMaterialButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateMaterial()");
739  fMaterialButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateMixture()");
740  fMediumButton->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateMedium()");
741 }
742 
743 ////////////////////////////////////////////////////////////////////////////////
744 /// Refresh editor according the selected obj.
745 
746 void TGeoManagerEditor::SetModel(TObject* obj)
747 {
748  fGeometry = (TGeoManager*)obj;
749  fManagerName->SetText(fGeometry->GetName());
750  fManagerTitle->SetText(fGeometry->GetTitle());
751  fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));
752  fMaterialName->SetText(TString::Format("material%i", fGeometry->GetListOfMaterials()->GetSize()));
753  fMediumName->SetText(TString::Format("medium%i", fGeometry->GetListOfMedia()->GetSize()));
754  fVolumeName->SetText(TString::Format("volume%i", fGeometry->GetListOfVolumes()->GetEntries()));
755  // Check if master volume can be set
756  if (fGeometry->GetMasterVolume()) fSetTopVolume->SetEnabled(kFALSE);
757  else fSetTopVolume->SetEnabled(kTRUE);
758  // Check if geometry is already closed
759  if (!fGeometry->IsClosed()) fCloseGeometry->SetEnabled(kTRUE);
760  else {
761  fCloseGeometry->SetEnabled(kFALSE);
762  fBSelTop->SetEnabled(kFALSE);
763  }
764  // Check if volumes category can be activated
765  if (!fGeometry->GetListOfShapes()->GetEntries() || !fGeometry->GetListOfMedia()->GetSize())
766  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kFALSE);
767  else
768  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
769  if (!fGeometry->GetListOfShapes()->GetEntries()) ShowSelectShape(kFALSE);
770  else ShowSelectShape();
771  if (!fGeometry->GetListOfVolumes()->GetEntries()) ShowSelectVolume(kFALSE);
772  else ShowSelectVolume();
773  if (!fGeometry->GetListOfMedia()->GetSize()) ShowSelectMedium(kFALSE);
774  else ShowSelectMedium();
775  if (!fGeometry->GetListOfMatrices()->GetEntries()) ShowSelectMatrix(kFALSE);
776  else ShowSelectMatrix();
777 
778  // Check if media category can be activated
779  if (!fGeometry->GetListOfMaterials()->GetSize()) {
780  fCategories->GetItem("Media")->GetButton()->SetEnabled(kFALSE);
781  ShowSelectMaterial(kFALSE);
782  } else {
783  fCategories->GetItem("Media")->GetButton()->SetEnabled(kTRUE);
784  ShowSelectMaterial();
785  }
786 
787  fTab->SetTab(0);
788  fCategories->Layout();
789  if (fTabMgr == 0) {
790  fTabMgr = TGeoTabManager::GetMakeTabManager(fGedEditor);
791  fTabMgr->fVolumeTab = fVolumeTab;
792  }
793  if (fInit) ConnectSignals2Slots();
794  // SetActive();
795 }
796 
797 ////////////////////////////////////////////////////////////////////////////////
798 /// Change name/title of the geometry
799 
800 void TGeoManagerEditor::DoName()
801 {
802  fGeometry->SetName(fManagerName->GetText());
803  fGeometry->SetTitle(fManagerTitle->GetText());
804 }
805 
806 ////////////////////////////////////////////////////////////////////////////////
807 /// Export geometry as .root or .C file
808 
809 void TGeoManagerEditor::DoExportGeometry()
810 {
811  Bool_t asroot = fExportOption[0]->IsDown();
812  TString s = fGeometry->GetName();
813  s = s.Strip();
814  s.Remove(20);
815  const char *name;
816  if (asroot) name = TString::Format("%s.root", s.Data());
817  else name = TString::Format("%s.C", s.Data());
818  fGeometry->Export(name);
819 }
820 
821 ////////////////////////////////////////////////////////////////////////////////
822 /// Create a box.
823 
824 void TGeoManagerEditor::DoCreateBox()
825 {
826  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
827  fSelectedShape = new TGeoBBox(TString::Format("box_%i",id), 1., 1., 1.);
828  ShowSelectShape();
829  // Check if volumes category can be activated
830  if (fGeometry->GetListOfMedia()->GetSize())
831  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
832  DoEditShape();
833 }
834 
835 ////////////////////////////////////////////////////////////////////////////////
836 /// Create a parallelipiped.
837 
838 void TGeoManagerEditor::DoCreatePara()
839 {
840  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
841  fSelectedShape = new TGeoPara(TString::Format("para_%i",id), 1., 1., 1., 30., 20., 45.);
842  ShowSelectShape();
843  if (fGeometry->GetListOfMedia()->GetSize())
844  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
845  DoEditShape();
846 }
847 
848 ////////////////////////////////////////////////////////////////////////////////
849 /// Create a Trd1.
850 
851 void TGeoManagerEditor::DoCreateTrd1()
852 {
853  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
854  fSelectedShape = new TGeoTrd1(TString::Format("trd1_%i",id), 0.5, 1., 1., 1.);
855  ShowSelectShape();
856  if (fGeometry->GetListOfMedia()->GetSize())
857  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
858  DoEditShape();
859 }
860 
861 ////////////////////////////////////////////////////////////////////////////////
862 /// Create a Trd2.
863 
864 void TGeoManagerEditor::DoCreateTrd2()
865 {
866  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
867  fSelectedShape = new TGeoTrd2(TString::Format("trd2_%i",id), 0.5, 1., 0.5, 1., 1.);
868  ShowSelectShape();
869  if (fGeometry->GetListOfMedia()->GetSize())
870  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
871  DoEditShape();
872 }
873 
874 ////////////////////////////////////////////////////////////////////////////////
875 /// Create a general trapezoid.
876 
877 void TGeoManagerEditor::DoCreateTrap()
878 {
879  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
880  fSelectedShape = new TGeoTrap(TString::Format("trap_%i",id), 1., 15., 45., 0.5, 0.3, 0.5, 30., 0.5, 0.3, 0.5, 30.);
881  ShowSelectShape();
882  if (fGeometry->GetListOfMedia()->GetSize())
883  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
884  DoEditShape();
885 }
886 
887 ////////////////////////////////////////////////////////////////////////////////
888 /// Create a twisted trapezoid.
889 
890 void TGeoManagerEditor::DoCreateGtra()
891 {
892  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
893  fSelectedShape = new TGeoGtra(TString::Format("gtra_%i",id), 1., 15., 45., 45.,0.5, 0.3, 0.5, 30., 0.5, 0.3, 0.5, 30.);
894  ShowSelectShape();
895  if (fGeometry->GetListOfMedia()->GetSize())
896  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
897  DoEditShape();
898 }
899 
900 ////////////////////////////////////////////////////////////////////////////////
901 /// Create an extruded polygone.
902 
903 void TGeoManagerEditor::DoCreateXtru()
904 {
905 }
906 
907 ////////////////////////////////////////////////////////////////////////////////
908 /// Create an arbitrary polygone with maximum 8 vertices sitting on 2 parallel
909 /// planes
910 
911 void TGeoManagerEditor::DoCreateArb8()
912 {
913 }
914 
915 ////////////////////////////////////////////////////////////////////////////////
916 /// Create a tube.
917 
918 void TGeoManagerEditor::DoCreateTube()
919 {
920  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
921  fSelectedShape = new TGeoTube(TString::Format("tube_%i",id), 0.5, 1., 1.);
922  ShowSelectShape();
923  if (fGeometry->GetListOfMedia()->GetSize())
924  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
925  DoEditShape();
926 }
927 
928 ////////////////////////////////////////////////////////////////////////////////
929 /// Create a tube segment.
930 
931 void TGeoManagerEditor::DoCreateTubs()
932 {
933  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
934  fSelectedShape = new TGeoTubeSeg(TString::Format("tubs_%i",id), 0.5, 1., 1.,0.,45.);
935  ShowSelectShape();
936  if (fGeometry->GetListOfMedia()->GetSize())
937  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
938  DoEditShape();
939 }
940 
941 ////////////////////////////////////////////////////////////////////////////////
942 /// Create a cone.
943 
944 void TGeoManagerEditor::DoCreateCone()
945 {
946  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
947  fSelectedShape = new TGeoCone(TString::Format("cone_%i",id), 0.5, 0.5, 1., 1.5, 2.);
948  ShowSelectShape();
949  if (fGeometry->GetListOfMedia()->GetSize())
950  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
951  DoEditShape();
952 }
953 
954 ////////////////////////////////////////////////////////////////////////////////
955 /// Create a cone segment.
956 
957 void TGeoManagerEditor::DoCreateCons()
958 {
959  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
960  fSelectedShape = new TGeoConeSeg(TString::Format("cons_%i",id), 0.5, 0.5, 1., 1.5, 2.,0.,45.);
961  ShowSelectShape();
962  if (fGeometry->GetListOfMedia()->GetSize())
963  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
964  DoEditShape();
965 }
966 
967 ////////////////////////////////////////////////////////////////////////////////
968 /// Create a sphere.
969 
970 void TGeoManagerEditor::DoCreateSphe()
971 {
972  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
973  fSelectedShape = new TGeoSphere(TString::Format("sphere_%i",id), 0.5, 1., 0., 180., 0.,360.);
974  ShowSelectShape();
975  if (fGeometry->GetListOfMedia()->GetSize())
976  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
977  DoEditShape();
978 }
979 
980 ////////////////////////////////////////////////////////////////////////////////
981 /// Create a cut tube.
982 
983 void TGeoManagerEditor::DoCreateCtub()
984 {
985  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
986  fSelectedShape = new TGeoCtub(TString::Format("ctub_%i",id), 0.5, 1., 1.,0.,45.,0.,0.,-1,0.,0.,1);
987  ShowSelectShape();
988  if (fGeometry->GetListOfMedia()->GetSize())
989  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
990  DoEditShape();
991 }
992 
993 ////////////////////////////////////////////////////////////////////////////////
994 /// Create an eliptical tube.
995 
996 void TGeoManagerEditor::DoCreateEltu()
997 {
998  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
999  fSelectedShape = new TGeoEltu(TString::Format("para_%i",id), 1., 2., 1.5 );
1000  ShowSelectShape();
1001  if (fGeometry->GetListOfMedia()->GetSize())
1002  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
1003  DoEditShape();
1004 }
1005 
1006 ////////////////////////////////////////////////////////////////////////////////
1007 /// Create a torus shape.
1008 
1009 void TGeoManagerEditor::DoCreateTorus()
1010 {
1011  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
1012  fSelectedShape = new TGeoTorus(TString::Format("torus_%i",id), 10., 1., 1.5, 0, 360.);
1013  ShowSelectShape();
1014  if (fGeometry->GetListOfMedia()->GetSize())
1015  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
1016  DoEditShape();
1017 
1018 }
1019 
1020 ////////////////////////////////////////////////////////////////////////////////
1021 /// Create a polycone shape.
1022 
1023 void TGeoManagerEditor::DoCreatePcon()
1024 {
1025  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
1026  fSelectedShape = new TGeoPcon(TString::Format("pcon_%i",id), 0., 360., 2);
1027  ((TGeoPcon*)fSelectedShape)->DefineSection(0, -1, 0.5, 1.);
1028  ((TGeoPcon*)fSelectedShape)->DefineSection(1, 1, 0.2, 0.5);
1029  ShowSelectShape();
1030  if (fGeometry->GetListOfMedia()->GetSize())
1031  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
1032  DoEditShape();
1033 }
1034 
1035 ////////////////////////////////////////////////////////////////////////////////
1036 /// Create a polygone shape.
1037 
1038 void TGeoManagerEditor::DoCreatePgon()
1039 {
1040  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
1041  fSelectedShape = new TGeoPgon(TString::Format("pgon_%i",id), 0., 360.,6,2);
1042  ((TGeoPcon*)fSelectedShape)->DefineSection(0, -1, 0.5, 1.);
1043  ((TGeoPcon*)fSelectedShape)->DefineSection(1, 1, 0.2, 0.5);
1044  ShowSelectShape();
1045  if (fGeometry->GetListOfMedia()->GetSize())
1046  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
1047  DoEditShape();
1048 }
1049 
1050 ////////////////////////////////////////////////////////////////////////////////
1051 /// Create a hyperboloid.
1052 
1053 void TGeoManagerEditor::DoCreateHype()
1054 {
1055  Int_t id = gGeoManager->GetListOfShapes()->GetEntries();
1056  fSelectedShape = new TGeoHype(TString::Format("hype_%i",id), 1., 15., 2., 30., 5.);
1057  ShowSelectShape();
1058  if (fGeometry->GetListOfMedia()->GetSize())
1059  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
1060  DoEditShape();
1061 }
1062 
1063 ////////////////////////////////////////////////////////////////////////////////
1064 /// Create a paraboloid.
1065 
1066 void TGeoManagerEditor::DoCreateParab()
1067 {
1068 }
1069 
1070 ////////////////////////////////////////////////////////////////////////////////
1071 /// Create a composite shape.
1072 
1073 void TGeoManagerEditor::DoCreateComposite()
1074 {
1075 }
1076 
1077 ////////////////////////////////////////////////////////////////////////////////
1078 /// Create a new material.
1079 
1080 void TGeoManagerEditor::DoCreateMaterial()
1081 {
1082  TGeoElement *el = fGeometry->GetElementTable()->GetElement(fElementList->GetSelected());
1083  if (!el) {
1084  Error("DoCreateMaterial", "Cannot find selected element in list");
1085  return;
1086  }
1087  Double_t density = fEntryDensity->GetNumber();
1088  const char *name = fMaterialName->GetText();
1089  fSelectedMaterial = new TGeoMaterial(name, el, density);
1090  ShowSelectMaterial();
1091  fCategories->GetItem("Media")->GetButton()->SetEnabled(kTRUE);
1092  DoEditMaterial();
1093  fMaterialName->SetText(TString::Format("material%i", fGeometry->GetListOfMaterials()->GetSize()));
1094 }
1095 
1096 ////////////////////////////////////////////////////////////////////////////////
1097 /// Create a new mixture.
1098 
1099 void TGeoManagerEditor::DoCreateMixture()
1100 {
1101  Double_t density = fEntryDensity->GetNumber();
1102  const char *name = fMaterialName->GetText();
1103  fSelectedMaterial = new TGeoMixture(name, 1, density);
1104  ShowSelectMaterial();
1105  fCategories->GetItem("Media")->GetButton()->SetEnabled(kTRUE);
1106  DoEditMaterial();
1107  fMaterialName->SetText(TString::Format("material%i", fGeometry->GetListOfMaterials()->GetSize()));
1108 }
1109 
1110 ////////////////////////////////////////////////////////////////////////////////
1111 /// Create a new medium.
1112 
1113 void TGeoManagerEditor::DoCreateMedium()
1114 {
1115  Int_t id = fMediumId->GetIntNumber();
1116  if (!fSelectedMaterial2) return;
1117  const char *name = fMediumName->GetText();
1118  fSelectedMedium = new TGeoMedium(name, id, fSelectedMaterial2);
1119  ShowSelectMedium();
1120  if (fGeometry->GetListOfShapes()->GetEntries())
1121  fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);
1122  DoEditMedium();
1123  fMediumName->SetText(TString::Format("medium%i", fGeometry->GetListOfMedia()->GetSize()));
1124 }
1125 
1126 ////////////////////////////////////////////////////////////////////////////////
1127 /// Create a new translation.
1128 
1129 void TGeoManagerEditor::DoCreateTranslation()
1130 {
1131  const char *name = fMatrixName->GetText();
1132  fSelectedMatrix = new TGeoTranslation(name, 0., 0., 0.);
1133  fSelectedMatrix->SetBit(TGeoMatrix::kGeoTranslation);
1134  fSelectedMatrix->RegisterYourself();
1135  ShowSelectMatrix();
1136  DoEditMatrix();
1137  fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));
1138 }
1139 
1140 ////////////////////////////////////////////////////////////////////////////////
1141 /// Create a new rotation.
1142 
1143 void TGeoManagerEditor::DoCreateRotation()
1144 {
1145  const char *name = fMatrixName->GetText();
1146  fSelectedMatrix = new TGeoRotation(name);
1147  fSelectedMatrix->SetBit(TGeoMatrix::kGeoRotation);
1148  fSelectedMatrix->RegisterYourself();
1149  ShowSelectMatrix();
1150  DoEditMatrix();
1151  fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));
1152 }
1153 
1154 ////////////////////////////////////////////////////////////////////////////////
1155 /// Create a new volume.
1156 
1157 void TGeoManagerEditor::DoCreateVolume()
1158 {
1159  const char *name = fVolumeName->GetText();
1160  if (!fSelectedShape2 || !fSelectedMedium2) return;
1161  fSelectedVolume = new TGeoVolume(name, fSelectedShape2, fSelectedMedium2);
1162  fLSelVolume->SetText(name);
1163  ShowSelectVolume();
1164  DoEditVolume();
1165  fVolumeName->SetText(TString::Format("volume%i", fGeometry->GetListOfVolumes()->GetEntries()));
1166 }
1167 
1168 ////////////////////////////////////////////////////////////////////////////////
1169 /// Create a new volume assembly.
1170 
1171 void TGeoManagerEditor::DoCreateAssembly()
1172 {
1173  const char *name = fVolumeName->GetText();
1174  fSelectedVolume = new TGeoVolumeAssembly(name);
1175  fLSelVolume->SetText(name);
1176  ShowSelectVolume();
1177  DoEditVolume();
1178  fVolumeName->SetText(TString::Format("volume%i", fGeometry->GetListOfVolumes()->GetEntries()));
1179 }
1180 
1181 ////////////////////////////////////////////////////////////////////////////////
1182 /// Create a new translation + rotation.
1183 
1184 void TGeoManagerEditor::DoCreateCombi()
1185 {
1186  const char *name = fMatrixName->GetText();
1187  fSelectedMatrix = new TGeoCombiTrans(name, 0., 0., 0., new TGeoRotation());
1188  fSelectedMatrix->RegisterYourself();
1189  fSelectedMatrix->SetBit(TGeoMatrix::kGeoTranslation);
1190  fSelectedMatrix->SetBit(TGeoMatrix::kGeoRotation);
1191  ShowSelectMatrix();
1192  DoEditMatrix();
1193  fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));
1194 }
1195 
1196 ////////////////////////////////////////////////////////////////////////////////
1197 /// Set top volume for the geometry.
1198 
1199 void TGeoManagerEditor::DoSetTopVolume()
1200 {
1201  if (!fSelectedVolume) return;
1202  fGeometry->SetTopVolume(fSelectedVolume);
1203  fSetTopVolume->SetEnabled(kFALSE);
1204 }
1205 
1206 ////////////////////////////////////////////////////////////////////////////////
1207 /// Slot for editing selected shape.
1208 
1209 void TGeoManagerEditor::DoEditShape()
1210 {
1211  if (!fSelectedShape) return;
1212  fTabMgr->GetShapeEditor(fSelectedShape);
1213  fSelectedShape->Draw();
1214  fTabMgr->GetPad()->GetView()->ShowAxis();
1215 }
1216 
1217 ////////////////////////////////////////////////////////////////////////////////
1218 /// Slot for editing selected volume.
1219 
1220 void TGeoManagerEditor::DoEditVolume()
1221 {
1222  if (!fSelectedVolume) {
1223  fTabMgr->SetVolTabEnabled(kFALSE);
1224  return;
1225  }
1226  fTabMgr->SetVolTabEnabled();
1227  fTabMgr->SetTab();
1228  fTabMgr->GetVolumeEditor(fSelectedVolume);
1229  fSelectedVolume->Draw();
1230 }
1231 
1232 ////////////////////////////////////////////////////////////////////////////////
1233 /// Slot for editing selected medium.
1234 
1235 void TGeoManagerEditor::DoEditMedium()
1236 {
1237  if (!fSelectedMedium) return;
1238  fTabMgr->GetMediumEditor(fSelectedMedium);
1239 }
1240 
1241 ////////////////////////////////////////////////////////////////////////////////
1242 /// Slot for editing selected material.
1243 
1244 void TGeoManagerEditor::DoEditMaterial()
1245 {
1246  if (!fSelectedMaterial) return;
1247  fTabMgr->GetMaterialEditor(fSelectedMaterial);
1248 }
1249 
1250 ////////////////////////////////////////////////////////////////////////////////
1251 /// Slot for editing selected matrix.
1252 
1253 void TGeoManagerEditor::DoEditMatrix()
1254 {
1255  if (!fSelectedMatrix) return;
1256  fTabMgr->GetMatrixEditor(fSelectedMatrix);
1257 }
1258 
1259 ////////////////////////////////////////////////////////////////////////////////
1260 /// Slot for selecting an existing matrix.
1261 
1262 void TGeoManagerEditor::DoSelectMatrix()
1263 {
1264  TGeoMatrix *matrix = fSelectedMatrix;
1265  new TGeoMatrixDialog(fBSelMatrix, gClient->GetRoot(), 200,300);
1266  fSelectedMatrix = (TGeoMatrix*)TGeoMatrixDialog::GetSelected();
1267  if (fSelectedMatrix) fLSelMatrix->SetText(fSelectedMatrix->GetName());
1268  else fSelectedMatrix = matrix;
1269 }
1270 
1271 ////////////////////////////////////////////////////////////////////////////////
1272 /// Slot for selecting an existing shape.
1273 
1274 void TGeoManagerEditor::DoSelectShape()
1275 {
1276  TGeoShape *shape = fSelectedShape;
1277  new TGeoShapeDialog(fBSelShape, gClient->GetRoot(), 200,300);
1278  fSelectedShape = (TGeoShape*)TGeoShapeDialog::GetSelected();
1279  if (fSelectedShape) fLSelShape->SetText(fSelectedShape->GetName());
1280  else fSelectedShape = shape;
1281 }
1282 
1283 ////////////////////////////////////////////////////////////////////////////////
1284 /// Slot for selecting a shape for making a volume.
1285 
1286 void TGeoManagerEditor::DoSelectShape2()
1287 {
1288  TGeoShape *shape = fSelectedShape2;
1289  new TGeoShapeDialog(fBSelShape2, gClient->GetRoot(), 200,300);
1290  fSelectedShape2 = (TGeoShape*)TGeoShapeDialog::GetSelected();
1291  if (fSelectedShape2) fLSelShape2->SetText(fSelectedShape2->GetName());
1292  else fSelectedShape2 = shape;
1293 }
1294 
1295 ////////////////////////////////////////////////////////////////////////////////
1296 /// Slot for selecting an existing material.
1297 
1298 void TGeoManagerEditor::DoSelectMaterial()
1299 {
1300  TGeoMaterial *mat = fSelectedMaterial;
1301  new TGeoMaterialDialog(fBSelMaterial, gClient->GetRoot(), 200,300);
1302  fSelectedMaterial = (TGeoMaterial*)TGeoMaterialDialog::GetSelected();
1303  if (fSelectedMaterial) fLSelMaterial->SetText(fSelectedMaterial->GetName());
1304  else fSelectedMaterial = mat;
1305 }
1306 
1307 ////////////////////////////////////////////////////////////////////////////////
1308 /// Slot for selecting an existing material and making a medium.
1309 
1310 void TGeoManagerEditor::DoSelectMaterial2()
1311 {
1312  TGeoMaterial *mat = fSelectedMaterial2;
1313  new TGeoMaterialDialog(fBSelMaterial2, gClient->GetRoot(), 200,300);
1314  fSelectedMaterial2 = (TGeoMaterial*)TGeoMaterialDialog::GetSelected();
1315  if (fSelectedMaterial2) fLSelMaterial2->SetText(fSelectedMaterial2->GetName());
1316  else fSelectedMaterial2 = mat;
1317 }
1318 
1319 ////////////////////////////////////////////////////////////////////////////////
1320 /// Slot for selecting an existing medium.
1321 
1322 void TGeoManagerEditor::DoSelectMedium()
1323 {
1324  TGeoMedium *med = fSelectedMedium;
1325  new TGeoMediumDialog(fBSelMedium, gClient->GetRoot(), 200,300);
1326  fSelectedMedium = (TGeoMedium*)TGeoMediumDialog::GetSelected();
1327  if (fSelectedMedium) fLSelMedium->SetText(fSelectedMedium->GetName());
1328  else fSelectedMedium = med;
1329 }
1330 
1331 ////////////////////////////////////////////////////////////////////////////////
1332 /// Slot for selecting an existing medium for making a volume.
1333 
1334 void TGeoManagerEditor::DoSelectMedium2()
1335 {
1336  TGeoMedium *med = fSelectedMedium2;
1337  new TGeoMediumDialog(fBSelMedium2, gClient->GetRoot(), 200,300);
1338  fSelectedMedium2 = (TGeoMedium*)TGeoMediumDialog::GetSelected();
1339  if (fSelectedMedium2) fLSelMedium2->SetText(fSelectedMedium2->GetName());
1340  else fSelectedMedium2 = med;
1341 }
1342 
1343 ////////////////////////////////////////////////////////////////////////////////
1344 /// Slot for selecting an existing volume.
1345 
1346 void TGeoManagerEditor::DoSelectVolume()
1347 {
1348  TGeoVolume *vol = fSelectedVolume;
1349  new TGeoVolumeDialog(fBSelVolume, gClient->GetRoot(), 200,300);
1350  fSelectedVolume = (TGeoVolume*)TGeoVolumeDialog::GetSelected();
1351  if (fSelectedVolume) fLSelVolume->SetText(fSelectedVolume->GetName());
1352  else fSelectedVolume = vol;
1353 }
1354 
1355 ////////////////////////////////////////////////////////////////////////////////
1356 /// Slot for seting top geometry volume.
1357 
1358 void TGeoManagerEditor::DoSelectTopVolume()
1359 {
1360  TGeoVolume *vol = fGeometry->GetTopVolume();
1361  new TGeoVolumeDialog(fBSelTop, gClient->GetRoot(), 200,300);
1362  fSelectedVolume = (TGeoVolume*)TGeoVolumeDialog::GetSelected();
1363  if (fSelectedVolume) fLSelTop->SetText(fSelectedVolume->GetName());
1364  else fSelectedVolume = vol;
1365  if (fSelectedVolume && (fSelectedVolume != vol)) fGeometry->SetTopVolume(fSelectedVolume);
1366 }
1367 
1368 ////////////////////////////////////////////////////////////////////////////////
1369 /// Slot for closing the geometry.
1370 
1371 void TGeoManagerEditor::DoCloseGeometry()
1372 {
1373  if (!fGeometry->IsClosed()) fGeometry->CloseGeometry();
1374  fCloseGeometry->SetEnabled(kFALSE);
1375 }
1376 
1377 ////////////////////////////////////////////////////////////////////////////////
1378 /// Show/hide interface for shape selection.
1379 
1380 void TGeoManagerEditor::ShowSelectShape(Bool_t show)
1381 {
1382  TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Shapes")->GetContainer();
1383  if (show) cont->ShowFrame(f2);
1384  else cont->HideFrame(f2);
1385 }
1386 
1387 ////////////////////////////////////////////////////////////////////////////////
1388 /// Show/hide interface for volume selection.
1389 
1390 void TGeoManagerEditor::ShowSelectVolume(Bool_t show)
1391 {
1392  TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("General")->GetContainer();
1393  if (show) cont->ShowFrame(f7);
1394  else cont->HideFrame(f7);
1395  cont = (TGCompositeFrame*)fCategories->GetItem("Volumes")->GetContainer();
1396  if (show) cont->ShowFrame(f3);
1397  else cont->HideFrame(f3);
1398 }
1399 
1400 ////////////////////////////////////////////////////////////////////////////////
1401 /// Show/hide interface for material selection.
1402 
1403 void TGeoManagerEditor::ShowSelectMaterial(Bool_t show)
1404 {
1405  TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Materials")->GetContainer();
1406  if (show) cont->ShowFrame(f4);
1407  else cont->HideFrame(f4);
1408 }
1409 
1410 ////////////////////////////////////////////////////////////////////////////////
1411 /// Show/hide interface for medium selection.
1412 
1413 void TGeoManagerEditor::ShowSelectMedium(Bool_t show)
1414 {
1415  TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Media")->GetContainer();
1416  if (show) cont->ShowFrame(f5);
1417  else cont->HideFrame(f5);
1418 }
1419 
1420 ////////////////////////////////////////////////////////////////////////////////
1421 /// Show/hide interface for matrix selection.
1422 
1423 void TGeoManagerEditor::ShowSelectMatrix(Bool_t show)
1424 {
1425  TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Matrices")->GetContainer();
1426  if (show) cont->ShowFrame(f6);
1427  else cont->HideFrame(f6);
1428 }
TGCompositeFrame::HideFrame
virtual void HideFrame(TGFrame *f)
Hide sub frame.
Definition: TGFrame.cxx:1172
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
TGFrame::Resize
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition: TGFrame.cxx:587
TGeoManagerEditor::DoEditMedium
void DoEditMedium()
Slot for editing selected medium.
Definition: TGeoManagerEditor.cxx:1235
TGeoManagerEditor::fBSelTop
TGPictureButton * fBSelTop
Definition: TGeoManagerEditor.h:105
TGeoSphere
Spherical shell class.
Definition: TGeoSphere.h:19
TGeoTube
Cylindrical tube class.
Definition: TGeoTube.h:19
TGeoManagerEditor::DoCreateCons
void DoCreateCons()
Create a cone segment.
Definition: TGeoManagerEditor.cxx:957
TGeoManagerEditor::fBSelMedium
TGPictureButton * fBSelMedium
Definition: TGeoManagerEditor.h:86
TGeoTabManager::SetTab
void SetTab()
Set a given tab element as active one.
Definition: TGeoTabManager.cxx:269
TGeoManagerEditor::fMediumId
TGNumberEntry * fMediumId
Definition: TGeoManagerEditor.h:97
TGeoManager
The manager class for any TGeo geometry.
Definition: TGeoManager.h:38
TGeoManagerEditor::DoExportGeometry
void DoExportGeometry()
Export geometry as .root or .C file.
Definition: TGeoManagerEditor.cxx:809
TGeoManagerEditor::DoSelectMedium
void DoSelectMedium()
Slot for selecting an existing medium.
Definition: TGeoManagerEditor.cxx:1322
TGeoBBox
Box class.
Definition: TGeoBBox.h:19
TGeoManagerEditor::ShowSelectShape
void ShowSelectShape(Bool_t show=kTRUE)
Show/hide interface for shape selection.
Definition: TGeoManagerEditor.cxx:1380
TGeoVolumeAssembly
Volume assemblies.
Definition: TGeoVolume.h:320
TGeoElementTable
Table of elements.
Definition: TGeoElement.h:367
TGeoManagerEditor::DoCreateComposite
void DoCreateComposite()
Create a composite shape.
Definition: TGeoManagerEditor.cxx:1073
TGeoManagerEditor::fVolumeButton
TGPictureButton * fVolumeButton[2]
Definition: TGeoManagerEditor.h:90
TGeoManagerEditor::DoCreateXtru
void DoCreateXtru()
Create an extruded polygone.
Definition: TGeoManagerEditor.cxx:903
TGeoManagerEditor::ConnectSignals2Slots
virtual void ConnectSignals2Slots()
Connect signals to slots.
Definition: TGeoManagerEditor.cxx:690
c
return c
Definition: entrylist_figure1.C:47
TGeoGtra
Gtra is a twisted trapezoid.
Definition: TGeoArb8.h:145
TGeoMatrix
Geometrical transformation package.
Definition: TGeoMatrix.h:40
TGeoManagerEditor::DoCreateSphe
void DoCreateSphe()
Create a sphere.
Definition: TGeoManagerEditor.cxx:970
TGeoManagerEditor::DoEditMaterial
void DoEditMaterial()
Slot for editing selected material.
Definition: TGeoManagerEditor.cxx:1244
TGLabel::SetTextColor
virtual void SetTextColor(Pixel_t color, Bool_t global=kFALSE)
Changes text color.
Definition: TGLabel.cxx:359
TGeoManagerEditor::DoCloseGeometry
void DoCloseGeometry()
Slot for closing the geometry.
Definition: TGeoManagerEditor.cxx:1371
TGeoManagerEditor::fCategories
TGShutter * fCategories
Definition: TGeoManagerEditor.h:57
TGeoManagerEditor::fMatrixName
TGTextEntry * fMatrixName
Definition: TGeoManagerEditor.h:61
TGTextEntry::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=500)
Set tool tip text associated with this text entry.
Definition: TGTextEntry.cxx:1661
TGeoManagerEditor::DoSelectMatrix
void DoSelectMatrix()
Slot for selecting an existing matrix.
Definition: TGeoManagerEditor.cxx:1262
TGeoPcon
A polycone.
Definition: TGeoPcon.h:19
TGeoManagerEditor::ShowSelectMatrix
void ShowSelectMatrix(Bool_t show=kTRUE)
Show/hide interface for matrix selection.
Definition: TGeoManagerEditor.cxx:1423
TGeoManagerEditor::DoSelectShape
void DoSelectShape()
Slot for selecting an existing shape.
Definition: TGeoManagerEditor.cxx:1274
TNamed::SetName
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:131
TGeoPgon
A polygone.
Definition: TGeoPgon.h:19
TGButtonGroup::SetButton
virtual void SetButton(Int_t id, Bool_t down=kTRUE)
Sets the button with id to be on/down, and if this is an exclusive group, all other button in the gro...
Definition: TGButtonGroup.cxx:332
TGeoVolume
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:61
TGeoManagerEditor::fSelectedVolume
TGeoVolume * fSelectedVolume
Definition: TGeoManagerEditor.h:70
TGeoManager::GetElementTable
TGeoElementTable * GetElementTable()
Returns material table. Creates it if not existing.
Definition: TGeoManager.cxx:3381
TGeoManagerEditor::DoCreateMaterial
void DoCreateMaterial()
Create a new material.
Definition: TGeoManagerEditor.cxx:1080
TGeoManagerEditor::fSelectedMedium
TGeoMedium * fSelectedMedium
Definition: TGeoManagerEditor.h:82
TGNumberEntry::SetNumber
virtual void SetNumber(Double_t val)
Definition: TGNumberEntry.h:192
TGeoVolume::Draw
virtual void Draw(Option_t *option="")
draw top volume according to option
Definition: TGeoVolume.cxx:1199
TGeoTabManager::fVolumeTab
TGCompositeFrame * fVolumeTab
Definition: TGeoTabManager.h:65
TGeoTranslation
Class describing translations.
Definition: TGeoMatrix.h:131
TGeoTorus
Torus segment class.
Definition: TGeoTorus.h:19
TGeoManager::SetTopVolume
void SetTopVolume(TGeoVolume *vol)
Set the top volume and corresponding node as starting point of the geometry.
Definition: TGeoManager.cxx:3412
TGeoManagerEditor::DoCreateEltu
void DoCreateEltu()
Create an eliptical tube.
Definition: TGeoManagerEditor.cxx:996
TGedEditor::GetTab
TGTab * GetTab() const
Definition: TGedEditor.h:92
TString
Basic string class.
Definition: TString.h:137
TGeoMaterial
Base class describing materials.
Definition: TGeoMaterial.h:35
gClient
#define gClient
Definition: TGClient.h:174
TGeoManagerEditor::DoCreateTrd2
void DoCreateTrd2()
Create a Trd2.
Definition: TGeoManagerEditor.cxx:864
TGeoManagerEditor::DoCreateTrd1
void DoCreateTrd1()
Create a Trd1.
Definition: TGeoManagerEditor.cxx:851
TGCompositeFrame::ShowFrame
virtual void ShowFrame(TGFrame *f)
Show sub frame.
Definition: TGFrame.cxx:1186
Int_t
int Int_t
Definition: RtypesCore.h:41
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
TGeoManager::GetMasterVolume
TGeoVolume * GetMasterVolume() const
Definition: TGeoManager.h:496
TGeoTabManager::GetMaterialEditor
void GetMaterialEditor(TGeoMaterial *material)
Get editor for a material.
Definition: TGeoTabManager.cxx:156
TGeoManagerEditor::DoCreatePara
void DoCreatePara()
Create a parallelipiped.
Definition: TGeoManagerEditor.cxx:838
kFALSE
const Bool_t kFALSE
Definition: Rtypes.h:92
TGeoManagerEditor::fBSelMaterial2
TGPictureButton * fBSelMaterial2
Definition: TGeoManagerEditor.h:69
TGeoManagerEditor::DoCreateParab
void DoCreateParab()
Create a paraboloid.
Definition: TGeoManagerEditor.cxx:1066
TGeoManagerEditor::DoSelectMedium2
void DoSelectMedium2()
Slot for selecting an existing medium for making a volume.
Definition: TGeoManagerEditor.cxx:1334
xmlio::Class
const char * Class
Definition: TXMLSetup.cxx:64
TGeoManagerEditor::DoCreateTube
void DoCreateTube()
Create a tube.
Definition: TGeoManagerEditor.cxx:918
TGeoManagerEditor::fSelectedShape
TGeoShape * fSelectedShape
Definition: TGeoManagerEditor.h:73
TGeoManagerEditor::DoSetTopVolume
void DoSetTopVolume()
Set top volume for the geometry.
Definition: TGeoManagerEditor.cxx:1199
TGeoTrd1
A trapezoid with only x length varying with z.
Definition: TGeoTrd1.h:19
TGeoTabManager::SetVolTabEnabled
void SetVolTabEnabled(Bool_t flag=kTRUE)
Enable/disable tabs.
Definition: TGeoTabManager.cxx:245
TGeoManagerEditor::fBSelVolume
TGPictureButton * fBSelVolume
Definition: TGeoManagerEditor.h:72
TGeoManagerEditor::fManagerName
TGTextEntry * fManagerName
Definition: TGeoManagerEditor.h:58
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
TGeoManager::GetListOfMaterials
TList * GetListOfMaterials() const
Definition: TGeoManager.h:461
TGeoManagerEditor::DoSelectVolume
void DoSelectVolume()
Slot for selecting an existing volume.
Definition: TGeoManagerEditor.cxx:1346
TGeoTabManager::Cleanup
static void Cleanup(TGCompositeFrame *frame)
Static method to cleanup hirarchically all daughters of a composite frame.
Definition: TGeoTabManager.cxx:85
TGeoManager::GetListOfMedia
TList * GetListOfMedia() const
Definition: TGeoManager.h:462
TGShutter::AddItem
virtual void AddItem(TGShutterItem *item)
Add shutter item to shutter frame.
Definition: TGShutter.cxx:71
TGeoManagerEditor::fTabMgr
TGeoTabManager * fTabMgr
Definition: TGeoManagerEditor.h:53
TGeoManager::Export
virtual Int_t Export(const char *filename, const char *name="", Option_t *option="vg")
Export this geometry to a file.
Definition: TGeoManager.cxx:3716
TGeoManagerEditor::fBSelMaterial
TGPictureButton * fBSelMaterial
Definition: TGeoManagerEditor.h:68
TGeoManagerEditor::fEditVolume
TGTextButton * fEditVolume
Definition: TGeoManagerEditor.h:102
TGShutterItem::GetContainer
TGFrame * GetContainer() const
Definition: TGShutter.h:65
TString::Format
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString...
Definition: TString.cxx:2335
Pixel_t
ULong_t Pixel_t
Definition: GuiTypes.h:41
TGeoConeSeg
A phi segment of a conical tube.
Definition: TGeoCone.h:100
TGNumberEntry::GetIntNumber
virtual Long_t GetIntNumber() const
Definition: TGNumberEntry.h:215
TGFrame::GetDefaultFrameBackground
static Pixel_t GetDefaultFrameBackground()
Get default frame background.
Definition: TGFrame.cxx:665
TGeoManagerEditor::DoCreateBox
void DoCreateBox()
Create a box.
Definition: TGeoManagerEditor.cxx:824
TGeoManagerEditor::DoCreateTranslation
void DoCreateTranslation()
Create a new translation.
Definition: TGeoManagerEditor.cxx:1129
TGeoManagerEditor::DoCreateCombi
void DoCreateCombi()
Create a new translation + rotation.
Definition: TGeoManagerEditor.cxx:1184
TGeoManagerEditor::DoEditVolume
void DoEditVolume()
Slot for editing selected volume.
Definition: TGeoManagerEditor.cxx:1220
TGeoManagerEditor::f5
TGCompositeFrame * f5
Definition: TGeoManagerEditor.h:110
TGeoManagerEditor::DoSelectTopVolume
void DoSelectTopVolume()
Slot for seting top geometry volume.
Definition: TGeoManagerEditor.cxx:1358
TGLabel::SetText
virtual void SetText(TGString *newText)
Set new text in label.
Definition: TGLabel.cxx:177
TGeoTabManager::GetMediumEditor
void GetMediumEditor(TGeoMedium *medium)
Get editor for a medium.
Definition: TGeoTabManager.cxx:142
TGeoManagerEditor::f2
TGCompositeFrame * f2
Definition: TGeoManagerEditor.h:107
TGeoElement
Base class for chemical elements.
Definition: TGeoElement.h:46
TGComboBox::Select
virtual void Select(Int_t id, Bool_t emit=kTRUE)
Make the selected item visible in the combo box window and emit signals according to the second param...
Definition: TGComboBox.cxx:443
TGCompositeFrame::TGCompositeFrame
TGCompositeFrame(const TGCompositeFrame &)
TGeoManagerEditor::DoCreateCone
void DoCreateCone()
Create a cone.
Definition: TGeoManagerEditor.cxx:944
TGedFrame::CreateEditorTabSubFrame
virtual TGVerticalFrame * CreateEditorTabSubFrame(const char *name)
Create a vertical frame to be used by &#39;owner&#39; in extra tab &#39;name&#39;.
Definition: TGedFrame.cxx:123
TGButtonGroup::SetRadioButtonExclusive
virtual void SetRadioButtonExclusive(Bool_t flag=kTRUE)
If enable is kTRUE, this button group will treat radio buttons as mutually exclusive, and other buttons according to IsExclusive().
Definition: TGButtonGroup.cxx:301
TGeoManagerEditor::fShapeButton
TGPictureButton * fShapeButton[21]
Definition: TGeoManagerEditor.h:88
TGShutter::GetItem
TGShutterItem * GetItem(const char *name)
returns a shutter item by name (name is hot string of shutter item)
Definition: TGShutter.cxx:300
TGeoManagerEditor::DoCreateRotation
void DoCreateRotation()
Create a new rotation.
Definition: TGeoManagerEditor.cxx:1143
TGFrame::SetBackgroundColor
virtual void SetBackgroundColor(Pixel_t back)
Set background color (override from TGWindow base class).
Definition: TGFrame.cxx:294
TGeoManagerEditor::DoCreateTorus
void DoCreateTorus()
Create a torus shape.
Definition: TGeoManagerEditor.cxx:1009
TGeoTrap
TRAP is a general trapezoid, i.e.
Definition: TGeoArb8.h:91
TGeoManagerEditor::DoSelectMaterial
void DoSelectMaterial()
Slot for selecting an existing material.
Definition: TGeoManagerEditor.cxx:1298
TGeoManagerEditor::DoCreateArb8
void DoCreateArb8()
Create an arbitrary polygone with maximum 8 vertices sitting on 2 parallel planes.
Definition: TGeoManagerEditor.cxx:911
TGeoManagerEditor::DoCreateMixture
void DoCreateMixture()
Create a new mixture.
Definition: TGeoManagerEditor.cxx:1099
TVirtualPad
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:59
TVirtualPad::GetView
virtual TView * GetView() const =0
TGeoManagerEditor::fSelectedShape2
TGeoShape * fSelectedShape2
Definition: TGeoManagerEditor.h:74
TGeoTabManager::GetVolumeTab
TGCompositeFrame * GetVolumeTab() const
Definition: TGeoTabManager.h:90
TGeoManagerEditor::fEditMedium
TGTextButton * fEditMedium
Definition: TGeoManagerEditor.h:99
TGeoManagerEditor::fSelectedMedium2
TGeoMedium * fSelectedMedium2
Definition: TGeoManagerEditor.h:83
TGeoManagerEditor::DoEditShape
void DoEditShape()
Slot for editing selected shape.
Definition: TGeoManagerEditor.cxx:1209
TGeoTrd2
A trapezoid with both x and y lengths varying with z.
Definition: TGeoTrd2.h:19
TQObject::Connect
Bool_t Connect(const char *signal, const char *receiver_class, void *receiver, const char *slot)
Non-static method is used to connect from the signal of this object to the receiver slot...
Definition: TQObject.cxx:1137
TGNumberEntry::Associate
virtual void Associate(const TGWindow *w)
Make w the window that will receive the generated messages.
Definition: TGNumberEntry.cxx:2005
TGeoPara
Parallelepiped class.
Definition: TGeoPara.h:19
TGeoManagerEditor::ShowSelectMaterial
void ShowSelectMaterial(Bool_t show=kTRUE)
Show/hide interface for material selection.
Definition: TGeoManagerEditor.cxx:1403
TGeoManagerEditor::f4
TGCompositeFrame * f4
Definition: TGeoManagerEditor.h:109
TGeoManagerEditor::DoCreateMedium
void DoCreateMedium()
Create a new medium.
Definition: TGeoManagerEditor.cxx:1113
TGeoShape
Base abstract class for all shapes.
Definition: TGeoShape.h:27
TGeoManagerEditor::ConnectSelected
void ConnectSelected(TCanvas *c)
Definition: TGeoManagerEditor.cxx:669
TGeoManagerEditor::fCloseGeometry
TGTextButton * fCloseGeometry
Definition: TGeoManagerEditor.h:106
TGeoManagerEditor::fSelectedMatrix
TGeoMatrix * fSelectedMatrix
Definition: TGeoManagerEditor.h:79
TGeoCombiTrans
Class describing rotation + translation.
Definition: TGeoMatrix.h:285
v
SVector< double, 2 > v
Definition: Dict.h:5
TGNumberEntry::SetNumStyle
void SetNumStyle(EStyle style)
Definition: TGNumberEntry.h:259
TGWidget::Associate
virtual void Associate(const TGWindow *w)
Definition: TGWidget.h:90
TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:488
TGeoTabManager::GetMakeTabManager
static TGeoTabManager * GetMakeTabManager(TGedEditor *ged)
Static method to return the tab manager currently appended to the pad or create one if not existing...
Definition: TGeoTabManager.cxx:197
TGWindow::GetName
virtual const char * GetName() const
Return unique name, used in SavePrimitive methods.
Definition: TGWindow.cxx:221
TGeoManagerEditor::ShowSelectVolume
void ShowSelectVolume(Bool_t show=kTRUE)
Show/hide interface for volume selection.
Definition: TGeoManagerEditor.cxx:1390
TGeoManager::GetListOfShapes
TObjArray * GetListOfShapes() const
Definition: TGeoManager.h:465
TGTab::SetTab
virtual Bool_t SetTab(Int_t tabIndex, Bool_t emit=kTRUE)
Brings the composite frame with the index tabIndex to the front and generate the following event if t...
Definition: TGTab.cxx:507
TGeoManagerEditor::SetModel
virtual void SetModel(TObject *obj)
Refresh editor according the selected obj.
Definition: TGeoManagerEditor.cxx:746
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:42
TGeoHype
Hyperboloid class defined by 5 parameters.
Definition: TGeoHype.h:19
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:925
TGeoManagerEditor::DoCreateTrap
void DoCreateTrap()
Create a general trapezoid.
Definition: TGeoManagerEditor.cxx:877
TGeoMatrix::RegisterYourself
virtual void RegisterYourself()
Register the matrix in the current manager, which will become the owner.
Definition: TGeoMatrix.cxx:575
TGeoManagerEditor::fSetTopVolume
TGTextButton * fSetTopVolume
Definition: TGeoManagerEditor.h:103
TGeoTabManager::GetVolumeEditor
void GetVolumeEditor(TGeoVolume *vol)
Get editor for a volume.
Definition: TGeoTabManager.cxx:116
TView::ShowAxis
virtual void ShowAxis()=0
TString::Strip
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition: TString.cxx:1070
TGeoElementTable::GetNelements
Int_t GetNelements() const
Definition: TGeoElement.h:415
TGeoManagerEditor::ShowSelectMedium
void ShowSelectMedium(Bool_t show=kTRUE)
Show/hide interface for medium selection.
Definition: TGeoManagerEditor.cxx:1413
TGeoManagerEditor::fEditMaterial
TGTextButton * fEditMaterial
Definition: TGeoManagerEditor.h:100
TGeoManagerEditor::fElementList
TGComboBox * fElementList
Definition: TGeoManagerEditor.h:94
TGeoManager::CloseGeometry
void CloseGeometry(Option_t *option="d")
Closing geometry implies checking the geometry validity, fixing shapes with negative parameters (run-...
Definition: TGeoManager.cxx:1452
TGeoTreeDialog::GetSelected
static TObject * GetSelected()
static; return selected object
Definition: TGeoTabManager.cxx:281
TGeoManagerEditor::fSelectedMaterial2
TGeoMaterial * fSelectedMaterial2
Definition: TGeoManagerEditor.h:65
TGeoManagerEditor::fVolumeName
TGTextEntry * fVolumeName
Definition: TGeoManagerEditor.h:63
TGNumberEntry::SetNumAttr
void SetNumAttr(EAttribute attr=kNEAAnyNumber)
Definition: TGNumberEntry.h:261
TGeoManager::GetListOfMatrices
TObjArray * GetListOfMatrices() const
Definition: TGeoManager.h:460
TGeoRotation
Class describing rotations.
Definition: TGeoMatrix.h:180
TGeoTabManager::GetPad
TVirtualPad * GetPad() const
Definition: TGeoTabManager.h:76
TGShutter::Layout
virtual void Layout()
Layout shutter items.
Definition: TGShutter.cxx:216
TGeoManagerEditor::DoCreateGtra
void DoCreateGtra()
Create a twisted trapezoid.
Definition: TGeoManagerEditor.cxx:890
TGTextEntry::GetText
const char * GetText() const
Definition: TGTextEntry.h:140
TString::Remove
TString & Remove(Ssiz_t pos)
Definition: TString.h:616
TGeoCtub
A tube segment cut with 2 planes.
Definition: TGeoTube.h:170
TGFrame::GetDefaultHeight
virtual UInt_t GetDefaultHeight() const
Definition: TGFrame.h:254
TCanvas
The Canvas class.
Definition: TCanvas.h:41
TGeoManagerEditor::~TGeoManagerEditor
virtual ~TGeoManagerEditor()
Destructor.
Definition: TGeoManagerEditor.cxx:622
TGeoManagerEditor::f6
TGCompositeFrame * f6
Definition: TGeoManagerEditor.h:111
TGeoManagerEditor::f7
TGCompositeFrame * f7
Definition: TGeoManagerEditor.h:112
TGeoManagerEditor::DoCreateHype
void DoCreateHype()
Create a hyperboloid.
Definition: TGeoManagerEditor.cxx:1053
TGeoManagerEditor::fMaterialName
TGTextEntry * fMaterialName
Definition: TGeoManagerEditor.h:62
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:279
gGeoManager
R__EXTERN TGeoManager * gGeoManager
Definition: TGeoManager.h:554
TGeoManagerEditor::DoCreateTubs
void DoCreateTubs()
Create a tube segment.
Definition: TGeoManagerEditor.cxx:931
TGeoManagerEditor::DoSelectMaterial2
void DoSelectMaterial2()
Slot for selecting an existing material and making a medium.
Definition: TGeoManagerEditor.cxx:1310
Double_t
double Double_t
Definition: RtypesCore.h:55
TGCompositeFrame::SetCleanup
virtual void SetCleanup(Int_t mode=kLocalCleanup)
Turn on automatic cleanup of child frames in dtor.
Definition: TGFrame.cxx:1054
TGComboBox::AddEntry
virtual void AddEntry(TGString *s, Int_t id)
Definition: TGComboBox.h:108
TGButton::SetEnabled
virtual void SetEnabled(Bool_t e=kTRUE)
Set enabled or disabled state of button.
Definition: TGButton.cxx:409
TGNumberEntry::GetNumber
virtual Double_t GetNumber() const
Definition: TGNumberEntry.h:212
TGClient::GetPicture
const TGPicture * GetPicture(const char *name)
Get picture from the picture pool.
Definition: TGClient.cxx:287
TGeoManagerEditor::f3
TGCompositeFrame * f3
Definition: TGeoManagerEditor.h:108
TGeoCone
Conical tube class.
Definition: TGeoCone.h:19
TGeoManagerEditor::fEditShape
TGTextButton * fEditShape
Definition: TGeoManagerEditor.h:98
TQObject::Disconnect
Bool_t Disconnect(const char *signal=0, void *receiver=0, const char *slot=0)
Disconnects signal of this object from slot of receiver.
Definition: TQObject.cxx:1295
TGeoManagerEditor::fEntryDensity
TGNumberEntry * fEntryDensity
Definition: TGeoManagerEditor.h:95
ETGeoVolumeWid
ETGeoVolumeWid
Definition: TGeoManagerEditor.cxx:91
TGCompositeFrame::AddFrame
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=0)
Add frame to the composite frame using the specified layout hints.
Definition: TGFrame.cxx:1099
TGButtonGroup::Show
virtual void Show()
Show group of buttons.
Definition: TGButtonGroup.cxx:529
TGeoMedium
Media are used to store properties related to tracking and which are useful only when using geometry ...
Definition: TGeoMedium.h:25
TGeoManagerEditor::TGeoManagerEditor
TGeoManagerEditor(const TGWindow *p=0, Int_t width=140, Int_t height=30, UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground())
Constructor for manager editor.
Definition: TGeoManagerEditor.cxx:113
TGeoManagerEditor::fMatrixButton
TGPictureButton * fMatrixButton[3]
Definition: TGeoManagerEditor.h:89
TGeoManagerEditor::SelectedSlot
virtual void SelectedSlot(TVirtualPad *pad, TObject *obj, Int_t event)
Connected to TCanvas::Selected.
Definition: TGeoManagerEditor.cxx:658
TGeoManagerEditor::fBSelMedium2
TGPictureButton * fBSelMedium2
Definition: TGeoManagerEditor.h:87
TGeoManagerEditor::DoSelectShape2
void DoSelectShape2()
Slot for selecting a shape for making a volume.
Definition: TGeoManagerEditor.cxx:1286
TGeoManagerEditor::fExportButton
TGTextButton * fExportButton
Definition: TGeoManagerEditor.h:93
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TGeoManagerEditor::fBSelShape
TGPictureButton * fBSelShape
Definition: TGeoManagerEditor.h:77
TGeoManagerEditor::fMediumButton
TGPictureButton * fMediumButton
Definition: TGeoManagerEditor.h:96
TGeoManagerEditor::DoCreatePgon
void DoCreatePgon()
Create a polygone shape.
Definition: TGeoManagerEditor.cxx:1038
TGeoManagerEditor::fGeometry
TGeoManager * fGeometry
Definition: TGeoManagerEditor.h:52
TGeoManagerEditor::fBSelShape2
TGPictureButton * fBSelShape2
Definition: TGeoManagerEditor.h:78
TGedFrame::fInit
Bool_t fInit
Definition: TGedFrame.h:55
TGComboBox::GetSelected
virtual Int_t GetSelected() const
Definition: TGComboBox.h:136
TGNumberEntry::GetNumberEntry
TGNumberEntryField * GetNumberEntry() const
Definition: TGNumberEntry.h:274
TGeoEltu
Elliptical tube class.
Definition: TGeoEltu.h:19
TGeoManagerEditor::fVolumeTab
TGCompositeFrame * fVolumeTab
Definition: TGeoManagerEditor.h:55
TGeoManagerEditor::fExportOption
TGRadioButton * fExportOption[2]
Definition: TGeoManagerEditor.h:92
TGObject::fClient
TGClient * fClient
Definition: TGObject.h:41
TGeoManagerEditor::fManagerTitle
TGTextEntry * fManagerTitle
Definition: TGeoManagerEditor.h:59
TGeoManagerEditor::DoCreatePcon
void DoCreatePcon()
Create a polycone shape.
Definition: TGeoManagerEditor.cxx:1023
TGeoManager::GetListOfVolumes
TObjArray * GetListOfVolumes() const
Definition: TGeoManager.h:463
TGeoManager::BuildDefaultMaterials
void BuildDefaultMaterials()
Now just a shortcut for GetElementTable.
Definition: TGeoManager.cxx:3372
f1
TF1 * f1
Definition: legend1.C:11
TObjArray::GetEntries
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition: TObjArray.cxx:494
TGeoManagerEditor::fBSelMatrix
TGPictureButton * fBSelMatrix
Definition: TGeoManagerEditor.h:81
TGeoManagerEditor::DoCreateVolume
void DoCreateVolume()
Create a new volume.
Definition: TGeoManagerEditor.cxx:1157
TGShutterItem::GetButton
TGButton * GetButton() const
Definition: TGShutter.h:64
TGeoManagerEditor::fEditMatrix
TGTextButton * fEditMatrix
Definition: TGeoManagerEditor.h:101
TGeoElementTable::GetElement
TGeoElement * GetElement(Int_t z)
Definition: TGeoElement.h:408
TGedEditor::DisconnectFromCanvas
virtual void DisconnectFromCanvas()
Disconnect this editor from the Selected signal of fCanvas.
Definition: TGedEditor.cxx:322
TGeoManagerEditor::fMaterialButton
TGPictureButton * fMaterialButton[2]
Definition: TGeoManagerEditor.h:91
TGTextEntry::SetText
virtual void SetText(const char *text, Bool_t emit=kTRUE)
Sets text entry to text, clears the selection and moves the cursor to the end of the line...
Definition: TGTextEntry.cxx:621
TGeoManager::GetTopVolume
TGeoVolume * GetTopVolume() const
Definition: TGeoManager.h:497
TGeoManager::IsClosed
Bool_t IsClosed() const
Definition: TGeoManager.h:279
TGeoManagerEditor::DoCreateCtub
void DoCreateCtub()
Create a cut tube.
Definition: TGeoManagerEditor.cxx:983
TGeoManagerEditor::fMediumName
TGTextEntry * fMediumName
Definition: TGeoManagerEditor.h:60
TCollection::GetSize
virtual Int_t GetSize() const
Definition: TCollection.h:95
TGCompositeFrame::Cleanup
virtual void Cleanup()
Cleanup and delete all objects contained in this composite frame.
Definition: TGFrame.cxx:949
TGeoShape::Draw
virtual void Draw(Option_t *option="")
Draw this shape.
Definition: TGeoShape.cxx:723
TGRadioButton::IsDown
virtual Bool_t IsDown() const
Definition: TGButton.h:375
kTRUE
const Bool_t kTRUE
Definition: Rtypes.h:91
TNamed::SetTitle
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:155
TGedFrame::fGedEditor
TGedEditor * fGedEditor
Definition: TGedFrame.h:56
TGeoTabManager::GetMatrixEditor
void GetMatrixEditor(TGeoMatrix *matrix)
Get editor for a matrix.
Definition: TGeoTabManager.cxx:129
TGButton::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=400)
Set tool tip text associated with this button.
Definition: TGButton.cxx:395
TGFrame::ChangeOptions
virtual void ChangeOptions(UInt_t options)
Change frame options. Options is an OR of the EFrameTypes.
Definition: TGFrame.cxx:303
TGeoManagerEditor::DoCreateAssembly
void DoCreateAssembly()
Create a new volume assembly.
Definition: TGeoManagerEditor.cxx:1171
TGeoManagerEditor::DoEditMatrix
void DoEditMatrix()
Slot for editing selected matrix.
Definition: TGeoManagerEditor.cxx:1253
name
char name[80]
Definition: TGX11.cxx:109
TGeoManagerEditor::fSelectedMaterial
TGeoMaterial * fSelectedMaterial
Definition: TGeoManagerEditor.h:64
TGeoManagerEditor::DoName
void DoName()
Change name/title of the geometry.
Definition: TGeoManagerEditor.cxx:800
TGNumberEntry::GetDefaultHeight
UInt_t GetDefaultHeight() const
Definition: TGNumberEntry.h:286
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:52
TGeoTabManager::GetShapeEditor
void GetShapeEditor(TGeoShape *shape)
Get editor for a shape.
Definition: TGeoTabManager.cxx:103
TString::Data
const char * Data() const
Definition: TString.h:349
TGedEditor::GetCanvas
virtual TCanvas * GetCanvas() const
Definition: TGedEditor.h:96
TGeoTubeSeg
A phi segment of a tube.
Definition: TGeoTube.h:90