doc/v626/TGeoManagerEditor_8cxx_source.html

// @(#):$Id$

// Author: M.Gheata


/*************************************************************************

 * Copyright (C) 1995-2002, Rene Brun and Fons Rademakers.               *

 * All rights reserved.                                                  *

 *                                                                       *

 * For the licensing terms see $ROOTSYS/LICENSE.                         *

 * For the list of contributors see $ROOTSYS/README/CREDITS.             *

 *************************************************************************/


/** \class TGeoManagerEditor

\ingroup Geometry_builder


Editor for TGeoManager class. Provides also builder functionality for the

main TGeo objects: TGeoVolume, TGeoShape - derived classes, TGeoMaterial,

TGeoMatrix - derived transformations and TGeoMedium.

The GUI represents the main entry point for editing geometry classes. It

can be started either by:


  1. TGeoManager::Edit(). The method must be used when starting from a new

     geometry.

  2. Left-click on the 40x40 pixels top-right corner of a pad containing a

     drawn volume. The region is always accesible when drawing geometry elements

     and allows also restoring the manager editor in the "Style" tab of the GED

     editor anytime.


The TGeoManager editor is vertically split by a TGShutter widget into the

following categories:


  - General. This allows changing the name/title of the geometry, setting the

    top volume, closing the geometry and saving the geometry in a file. The name

    of the geometry file is formed by geometry_name.C/.root depending if the geometry

    need to be saved as a C macro or a .root file.

  - Shapes. The category provide buttons for creation of all supported shapes. The

    new shape name is chosen by the interface, but can be changed from the shape

    editor GUI. Existing shapes can be browsed and edited from the same category.

  - Volumes. The category allows the creation of a new volume having a given name,

    shape and medium. For creating a volume assembly only the name is relevant.

    Existing volumes can be browsed or edited from this category.

  - Materials. Allows creation of new materials/mixtures or editing existing ones.

  - Media. The same for creation/editing of tracking media (materials having a set

    of properties related to tracking)

  - Matrices. Allows creation of translations, rotations or combined transformations.

    Existing matrices can also be browser/edited.

*/


#include "TVirtualPad.h"

#include "TCanvas.h"

#include "TGTab.h"

#include "TG3DLine.h"

#include "TGComboBox.h"

#include "TGButton.h"

#include "TGButtonGroup.h"

#include "TGTextEntry.h"

#include "TGNumberEntry.h"

#include "TGLabel.h"

#include "TGShutter.h"


#include "TGeoVolumeEditor.h"

#include "TGeoNodeEditor.h"

#include "TGeoTabManager.h"

#include "TGeoVolume.h"

#include "TGeoManager.h"

#include "TGeoMatrix.h"

#include "TGeoBBox.h"

#include "TGeoPara.h"

#include "TGeoArb8.h"

#include "TGeoTube.h"

#include "TGeoEltu.h"

#include "TGeoHype.h"

#include "TGeoTorus.h"

#include "TGeoTrd1.h"

#include "TGeoTrd2.h"

#include "TGeoCone.h"

#include "TGeoSphere.h"

#include "TGeoPcon.h"

#include "TGeoPgon.h"

#include "TGeoElement.h"

#include "TGeoMaterial.h"

#include "TView.h"


#include "TGeoManagerEditor.h"

#include "TGedEditor.h"


ClassImp(TGeoManagerEditor);


enum ETGeoVolumeWid {

   kMANAGER_NAME, kMANAGER_TITLE,

   kMANAGER_SHAPE_SELECT, kMANAGER_MEDIA_SELECT,kMANAGER_MATERIAL_SELECT, kMANAGER_ELEMENT_SELECT,

   kMANAGER_SHAPE_SELECT2, kMANAGER_MEDIUM_SELECT2, kMANAGER_VOLUME_SELECT,

   kMANAGER_EDIT_SHAPE, kMANAGER_EDIT_MEDIUM, kMANAGER_DENSITY_SELECT, kMANAGER_NELEM_SELECT,

   kMANAGER_MATERIAL_SELECT2, kMANAGER_MEDIUM_SELECT, kMANAGER_MATRIX_SELECT, kMANAGER_TOP_SELECT,

   kEXPORT_ROOT, kEXPORT_C, kEXPORT_GEOMETRY,

   kCAT_GENERAL, kCAT_SHAPES, kCAT_VOLUMES, kCAT_MEDIA, kCAT_MATERIALS, kCAT_MATRICES,

   kCREATE_BOX, kCREATE_PARA, kCREATE_TRD1, kCREATE_TRD2,

   kCREATE_TRAP, kCREATE_GTRA, kCREATE_XTRU, kCREATE_ARB8,

   kCREATE_TUBE, kCREATE_TUBS, kCREATE_CONE, kCREATE_CONS,

   kCREATE_SPHE, kCREATE_CTUB, kCREATE_ELTU, kCREATE_TORUS,

   kCREATE_PCON, kCREATE_PGON, kCREATE_HYPE, kCREATE_PARAB, kCREATE_COMP,

   kCREATE_MATERIAL, kCREATE_MIXTURE, kCREATE_MEDIUM, kCREATE_VOLUME, kCREATE_ASSEMBLY,

   kCREATE_TRANSLATION, kCREATE_ROTATION, kCREATE_COMBI,

   kMEDIUM_NAME, kMEDIUM_ID, kMATRIX_NAME, kMATERIAL_NAME, kVOLUME_NAME,

   kMANAGER_APPLY, kMANAGER_CANCEL, kMANAGER_UNDO

};


////////////////////////////////////////////////////////////////////////////////

/// Constructor for manager editor.


TGeoManagerEditor::TGeoManagerEditor(const TGWindow *p, Int_t width,

                                     Int_t height, UInt_t options, Pixel_t back)

   : TGedFrame(p, width, height, options | kVerticalFrame, back)

{

   fGeometry = gGeoManager;

   fTabMgr   = 0;

   fTab      = 0;

   fConnectedCanvas = 0;


   fIsModified = kFALSE;

   TGCompositeFrame *f1;

   TGLabel *label;


   // TGShutter for categories

   fCategories = new TGShutter(this, kSunkenFrame | kFixedHeight);


   TGCompositeFrame *container;

   Pixel_t color;

   // General settings

   TGShutterItem *si = new TGShutterItem(fCategories, new TGHotString("General"),kCAT_GENERAL);

   container = (TGCompositeFrame*)si->GetContainer();

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);

   // TextEntry for manager name

   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Name/Title"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));

   fManagerName = new TGTextEntry(container, new TGTextBuffer(50), kMANAGER_NAME);

   fManagerName->Resize(135, fManagerName->GetDefaultHeight());

   fManagerName->SetToolTipText("Enter the geometry name");

   container->AddFrame(fManagerName, new TGLayoutHints(kLHintsLeft, 3, 1, 0, 0));

   fManagerTitle = new TGTextEntry(container, new TGTextBuffer(50), kMANAGER_TITLE);

   fManagerTitle->Resize(135, fManagerTitle->GetDefaultHeight());

   fManagerTitle->SetToolTipText("Enter the geometry name");

   container->AddFrame(fManagerTitle, new TGLayoutHints(kLHintsLeft, 3, 1, 0, 0));

   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Export geometry"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 6, 0));

   TString stitle = "Options";

   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   TGButtonGroup *bg = new TGVButtonGroup(f1, stitle);

   fExportOption[0] = new TGRadioButton(bg, ".root", kEXPORT_ROOT);

   fExportOption[1] = new TGRadioButton(bg, ".C", kEXPORT_C);

   fExportButton = new TGTextButton(f1, "Export", kEXPORT_GEOMETRY);

   bg->SetRadioButtonExclusive();

   bg->SetButton(kEXPORT_ROOT);

   bg->Show();

   f1->AddFrame(bg, new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(fExportButton, new TGLayoutHints(kLHintsLeft, 20, 2, 22, 0));

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 2, 2));

   // Close geometry

   f7 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);

   f1 = new TGCompositeFrame(f7, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Close geometry"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   f7->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));

   f1 = new TGCompositeFrame(f7, 155, 30, kHorizontalFrame | kFixedWidth);

   fLSelTop = new TGLabel(f1, "Select top");

   gClient->GetColorByName("#0000ff", color);

   fLSelTop->SetTextColor(color);

   fLSelTop->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelTop, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelTop = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_TOP_SELECT);

   fBSelTop->SetToolTipText("Select the top volume");

   fBSelTop->Associate(this);

   f1->AddFrame(fBSelTop, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));

   fCloseGeometry = new TGTextButton(f1, "Close");

   f1->AddFrame(fCloseGeometry, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));

   fCloseGeometry->SetToolTipText("Close geometry to make it ready for tracking");

   fCloseGeometry->Associate(this);

   f7->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));

   container->AddFrame(f7, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));


   si = new TGShutterItem(fCategories, new TGHotString("Shapes"),kCAT_SHAPES);

   container = (TGCompositeFrame*)si->GetContainer();

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);


   // Shape creators

   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Create new shape"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));

   TGLayoutHints *lhb = new TGLayoutHints(kLHintsLeft, 0, 4, 0, 0);

   TGLayoutHints *lhf1 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2, 2, 2, 2);

   Int_t ipict;

   f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);

   fShapeButton[0] = new TGPictureButton(f1, fClient->GetPicture("geobbox_t.xpm"), kCREATE_BOX);

   fShapeButton[0]->SetToolTipText("Create a box");

   fShapeButton[1] = new TGPictureButton(f1, fClient->GetPicture("geopara_t.xpm"), kCREATE_PARA);

   fShapeButton[1]->SetToolTipText("Create a parallelipiped");

   fShapeButton[2] = new TGPictureButton(f1, fClient->GetPicture("geotrd1_t.xpm"), kCREATE_TRD1);

   fShapeButton[2]->SetToolTipText("Create a TRD1 trapezoid");

   fShapeButton[3] = new TGPictureButton(f1, fClient->GetPicture("geotrd2_t.xpm"), kCREATE_TRD2);

   fShapeButton[3]->SetToolTipText("Create a TRD2 trapezoid");

   fShapeButton[4] = new TGPictureButton(f1, fClient->GetPicture("geotrap_t.xpm"), kCREATE_TRAP);

   fShapeButton[4]->SetToolTipText("Create a general trapezoid");

   fShapeButton[5] = new TGPictureButton(f1, fClient->GetPicture("geogtra_t.xpm"), kCREATE_GTRA);

   fShapeButton[5]->SetToolTipText("Create a general twisted trapezoid");

   for (ipict=0; ipict<6; ipict++) f1->AddFrame(fShapeButton[ipict],lhb);

   container->AddFrame(f1, lhf1);

   f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);

   fShapeButton[6] = new TGPictureButton(f1, fClient->GetPicture("geoxtru_t.xpm"), kCREATE_XTRU);

   fShapeButton[6]->SetToolTipText("Create a extruded polygone");

   fShapeButton[7] = new TGPictureButton(f1, fClient->GetPicture("geoarb8_t.xpm"), kCREATE_ARB8);

   fShapeButton[7]->SetToolTipText("Create an arbitrary trapezoid with 8 vertices");

   fShapeButton[8] = new TGPictureButton(f1, fClient->GetPicture("geotube_t.xpm"), kCREATE_TUBE);

   fShapeButton[8]->SetToolTipText("Create a cylindrical pipe");

   fShapeButton[9] = new TGPictureButton(f1, fClient->GetPicture("geotubeseg_t.xpm"), kCREATE_TUBS);

   fShapeButton[9]->SetToolTipText("Create a cylindrical pipe within a phi range");

   fShapeButton[10] = new TGPictureButton(f1, fClient->GetPicture("geocone_t.xpm"), kCREATE_CONE);

   fShapeButton[10]->SetToolTipText("Create a conical pipe");

   fShapeButton[11] = new TGPictureButton(f1, fClient->GetPicture("geoconeseg_t.xpm"), kCREATE_CONS);

   fShapeButton[11]->SetToolTipText("Create a conical pipe within a phi range");

   for (ipict=0; ipict<6; ipict++) f1->AddFrame(fShapeButton[ipict+6],lhb);

   container->AddFrame(f1, lhf1);

   f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);

   fShapeButton[12] = new TGPictureButton(f1, fClient->GetPicture("geosphere_t.xpm"), kCREATE_SPHE);

   fShapeButton[12]->SetToolTipText("Create a spherical sector");

   fShapeButton[13] = new TGPictureButton(f1, fClient->GetPicture("geoctub_t.xpm"), kCREATE_CTUB);

   fShapeButton[13]->SetToolTipText("Create a cut tube");

   fShapeButton[14] = new TGPictureButton(f1, fClient->GetPicture("geoeltu_t.xpm"), kCREATE_ELTU);

   fShapeButton[14]->SetToolTipText("Create an elliptical tube");

   fShapeButton[15] = new TGPictureButton(f1, fClient->GetPicture("geotorus_t.xpm"), kCREATE_TORUS);

   fShapeButton[15]->SetToolTipText("Create a toroidal tube with a phi range");

   fShapeButton[16] = new TGPictureButton(f1, fClient->GetPicture("geopcon_t.xpm"), kCREATE_PCON);

   fShapeButton[16]->SetToolTipText("Create a polycone shape");

   fShapeButton[17] = new TGPictureButton(f1, fClient->GetPicture("geopgon_t.xpm"), kCREATE_PGON);

   fShapeButton[17]->SetToolTipText("Create a polygon shape");

   for (ipict=0; ipict<6; ipict++) f1->AddFrame(fShapeButton[ipict+12],lhb);

   container->AddFrame(f1, lhf1);

   f1 = new TGCompositeFrame(container, 118, 30, kHorizontalFrame);

   fShapeButton[18] = new TGPictureButton(f1, fClient->GetPicture("geohype_t.xpm"), kCREATE_HYPE);

   fShapeButton[18]->SetToolTipText("Create a hyperboloid");

   fShapeButton[19] = new TGPictureButton(f1, fClient->GetPicture("geoparab_t.xpm"), kCREATE_PARAB);

   fShapeButton[19]->SetToolTipText("Create a paraboloid");

   fShapeButton[20] = new TGPictureButton(f1, fClient->GetPicture("geocomposite_t.xpm"), kCREATE_COMP);

   fShapeButton[20]->SetToolTipText("Create a composite shape");

   for (ipict=0; ipict<3; ipict++) f1->AddFrame(fShapeButton[ipict+18],lhb);

   container->AddFrame(f1, lhf1);


   // List of shapes

   f2 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);

   f1 = new TGCompositeFrame(f2, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Existing shapes"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   f2->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));

   f1 = new TGCompositeFrame(f2, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedShape = 0;

   fLSelShape = new TGLabel(f1, "Select shape");

   gClient->GetColorByName("#0000ff", color);

   fLSelShape->SetTextColor(color);

   fLSelShape->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelShape, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelShape = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_SHAPE_SELECT);

   fBSelShape->SetToolTipText("Select one of the existing shapes");

   fBSelShape->Associate(this);

   f1->AddFrame(fBSelShape, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));

   fEditShape = new TGTextButton(f1, "Edit");

   f1->AddFrame(fEditShape, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));

   fEditShape->SetToolTipText("Edit selected shape");

   fEditShape->Associate(this);

   f2->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));

   container->AddFrame(f2, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));


   // Volumes category

   si = new TGShutterItem(fCategories, new TGHotString("Volumes"),kCAT_VOLUMES);

   container = (TGCompositeFrame*)si->GetContainer();

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);


   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Create new volume"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));


   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));

   fVolumeName = new TGTextEntry(f1, new TGTextBuffer(50), kVOLUME_NAME);

   fVolumeName->Resize(100, fVolumeName->GetDefaultHeight());

   fVolumeName->SetToolTipText("Enter the name for the new volume");

   f1->AddFrame(fVolumeName, new TGLayoutHints(kLHintsRight, 3, 1, 2, 5));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));


   // ComboBox for shape component

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedShape2 = 0;

   fLSelShape2 = new TGLabel(f1, "Select shape");

   gClient->GetColorByName("#0000ff", color);

   fLSelShape2->SetTextColor(color);

   fLSelShape2->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelShape2, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelShape2 = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_SHAPE_SELECT2);

   fBSelShape2->SetToolTipText("Select one of the existing shapes");

   fBSelShape2->Associate(this);

   f1->AddFrame(fBSelShape2, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));


   // ComboBox for medium component

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedMedium2 = 0;

   fLSelMedium2 = new TGLabel(f1, "Select medium");

   gClient->GetColorByName("#0000ff", color);

   fLSelMedium2->SetTextColor(color);

   fLSelMedium2->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelMedium2, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelMedium2 = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MEDIUM_SELECT2);

   fBSelMedium2->SetToolTipText("Select one of the existing media");

   fBSelMedium2->Associate(this);

   f1->AddFrame(fBSelMedium2, new TGLayoutHints(kLHintsLeft, 1, 1, 1, 1));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));

   // Picture buttons for different volumes

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));

   fVolumeButton[0] = new TGPictureButton(f1, fClient->GetPicture("geovolume_t.xpm"), kCREATE_VOLUME);

   fVolumeButton[0]->SetToolTipText("Create a new volume from shape and medium");

   fVolumeButton[1] = new TGPictureButton(f1, fClient->GetPicture("geoassembly_t.xpm"), kCREATE_ASSEMBLY);

   fVolumeButton[1]->SetToolTipText("Create a new volume assembly having the selected name");

   for (ipict=0; ipict<2; ipict++) f1->AddFrame(fVolumeButton[ipict],lhb);

   container->AddFrame(f1, lhf1);

   // List of volumes

   f3 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);

   f1 = new TGCompositeFrame(f3, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Existing volumes"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   f3->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));

   f1 = new TGCompositeFrame(f3, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedVolume = 0;

   fLSelVolume = new TGLabel(f1, "Select volume");

   gClient->GetColorByName("#0000ff", color);

   fLSelVolume->SetTextColor(color);

   fLSelVolume->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelVolume, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelVolume = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_VOLUME_SELECT);

   fBSelVolume->SetToolTipText("Select one of the existing volumes");

   fBSelVolume->Associate(this);

   f1->AddFrame(fBSelVolume, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));

   f3->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));

   f1 = new TGCompositeFrame(f3, 155, 30, kHorizontalFrame | kFixedWidth);

   fEditVolume = new TGTextButton(f1, " Edit ");

   f1->AddFrame(fEditVolume, new TGLayoutHints(kLHintsLeft, 20, 1, 2, 2));

   fEditVolume->SetToolTipText("Edit selected volume");

   fEditVolume->Associate(this);

   fSetTopVolume = new TGTextButton(f1, "Set top");

   f1->AddFrame(fSetTopVolume, new TGLayoutHints(kLHintsRight, 1, 20, 2, 2));

   fSetTopVolume->SetToolTipText("Set top volume for geometry");

   fSetTopVolume->Associate(this);

   f3->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));

   container->AddFrame(f3, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));


   // Materials category

   si = new TGShutterItem(fCategories, new TGHotString("Materials"),kCAT_MATERIALS);

   container = (TGCompositeFrame*)si->GetContainer();

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);


   // Material creators

   gGeoManager->BuildDefaultMaterials();

   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Create material/mixt."), new TGLayoutHints(kLHintsLeft, 2, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));

   fMaterialName = new TGTextEntry(f1, new TGTextBuffer(50), kMATERIAL_NAME);

   fMaterialName->Resize(100, fMaterialName->GetDefaultHeight());

   fMaterialName->SetToolTipText("Enter the new material name");

   f1->AddFrame(fMaterialName, new TGLayoutHints(kLHintsRight, 3, 1, 2, 5));

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));


   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Element"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));

   fElementList = new TGComboBox(f1, kMANAGER_ELEMENT_SELECT);

   fElementList->Resize(100, fManagerName->GetDefaultHeight());

   TGeoElementTable *table = gGeoManager->GetElementTable();

   if (table) {

      TGeoElement *element;

      for (Int_t i=0; i<table->GetNelements(); i++) {

         element = table->GetElement(i);

         fElementList->AddEntry(element->GetTitle(),i);

      }

   }

   fElementList->Select(0);

   f1->AddFrame(fElementList, new TGLayoutHints(kLHintsRight, 2, 2, 4, 4));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 2, 2));

   // Number entry for density

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Density"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));

   fEntryDensity = new TGNumberEntry(f1, 0., 5, kMANAGER_DENSITY_SELECT);

   fEntryDensity->SetNumStyle(TGNumberFormat::kNESRealThree);

   fEntryDensity->SetNumAttr(TGNumberFormat::kNEANonNegative);

   fEntryDensity->Resize(100,fEntryDensity->GetDefaultHeight());

   TGTextEntry *nef = (TGTextEntry*)fEntryDensity->GetNumberEntry();

   nef->SetToolTipText("Enter material/mixture density");

   fEntryDensity->SetNumber(0);

   fEntryDensity->Associate(this);

   f1->AddFrame(fEntryDensity, new TGLayoutHints(kLHintsRight, 2, 2, 2, 2));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 2, 2));

   // Buttons for creating materials/mixtures

   // Picture buttons for different volumes

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));

   fMaterialButton[0] = new TGPictureButton(f1, fClient->GetPicture("geomaterial_t.xpm"), kCREATE_MATERIAL);

   fMaterialButton[0]->SetToolTipText("Create a new material from element and density");

   fMaterialButton[1] = new TGPictureButton(f1, fClient->GetPicture("geomixture_t.xpm"), kCREATE_MIXTURE);

   fMaterialButton[1]->SetToolTipText("Create a new mixture with selected density");

   for (ipict=0; ipict<2; ipict++) f1->AddFrame(fMaterialButton[ipict],lhb);

   container->AddFrame(f1, lhf1);


   // List of materials

   f4 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);

   f1 = new TGCompositeFrame(f4, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Existing materials"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   f4->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));

   f1 = new TGCompositeFrame(f4, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedMaterial = 0;

   fLSelMaterial = new TGLabel(f1, "Select material");

   gClient->GetColorByName("#0000ff", color);

   fLSelMaterial->SetTextColor(color);

   fLSelMaterial->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelMaterial, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelMaterial = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MATERIAL_SELECT);

   fBSelMaterial->SetToolTipText("Select one of the existing materials");

   fBSelMaterial->Associate(this);

   f1->AddFrame(fBSelMaterial, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));

   fEditMaterial = new TGTextButton(f1, "Edit");

   f1->AddFrame(fEditMaterial, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));

   fEditMaterial->SetToolTipText("Edit selected material");

   fEditMaterial->Associate(this);

   f4->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));

   container->AddFrame(f4, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));


   si = new TGShutterItem(fCategories, new TGHotString("Media"),kCAT_MEDIA);

   container = (TGCompositeFrame*)si->GetContainer();

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);


   // Media category

   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Create new medium"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));


   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));

   fMediumName = new TGTextEntry(f1, new TGTextBuffer(50), kMEDIUM_NAME);

   fMediumName->Resize(60, fMediumName->GetDefaultHeight());

   fMediumName->SetToolTipText("Enter the new medium name");

   f1->AddFrame(fMediumName, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 5));


   fMediumId = new TGNumberEntry(f1, 0., 5, kMEDIUM_ID);

   fMediumId->SetNumStyle(TGNumberFormat::kNESInteger);

   fMediumId->SetNumAttr(TGNumberFormat::kNEAPositive);

   fMediumId->Resize(35,fMediumId->GetDefaultHeight());

   nef = (TGTextEntry*)fMediumId->GetNumberEntry();

   nef->SetToolTipText("Enter medium ID");

   fMediumId->SetNumber(fGeometry->GetListOfMedia()->GetSize());

   fMediumId->Associate(this);

   f1->AddFrame(fMediumId, new TGLayoutHints(kLHintsRight, 2, 2, 2 ,2));

   f1->AddFrame(new TGLabel(f1, "ID"), new TGLayoutHints(kLHintsRight, 1, 1, 6, 0));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));

   // ComboBox for materials

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedMaterial2 = 0;

   fLSelMaterial2 = new TGLabel(f1, "Select material");

   gClient->GetColorByName("#0000ff", color);

   fLSelMaterial2->SetTextColor(color);

   fLSelMaterial2->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelMaterial2, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelMaterial2 = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MATERIAL_SELECT2);

   fBSelMaterial2->SetToolTipText("Select one of the existing materials");

   fBSelMaterial2->Associate(this);

   f1->AddFrame(fBSelMaterial2, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));

   fMediumButton = new TGPictureButton(f1, fClient->GetPicture("geomedium_t.xpm"), kCREATE_MEDIUM);

   fMediumButton->SetToolTipText("Create a new medium from selected material");

   fMediumButton->Associate(this);

   f1->AddFrame(fMediumButton, new TGLayoutHints(kLHintsLeft, 5, 2, 2, 2));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 2, 2));


   // List of media

   f5 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);

   f1 = new TGCompositeFrame(f5, 145, 10, kHorizontalFrame | kLHintsExpandX | kFixedWidth | kOwnBackground);

   f1->AddFrame(label = new TGLabel(f1, "Existing media"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   f5->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 0, 0));

   f1 = new TGCompositeFrame(f5, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedMedium = 0;

   fLSelMedium = new TGLabel(f1, "Select medium");

   gClient->GetColorByName("#0000ff", color);

   fLSelMedium->SetTextColor(color);

   fLSelMedium->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelMedium, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelMedium = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MEDIA_SELECT);

   fBSelMedium->SetToolTipText("Select one of the existing media");

   fBSelMedium->Associate(this);

   f1->AddFrame(fBSelMedium, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));

   fEditMedium = new TGTextButton(f1, "Edit");

   f1->AddFrame(fEditMedium, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));

   fEditMedium->SetToolTipText("Edit selected medium");

   fEditMedium->Associate(this);

   f5->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));

   container->AddFrame(f5, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));


   // Matrix category

   si = new TGShutterItem(fCategories, new TGHotString("Matrices"),kCAT_MATRICES);

   container = (TGCompositeFrame*)si->GetContainer();

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);

   // Name entry

   f1 = new TGCompositeFrame(container, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Create new matrix"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   container->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));


   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Name"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));

   fMatrixName = new TGTextEntry(f1, new TGTextBuffer(50), kMATRIX_NAME);

   fMatrixName->Resize(100, fMatrixName->GetDefaultHeight());

   fMatrixName->SetToolTipText("Enter the new matrix name");

   f1->AddFrame(fMatrixName, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 5));

   container->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));

   // Picture buttons for different matrices

   f1 = new TGCompositeFrame(container, 155, 30, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(new TGLabel(f1, "Create..."), new TGLayoutHints(kLHintsLeft, 1, 5, 6, 0));

   fMatrixButton[0] = new TGPictureButton(f1, fClient->GetPicture("geotranslation_t.xpm"), kCREATE_TRANSLATION);

   fMatrixButton[0]->SetToolTipText("Create a translation");

   fMatrixButton[1] = new TGPictureButton(f1, fClient->GetPicture("georotation_t.xpm"), kCREATE_ROTATION);

   fMatrixButton[1]->SetToolTipText("Create a rotation");

   fMatrixButton[2] = new TGPictureButton(f1, fClient->GetPicture("geocombi_t.xpm"), kCREATE_COMBI);

   fMatrixButton[2]->SetToolTipText("Create a rotation + translation");

   for (ipict=0; ipict<3; ipict++) f1->AddFrame(fMatrixButton[ipict],lhb);

   container->AddFrame(f1, lhf1);

   // List of matrices

   f6 = new TGCompositeFrame(container, 155, 10, kVerticalFrame | kFixedWidth);

   f1 = new TGCompositeFrame(f6, 155, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(label = new TGLabel(f1, "Existing matrices"), new TGLayoutHints(kLHintsLeft, 1, 1, 0, 0));

   f1->AddFrame(new TGHorizontal3DLine(f1), new TGLayoutHints(kLHintsExpandX, 5, 5, 7, 7));

   gClient->GetColorByName("#ff0000", color);

   label->SetTextColor(color);

   f6->AddFrame(f1, new TGLayoutHints(kLHintsTop, 0, 0, 2, 0));

   f1 = new TGCompositeFrame(f6, 155, 30, kHorizontalFrame | kFixedWidth);

   fSelectedMatrix = 0;

   fLSelMatrix = new TGLabel(f1, "Select matrix");

   gClient->GetColorByName("#0000ff", color);

   fLSelMatrix->SetTextColor(color);

   fLSelMatrix->ChangeOptions(kSunkenFrame | kDoubleBorder);

   f1->AddFrame(fLSelMatrix, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 1, 1, 2, 2));

   fBSelMatrix = new TGPictureButton(f1, fClient->GetPicture("rootdb_t.xpm"), kMANAGER_MATRIX_SELECT);

   fBSelMatrix->SetToolTipText("Select one of the existing matrices");

   fBSelMatrix->Associate(this);

   f1->AddFrame(fBSelMatrix, new TGLayoutHints(kLHintsLeft, 1, 1, 2, 2));

   fEditMatrix = new TGTextButton(f1, "Edit");

   f1->AddFrame(fEditMatrix, new TGLayoutHints(kLHintsRight, 1, 1, 2, 2));

   fEditMatrix->SetToolTipText("Edit selected matrix");

   fEditMatrix->Associate(this);

   f6->AddFrame(f1, new TGLayoutHints(kLHintsLeft, 0, 0, 0, 0));

   container->AddFrame(f6, new TGLayoutHints(kLHintsLeft, 0, 0, 6, 0));


   fCategories->Resize(163,370);

   AddFrame(fCategories, new TGLayoutHints(kLHintsLeft, 0, 0, 4, 4));


   fVolumeTab = CreateEditorTabSubFrame("Volume");


   // Set the fTab and disconnect editor from the canvas.

   fTab = fGedEditor->GetTab();

   TCanvas* edCanvas = fGedEditor->GetCanvas();

   fGedEditor->DisconnectFromCanvas();

   if (edCanvas != fConnectedCanvas) {

      DisconnectSelected();

      if (edCanvas)

         ConnectSelected(edCanvas);

      fConnectedCanvas = edCanvas;

   }

}


////////////////////////////////////////////////////////////////////////////////

/// Destructor.


TGeoManagerEditor::~TGeoManagerEditor()

{

   TGCompositeFrame *cont;

   cont = (TGCompositeFrame*)fCategories->GetItem("General")->GetContainer();

   TGeoTabManager::Cleanup(cont);

   fCategories->GetItem("General")->SetCleanup(0);

   cont = (TGCompositeFrame*)fCategories->GetItem("Shapes")->GetContainer();

   TGeoTabManager::Cleanup(cont);

   fCategories->GetItem("Shapes")->SetCleanup(0);

   cont = (TGCompositeFrame*)fCategories->GetItem("Volumes")->GetContainer();

   TGeoTabManager::Cleanup(cont);

   fCategories->GetItem("Volumes")->SetCleanup(0);

   cont = (TGCompositeFrame*)fCategories->GetItem("Materials")->GetContainer();

   TGeoTabManager::Cleanup(cont);

   fCategories->GetItem("Materials")->SetCleanup(0);

   cont = (TGCompositeFrame*)fCategories->GetItem("Media")->GetContainer();

   TGeoTabManager::Cleanup(cont);

   fCategories->GetItem("Media")->SetCleanup(0);

   cont = (TGCompositeFrame*)fCategories->GetItem("Matrices")->GetContainer();

   TGeoTabManager::Cleanup(cont);

   fCategories->GetItem("Matrices")->SetCleanup(0);


   delete fExportOption[0]; delete fExportOption[1];


   Cleanup();


   if (fTabMgr) {

      fTabMgr->GetVolumeTab()->Cleanup();

      delete fTabMgr;

   }

}


////////////////////////////////////////////////////////////////////////////////

/// Connected to TCanvas::Selected. TGeoManagerEditor takes this

/// function from TGedEditor and only uses it if obj is a TGeoVolume.


void TGeoManagerEditor::SelectedSlot(TVirtualPad* /*pad*/, TObject* obj, Int_t event)

{

   if (event == kButton1 && obj->InheritsFrom(TGeoVolume::Class())) {

      TGeoVolume* v = (TGeoVolume*) obj;

      fTabMgr->SetVolTabEnabled();

      fTabMgr->SetTab();

      fTabMgr->GetVolumeEditor(v);

      v->Draw();

   }

}


void TGeoManagerEditor::ConnectSelected(TCanvas *c)

{

   // Connect to TCanvas::Selected.


   c->Connect("Selected(TVirtualPad*,TObject*,Int_t)", "TGeoManagerEditor",

              this, "SelectedSlot(TVirtualPad*,TObject*,Int_t)");

}


void TGeoManagerEditor::DisconnectSelected()

{

   // Disconnect from TCanvas::Selected.


   if (fConnectedCanvas)

      Disconnect(fConnectedCanvas, "Selected(TVirtualPad*,TObject*,Int_t)",

                 this, "SelectedSlot(TVirtualPad*,TObject*,Int_t)");


}


////////////////////////////////////////////////////////////////////////////////

/// Connect signals to slots.


void TGeoManagerEditor::ConnectSignals2Slots()

{

   fManagerName->Connect("TextChanged(const char *)", "TGeoManagerEditor", this, "DoName()");

   fManagerTitle->Connect("TextChanged(const char *)", "TGeoManagerEditor", this, "DoName()");

   fExportButton->Connect("Clicked()", "TGeoManagerEditor", this, "DoExportGeometry()");

   fCloseGeometry->Connect("Clicked()", "TGeoManagerEditor", this, "DoCloseGeometry()");

   fShapeButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateBox()");

   fShapeButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreatePara()");

   fShapeButton[2]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTrd1()");

   fShapeButton[3]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTrd2()");

   fShapeButton[4]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTrap()");

   fShapeButton[5]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateGtra()");

   fShapeButton[6]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateXtru()");

   fShapeButton[7]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateArb8()");

   fShapeButton[8]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTube()");

   fShapeButton[9]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTubs()");

   fShapeButton[10]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCone()");

   fShapeButton[11]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCons()");

   fShapeButton[12]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateSphe()");

   fShapeButton[13]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCtub()");

   fShapeButton[14]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateEltu()");

   fShapeButton[15]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTorus()");

   fShapeButton[16]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreatePcon()");

   fShapeButton[17]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreatePgon()");

   fShapeButton[18]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateHype()");

   fShapeButton[19]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateParab()");

   fShapeButton[20]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateComposite()");

   fMatrixButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateTranslation()");

   fMatrixButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateRotation()");

   fMatrixButton[2]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateCombi()");

   fVolumeButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateVolume()");

   fVolumeButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateAssembly()");

   fBSelTop->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectTopVolume()");

   fBSelVolume->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectVolume()");

   fBSelShape->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectShape()");

   fBSelShape2->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectShape2()");

   fBSelMatrix->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMatrix()");

   fBSelMaterial->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMaterial()");

   fBSelMaterial2->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMaterial2()");

   fBSelMedium->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMedium()");

   fBSelMedium2->Connect("Clicked()", "TGeoManagerEditor", this, "DoSelectMedium2()");

   fSetTopVolume->Connect("Clicked()", "TGeoManagerEditor", this, "DoSetTopVolume()");

   fEditShape->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditShape()");

   fEditMedium->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditMedium()");

   fEditMaterial->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditMaterial()");

   fEditMatrix->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditMatrix()");

   fEditVolume->Connect("Clicked()", "TGeoManagerEditor", this, "DoEditVolume()");


   fMaterialButton[0]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateMaterial()");

   fMaterialButton[1]->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateMixture()");

   fMediumButton->Connect("Clicked()", "TGeoManagerEditor", this, "DoCreateMedium()");

}


////////////////////////////////////////////////////////////////////////////////

/// Refresh editor according the selected obj.


void TGeoManagerEditor::SetModel(TObject* obj)

{

   fGeometry = (TGeoManager*)obj;

   fManagerName->SetText(fGeometry->GetName());

   fManagerTitle->SetText(fGeometry->GetTitle());

   fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));

   fMaterialName->SetText(TString::Format("material%i", fGeometry->GetListOfMaterials()->GetSize()));

   fMediumName->SetText(TString::Format("medium%i", fGeometry->GetListOfMedia()->GetSize()));

   fVolumeName->SetText(TString::Format("volume%i", fGeometry->GetListOfVolumes()->GetEntries()));

   // Check if master volume can be set

   if (fGeometry->GetMasterVolume()) fSetTopVolume->SetEnabled(kFALSE);

   else fSetTopVolume->SetEnabled(kTRUE);

   // Check if geometry is already closed

   if (!fGeometry->IsClosed()) fCloseGeometry->SetEnabled(kTRUE);

   else {

      fCloseGeometry->SetEnabled(kFALSE);

      fBSelTop->SetEnabled(kFALSE);

   }

   // Check if volumes category can be activated

   if (!fGeometry->GetListOfShapes()->GetEntries() || !fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kFALSE);

   else

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   if (!fGeometry->GetListOfShapes()->GetEntries()) ShowSelectShape(kFALSE);

   else ShowSelectShape();

   if (!fGeometry->GetListOfVolumes()->GetEntries()) ShowSelectVolume(kFALSE);

   else ShowSelectVolume();

   if (!fGeometry->GetListOfMedia()->GetSize()) ShowSelectMedium(kFALSE);

   else ShowSelectMedium();

   if (!fGeometry->GetListOfMatrices()->GetEntries()) ShowSelectMatrix(kFALSE);

   else ShowSelectMatrix();


   // Check if media category can be activated

   if (!fGeometry->GetListOfMaterials()->GetSize()) {

      fCategories->GetItem("Media")->GetButton()->SetEnabled(kFALSE);

      ShowSelectMaterial(kFALSE);

   } else {

      fCategories->GetItem("Media")->GetButton()->SetEnabled(kTRUE);

      ShowSelectMaterial();

   }


   fTab->SetTab(0);

   fCategories->Layout();

   if (fTabMgr == 0) {

      fTabMgr = TGeoTabManager::GetMakeTabManager(fGedEditor);

      fTabMgr->fVolumeTab  = fVolumeTab;

   }

   if (fInit) ConnectSignals2Slots();

   // SetActive();

}


////////////////////////////////////////////////////////////////////////////////

/// Change name/title of the geometry


void TGeoManagerEditor::DoName()

{

   fGeometry->SetName(fManagerName->GetText());

   fGeometry->SetTitle(fManagerTitle->GetText());

}


////////////////////////////////////////////////////////////////////////////////

/// Export geometry as .root or .C file


void TGeoManagerEditor::DoExportGeometry()

{

   Bool_t asroot = fExportOption[0]->IsDown();

   TString s = fGeometry->GetName();

   s = s.Strip();

   s.Remove(20);

   const char *name;

   if (asroot) name = TString::Format("%s.root", s.Data());

   else        name = TString::Format("%s.C", s.Data());

   fGeometry->Export(name);

}


////////////////////////////////////////////////////////////////////////////////

/// Create a box.


void TGeoManagerEditor::DoCreateBox()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoBBox(TString::Format("box_%i",id), 1., 1., 1.);

   ShowSelectShape();

   // Check if volumes category can be activated

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a parallelipiped.


void TGeoManagerEditor::DoCreatePara()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoPara(TString::Format("para_%i",id), 1., 1., 1., 30., 20., 45.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a Trd1.


void TGeoManagerEditor::DoCreateTrd1()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoTrd1(TString::Format("trd1_%i",id), 0.5, 1., 1., 1.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a Trd2.


void TGeoManagerEditor::DoCreateTrd2()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoTrd2(TString::Format("trd2_%i",id), 0.5, 1., 0.5, 1., 1.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a general trapezoid.


void TGeoManagerEditor::DoCreateTrap()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

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

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a twisted trapezoid.


void TGeoManagerEditor::DoCreateGtra()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

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

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create an extruded polygone.


void TGeoManagerEditor::DoCreateXtru()

{

}


////////////////////////////////////////////////////////////////////////////////

/// Create an arbitrary polygone with maximum 8 vertices sitting on 2 parallel

/// planes


void TGeoManagerEditor::DoCreateArb8()

{

}


////////////////////////////////////////////////////////////////////////////////

/// Create a tube.


void TGeoManagerEditor::DoCreateTube()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoTube(TString::Format("tube_%i",id), 0.5, 1., 1.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a tube segment.


void TGeoManagerEditor::DoCreateTubs()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoTubeSeg(TString::Format("tubs_%i",id), 0.5, 1., 1.,0.,45.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a cone.


void TGeoManagerEditor::DoCreateCone()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoCone(TString::Format("cone_%i",id), 0.5, 0.5, 1., 1.5, 2.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a cone segment.


void TGeoManagerEditor::DoCreateCons()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoConeSeg(TString::Format("cons_%i",id), 0.5, 0.5, 1., 1.5, 2.,0.,45.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a sphere.


void TGeoManagerEditor::DoCreateSphe()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoSphere(TString::Format("sphere_%i",id), 0.5, 1., 0., 180., 0.,360.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a cut tube.


void TGeoManagerEditor::DoCreateCtub()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoCtub(TString::Format("ctub_%i",id), 0.5, 1., 1.,0.,45.,0.,0.,-1,0.,0.,1);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create an elliptical tube.


void TGeoManagerEditor::DoCreateEltu()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoEltu(TString::Format("para_%i",id), 1., 2., 1.5 );

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a torus shape.


void TGeoManagerEditor::DoCreateTorus()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoTorus(TString::Format("torus_%i",id), 10., 1., 1.5, 0, 360.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();


}


////////////////////////////////////////////////////////////////////////////////

/// Create a polycone shape.


void TGeoManagerEditor::DoCreatePcon()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoPcon(TString::Format("pcon_%i",id), 0., 360., 2);

   ((TGeoPcon*)fSelectedShape)->DefineSection(0, -1, 0.5, 1.);

   ((TGeoPcon*)fSelectedShape)->DefineSection(1, 1, 0.2, 0.5);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a polygone shape.


void TGeoManagerEditor::DoCreatePgon()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoPgon(TString::Format("pgon_%i",id), 0., 360.,6,2);

   ((TGeoPcon*)fSelectedShape)->DefineSection(0, -1, 0.5, 1.);

   ((TGeoPcon*)fSelectedShape)->DefineSection(1, 1, 0.2, 0.5);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a hyperboloid.


void TGeoManagerEditor::DoCreateHype()

{

   Int_t id = gGeoManager->GetListOfShapes()->GetEntries();

   fSelectedShape = new TGeoHype(TString::Format("hype_%i",id), 1., 15., 2., 30., 5.);

   ShowSelectShape();

   if (fGeometry->GetListOfMedia()->GetSize())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditShape();

}


////////////////////////////////////////////////////////////////////////////////

/// Create a paraboloid.


void TGeoManagerEditor::DoCreateParab()

{

}


////////////////////////////////////////////////////////////////////////////////

/// Create a composite shape.


void TGeoManagerEditor::DoCreateComposite()

{

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new material.


void TGeoManagerEditor::DoCreateMaterial()

{

   TGeoElement *el = fGeometry->GetElementTable()->GetElement(fElementList->GetSelected());

   if (!el) {

      Error("DoCreateMaterial", "Cannot find selected element in list");

      return;

   }

   Double_t density = fEntryDensity->GetNumber();

   const char *name = fMaterialName->GetText();

   fSelectedMaterial = new TGeoMaterial(name, el, density);

   ShowSelectMaterial();

   fCategories->GetItem("Media")->GetButton()->SetEnabled(kTRUE);

   DoEditMaterial();

   fMaterialName->SetText(TString::Format("material%i", fGeometry->GetListOfMaterials()->GetSize()));

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new mixture.


void TGeoManagerEditor::DoCreateMixture()

{

   Double_t density = fEntryDensity->GetNumber();

   const char *name = fMaterialName->GetText();

   fSelectedMaterial = new TGeoMixture(name, 1, density);

   ShowSelectMaterial();

   fCategories->GetItem("Media")->GetButton()->SetEnabled(kTRUE);

   DoEditMaterial();

   fMaterialName->SetText(TString::Format("material%i", fGeometry->GetListOfMaterials()->GetSize()));

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new medium.


void TGeoManagerEditor::DoCreateMedium()

{

   Int_t id = fMediumId->GetIntNumber();

   if (!fSelectedMaterial2) return;

   const char *name = fMediumName->GetText();

   fSelectedMedium = new TGeoMedium(name, id, fSelectedMaterial2);

   ShowSelectMedium();

   if (fGeometry->GetListOfShapes()->GetEntries())

      fCategories->GetItem("Volumes")->GetButton()->SetEnabled(kTRUE);

   DoEditMedium();

   fMediumName->SetText(TString::Format("medium%i", fGeometry->GetListOfMedia()->GetSize()));

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new translation.


void TGeoManagerEditor::DoCreateTranslation()

{

   const char *name = fMatrixName->GetText();

   fSelectedMatrix = new TGeoTranslation(name, 0., 0., 0.);

   fSelectedMatrix->SetBit(TGeoMatrix::kGeoTranslation);

   fSelectedMatrix->RegisterYourself();

   ShowSelectMatrix();

   DoEditMatrix();

   fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new rotation.


void TGeoManagerEditor::DoCreateRotation()

{

   const char *name = fMatrixName->GetText();

   fSelectedMatrix = new TGeoRotation(name);

   fSelectedMatrix->SetBit(TGeoMatrix::kGeoRotation);

   fSelectedMatrix->RegisterYourself();

   ShowSelectMatrix();

   DoEditMatrix();

   fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new volume.


void TGeoManagerEditor::DoCreateVolume()

{

   const char *name = fVolumeName->GetText();

   if (!fSelectedShape2 || !fSelectedMedium2) return;

   fSelectedVolume = new TGeoVolume(name, fSelectedShape2, fSelectedMedium2);

   fLSelVolume->SetText(name);

   ShowSelectVolume();

   DoEditVolume();

   fVolumeName->SetText(TString::Format("volume%i", fGeometry->GetListOfVolumes()->GetEntries()));

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new volume assembly.


void TGeoManagerEditor::DoCreateAssembly()

{

   const char *name = fVolumeName->GetText();

   fSelectedVolume = new TGeoVolumeAssembly(name);

   fLSelVolume->SetText(name);

   ShowSelectVolume();

   DoEditVolume();

   fVolumeName->SetText(TString::Format("volume%i", fGeometry->GetListOfVolumes()->GetEntries()));

}


////////////////////////////////////////////////////////////////////////////////

/// Create a new translation + rotation.


void TGeoManagerEditor::DoCreateCombi()

{

   const char *name = fMatrixName->GetText();

   fSelectedMatrix = new TGeoCombiTrans(name, 0., 0., 0., new TGeoRotation());

   fSelectedMatrix->RegisterYourself();

   fSelectedMatrix->SetBit(TGeoMatrix::kGeoTranslation);

   fSelectedMatrix->SetBit(TGeoMatrix::kGeoRotation);

   ShowSelectMatrix();

   DoEditMatrix();

   fMatrixName->SetText(TString::Format("matrix%i", fGeometry->GetListOfMatrices()->GetEntries()));

}


////////////////////////////////////////////////////////////////////////////////

/// Set top volume for the geometry.


void TGeoManagerEditor::DoSetTopVolume()

{

   if (!fSelectedVolume) return;

   fGeometry->SetTopVolume(fSelectedVolume);

   fSetTopVolume->SetEnabled(kFALSE);

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for editing selected shape.


void TGeoManagerEditor::DoEditShape()

{

   if (!fSelectedShape) return;

   fTabMgr->GetShapeEditor(fSelectedShape);

   fSelectedShape->Draw();

   fTabMgr->GetPad()->GetView()->ShowAxis();

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for editing selected volume.


void TGeoManagerEditor::DoEditVolume()

{

   if (!fSelectedVolume) {

      fTabMgr->SetVolTabEnabled(kFALSE);

      return;

   }

   fTabMgr->SetVolTabEnabled();

   fTabMgr->SetTab();

   fTabMgr->GetVolumeEditor(fSelectedVolume);

   fSelectedVolume->Draw();

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for editing selected medium.


void TGeoManagerEditor::DoEditMedium()

{

   if (!fSelectedMedium) return;

   fTabMgr->GetMediumEditor(fSelectedMedium);

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for editing selected material.


void TGeoManagerEditor::DoEditMaterial()

{

   if (!fSelectedMaterial) return;

   fTabMgr->GetMaterialEditor(fSelectedMaterial);

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for editing selected matrix.


void TGeoManagerEditor::DoEditMatrix()

{

   if (!fSelectedMatrix) return;

   fTabMgr->GetMatrixEditor(fSelectedMatrix);

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting an existing matrix.


void TGeoManagerEditor::DoSelectMatrix()

{

   TGeoMatrix *matrix = fSelectedMatrix;

   new TGeoMatrixDialog(fBSelMatrix, gClient->GetRoot(), 200,300);

   fSelectedMatrix = (TGeoMatrix*)TGeoMatrixDialog::GetSelected();

   if (fSelectedMatrix) fLSelMatrix->SetText(fSelectedMatrix->GetName());

   else fSelectedMatrix = matrix;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting an existing shape.


void TGeoManagerEditor::DoSelectShape()

{

   TGeoShape *shape = fSelectedShape;

   new TGeoShapeDialog(fBSelShape, gClient->GetRoot(), 200,300);

   fSelectedShape = (TGeoShape*)TGeoShapeDialog::GetSelected();

   if (fSelectedShape) fLSelShape->SetText(fSelectedShape->GetName());

   else fSelectedShape = shape;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting a shape for making a volume.


void TGeoManagerEditor::DoSelectShape2()

{

   TGeoShape *shape = fSelectedShape2;

   new TGeoShapeDialog(fBSelShape2, gClient->GetRoot(), 200,300);

   fSelectedShape2 = (TGeoShape*)TGeoShapeDialog::GetSelected();

   if (fSelectedShape2) fLSelShape2->SetText(fSelectedShape2->GetName());

   else fSelectedShape2 = shape;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting an existing material.


void TGeoManagerEditor::DoSelectMaterial()

{

   TGeoMaterial *mat = fSelectedMaterial;

   new TGeoMaterialDialog(fBSelMaterial, gClient->GetRoot(), 200,300);

   fSelectedMaterial = (TGeoMaterial*)TGeoMaterialDialog::GetSelected();

   if (fSelectedMaterial) fLSelMaterial->SetText(fSelectedMaterial->GetName());

   else fSelectedMaterial = mat;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting an existing material and making a medium.


void TGeoManagerEditor::DoSelectMaterial2()

{

   TGeoMaterial *mat = fSelectedMaterial2;

   new TGeoMaterialDialog(fBSelMaterial2, gClient->GetRoot(), 200,300);

   fSelectedMaterial2 = (TGeoMaterial*)TGeoMaterialDialog::GetSelected();

   if (fSelectedMaterial2) fLSelMaterial2->SetText(fSelectedMaterial2->GetName());

   else fSelectedMaterial2 = mat;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting an existing medium.


void TGeoManagerEditor::DoSelectMedium()

{

   TGeoMedium *med = fSelectedMedium;

   new TGeoMediumDialog(fBSelMedium, gClient->GetRoot(), 200,300);

   fSelectedMedium = (TGeoMedium*)TGeoMediumDialog::GetSelected();

   if (fSelectedMedium) fLSelMedium->SetText(fSelectedMedium->GetName());

   else fSelectedMedium = med;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting an existing medium for making a volume.


void TGeoManagerEditor::DoSelectMedium2()

{

   TGeoMedium *med = fSelectedMedium2;

   new TGeoMediumDialog(fBSelMedium2, gClient->GetRoot(), 200,300);

   fSelectedMedium2 = (TGeoMedium*)TGeoMediumDialog::GetSelected();

   if (fSelectedMedium2) fLSelMedium2->SetText(fSelectedMedium2->GetName());

   else fSelectedMedium2 = med;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for selecting an existing volume.


void TGeoManagerEditor::DoSelectVolume()

{

   TGeoVolume *vol = fSelectedVolume;

   new TGeoVolumeDialog(fBSelVolume, gClient->GetRoot(), 200,300);

   fSelectedVolume = (TGeoVolume*)TGeoVolumeDialog::GetSelected();

   if (fSelectedVolume) fLSelVolume->SetText(fSelectedVolume->GetName());

   else fSelectedVolume = vol;

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for setting top geometry volume.


void TGeoManagerEditor::DoSelectTopVolume()

{

   TGeoVolume *vol = fGeometry->GetTopVolume();

   new TGeoVolumeDialog(fBSelTop, gClient->GetRoot(), 200,300);

   fSelectedVolume = (TGeoVolume*)TGeoVolumeDialog::GetSelected();

   if (fSelectedVolume) fLSelTop->SetText(fSelectedVolume->GetName());

   else fSelectedVolume = vol;

   if (fSelectedVolume && (fSelectedVolume != vol)) fGeometry->SetTopVolume(fSelectedVolume);

}


////////////////////////////////////////////////////////////////////////////////

/// Slot for closing the geometry.


void TGeoManagerEditor::DoCloseGeometry()

{

   if (!fGeometry->IsClosed()) fGeometry->CloseGeometry();

   fCloseGeometry->SetEnabled(kFALSE);

}


////////////////////////////////////////////////////////////////////////////////

/// Show/hide interface for shape selection.


void TGeoManagerEditor::ShowSelectShape(Bool_t show)

{

   TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Shapes")->GetContainer();

   if (show) cont->ShowFrame(f2);

   else      cont->HideFrame(f2);

}


////////////////////////////////////////////////////////////////////////////////

/// Show/hide interface for volume selection.


void TGeoManagerEditor::ShowSelectVolume(Bool_t show)

{

   TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("General")->GetContainer();

   if (show) cont->ShowFrame(f7);

   else      cont->HideFrame(f7);

   cont = (TGCompositeFrame*)fCategories->GetItem("Volumes")->GetContainer();

   if (show) cont->ShowFrame(f3);

   else      cont->HideFrame(f3);

}


////////////////////////////////////////////////////////////////////////////////

/// Show/hide interface for material selection.


void TGeoManagerEditor::ShowSelectMaterial(Bool_t show)

{

   TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Materials")->GetContainer();

   if (show) cont->ShowFrame(f4);

   else      cont->HideFrame(f4);

}


////////////////////////////////////////////////////////////////////////////////

/// Show/hide interface for medium selection.


void TGeoManagerEditor::ShowSelectMedium(Bool_t show)

{

   TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Media")->GetContainer();

   if (show) cont->ShowFrame(f5);

   else      cont->HideFrame(f5);

}


////////////////////////////////////////////////////////////////////////////////

/// Show/hide interface for matrix selection.


void TGeoManagerEditor::ShowSelectMatrix(Bool_t show)

{

   TGCompositeFrame *cont = (TGCompositeFrame*)fCategories->GetItem("Matrices")->GetContainer();

   if (show) cont->ShowFrame(f6);

   else      cont->HideFrame(f6);

}

kSunkenFrame
@ kSunkenFrame
Definition GuiTypes.h:383

kVerticalFrame
@ kVerticalFrame
Definition GuiTypes.h:381

kDoubleBorder
@ kDoubleBorder
Definition GuiTypes.h:385

kFixedWidth
@ kFixedWidth
Definition GuiTypes.h:387

kHorizontalFrame
@ kHorizontalFrame
Definition GuiTypes.h:382

kFixedHeight
@ kFixedHeight
Definition GuiTypes.h:389

kOwnBackground
@ kOwnBackground
Definition GuiTypes.h:391

Pixel_t
ULong_t Pixel_t
Pixel value.
Definition GuiTypes.h:40

kButton1
@ kButton1
Definition GuiTypes.h:214

c
#define c(i)
Definition RSha256.hxx:101

kFALSE
const Bool_t kFALSE
Definition RtypesCore.h:101

Double_t
double Double_t
Definition RtypesCore.h:59

kTRUE
const Bool_t kTRUE
Definition RtypesCore.h:100

ClassImp
#define ClassImp(name)
Definition Rtypes.h:364

TCanvas.h

width
include TDocParser_001 C image html pict1_TDocParser_001 png width
Definition TDocParser.cxx:121

Error
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition TError.cxx:187

TG3DLine.h

TGButtonGroup.h

TGButton.h

gClient
#define gClient
Definition TGClient.h:157

TGComboBox.h

TGLabel.h

kLHintsRight
@ kLHintsRight
Definition TGLayout.h:26

kLHintsExpandY
@ kLHintsExpandY
Definition TGLayout.h:31

kLHintsLeft
@ kLHintsLeft
Definition TGLayout.h:24

kLHintsTop
@ kLHintsTop
Definition TGLayout.h:27

kLHintsExpandX
@ kLHintsExpandX
Definition TGLayout.h:30

TGNumberEntry.h

TGShutter.h

TGTab.h

TGTextEntry.h

name
char name[80]
Definition TGX11.cxx:110

TGedEditor.h

TGeoArb8.h

TGeoBBox.h

TGeoCone.h

TGeoElement.h

TGeoEltu.h

TGeoHype.h

ETGeoVolumeWid
ETGeoVolumeWid
Definition TGeoManagerEditor.cxx:88

kCREATE_HYPE
@ kCREATE_HYPE
Definition TGeoManagerEditor.cxx:100

kMANAGER_MATERIAL_SELECT
@ kMANAGER_MATERIAL_SELECT
Definition TGeoManagerEditor.cxx:90

kCAT_VOLUMES
@ kCAT_VOLUMES
Definition TGeoManagerEditor.cxx:95

kMANAGER_MEDIUM_SELECT
@ kMANAGER_MEDIUM_SELECT
Definition TGeoManagerEditor.cxx:93

kMANAGER_TITLE
@ kMANAGER_TITLE
Definition TGeoManagerEditor.cxx:89

kMANAGER_VOLUME_SELECT
@ kMANAGER_VOLUME_SELECT
Definition TGeoManagerEditor.cxx:91

kCREATE_XTRU
@ kCREATE_XTRU
Definition TGeoManagerEditor.cxx:97

kCREATE_CONS
@ kCREATE_CONS
Definition TGeoManagerEditor.cxx:98

kCREATE_TRD1
@ kCREATE_TRD1
Definition TGeoManagerEditor.cxx:96

kMATRIX_NAME
@ kMATRIX_NAME
Definition TGeoManagerEditor.cxx:103

kMANAGER_MATERIAL_SELECT2
@ kMANAGER_MATERIAL_SELECT2
Definition TGeoManagerEditor.cxx:93

kCREATE_ROTATION
@ kCREATE_ROTATION
Definition TGeoManagerEditor.cxx:102

kMANAGER_ELEMENT_SELECT
@ kMANAGER_ELEMENT_SELECT
Definition TGeoManagerEditor.cxx:90

kCREATE_TUBS
@ kCREATE_TUBS
Definition TGeoManagerEditor.cxx:98

kEXPORT_ROOT
@ kEXPORT_ROOT
Definition TGeoManagerEditor.cxx:94

kCREATE_TUBE
@ kCREATE_TUBE
Definition TGeoManagerEditor.cxx:98

kCREATE_TRANSLATION
@ kCREATE_TRANSLATION
Definition TGeoManagerEditor.cxx:102

kCAT_SHAPES
@ kCAT_SHAPES
Definition TGeoManagerEditor.cxx:95

kCREATE_CONE
@ kCREATE_CONE
Definition TGeoManagerEditor.cxx:98

kCREATE_SPHE
@ kCREATE_SPHE
Definition TGeoManagerEditor.cxx:99

kMANAGER_SHAPE_SELECT2
@ kMANAGER_SHAPE_SELECT2
Definition TGeoManagerEditor.cxx:91

kMANAGER_CANCEL
@ kMANAGER_CANCEL
Definition TGeoManagerEditor.cxx:104

kCAT_MATERIALS
@ kCAT_MATERIALS
Definition TGeoManagerEditor.cxx:95

kCREATE_GTRA
@ kCREATE_GTRA
Definition TGeoManagerEditor.cxx:97

kCREATE_COMP
@ kCREATE_COMP
Definition TGeoManagerEditor.cxx:100

kMEDIUM_ID
@ kMEDIUM_ID
Definition TGeoManagerEditor.cxx:103

kMATERIAL_NAME
@ kMATERIAL_NAME
Definition TGeoManagerEditor.cxx:103

kMANAGER_APPLY
@ kMANAGER_APPLY
Definition TGeoManagerEditor.cxx:104

kMANAGER_MATRIX_SELECT
@ kMANAGER_MATRIX_SELECT
Definition TGeoManagerEditor.cxx:93

kMANAGER_MEDIUM_SELECT2
@ kMANAGER_MEDIUM_SELECT2
Definition TGeoManagerEditor.cxx:91

kVOLUME_NAME
@ kVOLUME_NAME
Definition TGeoManagerEditor.cxx:103

kCREATE_CTUB
@ kCREATE_CTUB
Definition TGeoManagerEditor.cxx:99

kMANAGER_NELEM_SELECT
@ kMANAGER_NELEM_SELECT
Definition TGeoManagerEditor.cxx:92

kCREATE_TRAP
@ kCREATE_TRAP
Definition TGeoManagerEditor.cxx:97

kCREATE_VOLUME
@ kCREATE_VOLUME
Definition TGeoManagerEditor.cxx:101

kCREATE_ELTU
@ kCREATE_ELTU
Definition TGeoManagerEditor.cxx:99

kCREATE_PGON
@ kCREATE_PGON
Definition TGeoManagerEditor.cxx:100

kCREATE_TORUS
@ kCREATE_TORUS
Definition TGeoManagerEditor.cxx:99

kMANAGER_NAME
@ kMANAGER_NAME
Definition TGeoManagerEditor.cxx:89

kCREATE_ASSEMBLY
@ kCREATE_ASSEMBLY
Definition TGeoManagerEditor.cxx:101

kMANAGER_DENSITY_SELECT
@ kMANAGER_DENSITY_SELECT
Definition TGeoManagerEditor.cxx:92

kCREATE_MEDIUM
@ kCREATE_MEDIUM
Definition TGeoManagerEditor.cxx:101

kCREATE_PCON
@ kCREATE_PCON
Definition TGeoManagerEditor.cxx:100

kMANAGER_MEDIA_SELECT
@ kMANAGER_MEDIA_SELECT
Definition TGeoManagerEditor.cxx:90

kCREATE_ARB8
@ kCREATE_ARB8
Definition TGeoManagerEditor.cxx:97

kMEDIUM_NAME
@ kMEDIUM_NAME
Definition TGeoManagerEditor.cxx:103

kCREATE_COMBI
@ kCREATE_COMBI
Definition TGeoManagerEditor.cxx:102

kEXPORT_GEOMETRY
@ kEXPORT_GEOMETRY
Definition TGeoManagerEditor.cxx:94

kCREATE_PARAB
@ kCREATE_PARAB
Definition TGeoManagerEditor.cxx:100

kMANAGER_EDIT_MEDIUM
@ kMANAGER_EDIT_MEDIUM
Definition TGeoManagerEditor.cxx:92

kEXPORT_C
@ kEXPORT_C
Definition TGeoManagerEditor.cxx:94

kCAT_MATRICES
@ kCAT_MATRICES
Definition TGeoManagerEditor.cxx:95

kMANAGER_TOP_SELECT
@ kMANAGER_TOP_SELECT
Definition TGeoManagerEditor.cxx:93

kCREATE_BOX
@ kCREATE_BOX
Definition TGeoManagerEditor.cxx:96

kMANAGER_EDIT_SHAPE
@ kMANAGER_EDIT_SHAPE
Definition TGeoManagerEditor.cxx:92

kMANAGER_SHAPE_SELECT
@ kMANAGER_SHAPE_SELECT
Definition TGeoManagerEditor.cxx:90

kCREATE_MATERIAL
@ kCREATE_MATERIAL
Definition TGeoManagerEditor.cxx:101

kCREATE_PARA
@ kCREATE_PARA
Definition TGeoManagerEditor.cxx:96

kCAT_GENERAL
@ kCAT_GENERAL
Definition TGeoManagerEditor.cxx:95

kMANAGER_UNDO
@ kMANAGER_UNDO
Definition TGeoManagerEditor.cxx:104

kCAT_MEDIA
@ kCAT_MEDIA
Definition TGeoManagerEditor.cxx:95

kCREATE_TRD2
@ kCREATE_TRD2
Definition TGeoManagerEditor.cxx:96

kCREATE_MIXTURE
@ kCREATE_MIXTURE
Definition TGeoManagerEditor.cxx:101

TGeoManagerEditor.h

TGeoManager.h

gGeoManager
R__EXTERN TGeoManager * gGeoManager
Definition TGeoManager.h:602

TGeoMaterial.h

TGeoMatrix.h

TGeoNodeEditor.h

TGeoPara.h

TGeoPcon.h

TGeoPgon.h

TGeoSphere.h

TGeoTabManager.h

TGeoTorus.h

TGeoTrd1.h

TGeoTrd2.h

TGeoTube.h

TGeoVolumeEditor.h

TGeoVolume.h

TView.h

TVirtualPad.h

TCanvas
The Canvas class.
Definition TCanvas.h:23

TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition TCollection.h:184

TGButtonGroup
Organizes TGButton widgets in a group.
Definition TGButtonGroup.h:21

TGButtonGroup::SetRadioButtonExclusive
virtual void SetRadioButtonExclusive(Bool_t flag=kTRUE)
If enable is kTRUE, this button group will treat radio buttons as mutually exclusive,...
Definition TGButtonGroup.cxx:313

TGButtonGroup::Show
virtual void Show()
Show group of buttons.
Definition TGButtonGroup.cxx:549

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:344

TGButton::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=400)
Set tool tip text associated with this button.
Definition TGButton.cxx:445

TGButton::SetEnabled
virtual void SetEnabled(Bool_t e=kTRUE)
Set enabled or disabled state of button.
Definition TGButton.cxx:459

TGClient::GetPicture
const TGPicture * GetPicture(const char *name)
Get picture from the picture pool.
Definition TGClient.cxx:289

TGComboBox
A combobox (also known as a drop down listbox) allows the selection of one item out of a list of item...
Definition TGComboBox.h:47

TGComboBox::GetSelected
virtual Int_t GetSelected() const
Definition TGComboBox.h:114

TGComboBox::AddEntry
virtual void AddEntry(TGString *s, Int_t id)
Definition TGComboBox.h:86

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:456

TGCompositeFrame
The base class for composite widgets (menu bars, list boxes, etc.).
Definition TGFrame.h:287

TGCompositeFrame::AddFrame
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=0)
Add frame to the composite frame using the specified layout hints.
Definition TGFrame.cxx:1117

TGCompositeFrame::Cleanup
virtual void Cleanup()
Cleanup and delete all objects contained in this composite frame.
Definition TGFrame.cxx:967

TGCompositeFrame::SetCleanup
virtual void SetCleanup(Int_t mode=kLocalCleanup)
Turn on automatic cleanup of child frames in dtor.
Definition TGFrame.cxx:1072

TGCompositeFrame::ShowFrame
virtual void ShowFrame(TGFrame *f)
Show sub frame.
Definition TGFrame.cxx:1204

TGCompositeFrame::HideFrame
virtual void HideFrame(TGFrame *f)
Hide sub frame.
Definition TGFrame.cxx:1190

TGFrame::ChangeOptions
virtual void ChangeOptions(UInt_t options)
Change frame options. Options is an OR of the EFrameTypes.
Definition TGFrame.cxx:321

TGFrame::GetDefaultHeight
virtual UInt_t GetDefaultHeight() const
Definition TGFrame.h:191

TGFrame::SetBackgroundColor
virtual void SetBackgroundColor(Pixel_t back)
Set background color (override from TGWindow base class).
Definition TGFrame.cxx:312

TGFrame::GetDefaultFrameBackground
static Pixel_t GetDefaultFrameBackground()
Get default frame background.
Definition TGFrame.cxx:683

TGFrame::Resize
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition TGFrame.cxx:605

TGHorizontal3DLine
A horizontal 3D line is a line that typically separates a toolbar from the menubar.
Definition TG3DLine.h:18

TGHotString
TGHotString is a string with a "hot" character underlined.
Definition TGString.h:42

TGLabel
This class handles GUI labels.
Definition TGLabel.h:24

TGLabel::SetTextColor
virtual void SetTextColor(Pixel_t color, Bool_t global=kFALSE)
Changes text color.
Definition TGLabel.cxx:362

TGLabel::SetText
virtual void SetText(TGString *newText)
Set new text in label.
Definition TGLabel.cxx:180

TGLayoutHints
This class describes layout hints used by the layout classes.
Definition TGLayout.h:50

TGNumberEntry
TGNumberEntry is a number entry input widget with up/down buttons.
Definition TGNumberEntry.h:148

TGNumberEntry::GetDefaultHeight
UInt_t GetDefaultHeight() const
Definition TGNumberEntry.h:272

TGNumberEntry::GetNumberEntry
TGNumberEntryField * GetNumberEntry() const
Definition TGNumberEntry.h:260

TGNumberEntry::Associate
virtual void Associate(const TGWindow *w)
Make w the window that will receive the generated messages.
Definition TGNumberEntry.cxx:2006

TGNumberEntry::GetIntNumber
virtual Long_t GetIntNumber() const
Definition TGNumberEntry.h:200

TGNumberEntry::SetNumAttr
void SetNumAttr(EAttribute attr=kNEAAnyNumber)
Definition TGNumberEntry.h:246

TGNumberEntry::GetNumber
virtual Double_t GetNumber() const
Definition TGNumberEntry.h:197

TGNumberEntry::SetNumber
virtual void SetNumber(Double_t val, Bool_t emit=kTRUE)
Definition TGNumberEntry.h:177

TGNumberEntry::SetNumStyle
void SetNumStyle(EStyle style)
Definition TGNumberEntry.h:244

TGNumberFormat::kNEAPositive
@ kNEAPositive
Positive number.
Definition TGNumberEntry.h:43

TGNumberFormat::kNEANonNegative
@ kNEANonNegative
Non-negative number.
Definition TGNumberEntry.h:42

TGNumberFormat::kNESRealThree
@ kNESRealThree
Fixed fraction real, three digit.
Definition TGNumberEntry.h:28

TGNumberFormat::kNESInteger
@ kNESInteger
Style of number entry field.
Definition TGNumberEntry.h:25

TGObject::fClient
TGClient * fClient
Connection to display server.
Definition TGObject.h:27

TGPictureButton
Yield an action as soon as it is clicked.
Definition TGButton.h:228

TGRadioButton
Selects different options.
Definition TGButton.h:322

TGRadioButton::IsDown
virtual Bool_t IsDown() const
Definition TGButton.h:371

TGShutterItem
Definition TGShutter.h:28

TGShutterItem::GetButton
TGButton * GetButton() const
Definition TGShutter.h:47

TGShutterItem::GetContainer
TGFrame * GetContainer() const
Definition TGShutter.h:48

TGShutter
A shutter widget contains a set of shutter items that can be open and closed like a shutter.
Definition TGShutter.h:58

TGShutter::AddItem
virtual void AddItem(TGShutterItem *item)
Add shutter item to shutter frame.
Definition TGShutter.cxx:73

TGShutter::GetItem
TGShutterItem * GetItem(const char *name)
returns a shutter item by name (name is hot string of shutter item)
Definition TGShutter.cxx:302

TGShutter::Layout
virtual void Layout()
Layout shutter items.
Definition TGShutter.cxx:218

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:558

TGTextBuffer
A text buffer is used in several widgets, like TGTextEntry, TGFileDialog, etc.
Definition TGTextBuffer.h:19

TGTextButton
Yield an action as soon as it is clicked.
Definition TGButton.h:142

TGTextEntry
A TGTextEntry is a one line text input widget.
Definition TGTextEntry.h:24

TGTextEntry::GetText
const char * GetText() const
Definition TGTextEntry.h:119

TGTextEntry::SetToolTipText
virtual void SetToolTipText(const char *text, Long_t delayms=500)
Set tool tip text associated with this text entry.
Definition TGTextEntry.cxx:1649

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:611

TGVButtonGroup
Organizes TGButton widgets in a group with one vertical column.
Definition TGButtonGroup.h:94

TGWidget::Associate
virtual void Associate(const TGWindow *w)
Definition TGWidget.h:72

TGWindow
ROOT GUI Window base class.
Definition TGWindow.h:23

TGedEditor::GetTab
TGTab * GetTab() const
Definition TGedEditor.h:73

TGedEditor::GetCanvas
virtual TCanvas * GetCanvas() const
Definition TGedEditor.h:77

TGedEditor::DisconnectFromCanvas
virtual void DisconnectFromCanvas()
Disconnect this editor from the Selected signal of fCanvas.
Definition TGedEditor.cxx:318

TGedFrame
Base frame for implementing GUI - a service class.
Definition TGedFrame.h:27

TGedFrame::fGedEditor
TGedEditor * fGedEditor
manager of this frame
Definition TGedFrame.h:48

TGedFrame::CreateEditorTabSubFrame
virtual TGVerticalFrame * CreateEditorTabSubFrame(const char *name)
Create a vertical frame to be used by 'owner' in extra tab 'name'.
Definition TGedFrame.cxx:122

TGedFrame::fInit
Bool_t fInit
init flag for setting signals/slots
Definition TGedFrame.h:47

TGeoBBox
Box class.
Definition TGeoBBox.h:18

TGeoCombiTrans
Class describing rotation + translation.
Definition TGeoMatrix.h:292

TGeoConeSeg
A cone segment is a cone having a range in phi.
Definition TGeoCone.h:102

TGeoCone
The cones are defined by 5 parameters:
Definition TGeoCone.h:18

TGeoCtub
The cut tubes constructor has the form:
Definition TGeoTube.h:172

TGeoElementTable
Table of elements.
Definition TGeoElement.h:370

TGeoElementTable::GetElement
TGeoElement * GetElement(Int_t z)
Definition TGeoElement.h:410

TGeoElementTable::GetNelements
Int_t GetNelements() const
Definition TGeoElement.h:417

TGeoElement
Base class for chemical elements.
Definition TGeoElement.h:37

TGeoEltu
An elliptical tube is defined by the two semi-axes A and B.
Definition TGeoEltu.h:18

TGeoGtra
A twisted trapezoid.
Definition TGeoArb8.h:146

TGeoHype
A hyperboloid is represented as a solid limited by two planes perpendicular to the Z axis (top and bo...
Definition TGeoHype.h:18

TGeoManagerEditor
Editor for TGeoManager class.
Definition TGeoManagerEditor.h:36

TGeoManagerEditor::DoCreateCons
void DoCreateCons()
Create a cone segment.
Definition TGeoManagerEditor.cxx:954

TGeoManagerEditor::DoCreateArb8
void DoCreateArb8()
Create an arbitrary polygone with maximum 8 vertices sitting on 2 parallel planes.
Definition TGeoManagerEditor.cxx:908

TGeoManagerEditor::DoCreatePgon
void DoCreatePgon()
Create a polygone shape.
Definition TGeoManagerEditor.cxx:1035

TGeoManagerEditor::DoSelectMedium
void DoSelectMedium()
Slot for selecting an existing medium.
Definition TGeoManagerEditor.cxx:1319

TGeoManagerEditor::fSelectedMaterial
TGeoMaterial * fSelectedMaterial
Definition TGeoManagerEditor.h:52

TGeoManagerEditor::DoCreateAssembly
void DoCreateAssembly()
Create a new volume assembly.
Definition TGeoManagerEditor.cxx:1168

TGeoManagerEditor::fMediumId
TGNumberEntry * fMediumId
Definition TGeoManagerEditor.h:85

TGeoManagerEditor::fBSelMedium2
TGPictureButton * fBSelMedium2
Definition TGeoManagerEditor.h:75

TGeoManagerEditor::DoCreateHype
void DoCreateHype()
Create a hyperboloid.
Definition TGeoManagerEditor.cxx:1050

TGeoManagerEditor::ConnectSelected
void ConnectSelected(TCanvas *c)
Definition TGeoManagerEditor.cxx:666

TGeoManagerEditor::fLSelMedium2
TGLabel * fLSelMedium2
Definition TGeoManagerEditor.h:73

TGeoManagerEditor::DoSelectMaterial
void DoSelectMaterial()
Slot for selecting an existing material.
Definition TGeoManagerEditor.cxx:1295

TGeoManagerEditor::fTabMgr
TGeoTabManager * fTabMgr
Definition TGeoManagerEditor.h:41

TGeoManagerEditor::fVolumeTab
TGCompositeFrame * fVolumeTab
Definition TGeoManagerEditor.h:43

TGeoManagerEditor::fVolumeButton
TGPictureButton * fVolumeButton[2]
Definition TGeoManagerEditor.h:78

TGeoManagerEditor::DoSelectShape
void DoSelectShape()
Slot for selecting an existing shape.
Definition TGeoManagerEditor.cxx:1271

TGeoManagerEditor::fLSelShape
TGLabel * fLSelShape
Definition TGeoManagerEditor.h:63

TGeoManagerEditor::DoEditVolume
void DoEditVolume()
Slot for editing selected volume.
Definition TGeoManagerEditor.cxx:1217

TGeoManagerEditor::f5
TGCompositeFrame * f5
Definition TGeoManagerEditor.h:98

TGeoManagerEditor::DoSelectShape2
void DoSelectShape2()
Slot for selecting a shape for making a volume.
Definition TGeoManagerEditor.cxx:1283

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:110

TGeoManagerEditor::fBSelMatrix
TGPictureButton * fBSelMatrix
Definition TGeoManagerEditor.h:69

TGeoManagerEditor::fMatrixButton
TGPictureButton * fMatrixButton[3]
Definition TGeoManagerEditor.h:77

TGeoManagerEditor::fMediumButton
TGPictureButton * fMediumButton
Definition TGeoManagerEditor.h:84

TGeoManagerEditor::DoEditMedium
void DoEditMedium()
Slot for editing selected medium.
Definition TGeoManagerEditor.cxx:1232

TGeoManagerEditor::fEditMedium
TGTextButton * fEditMedium
Definition TGeoManagerEditor.h:87

TGeoManagerEditor::DoCreatePara
void DoCreatePara()
Create a parallelipiped.
Definition TGeoManagerEditor.cxx:835

TGeoManagerEditor::DoSelectTopVolume
void DoSelectTopVolume()
Slot for setting top geometry volume.
Definition TGeoManagerEditor.cxx:1355

TGeoManagerEditor::DoCreateTubs
void DoCreateTubs()
Create a tube segment.
Definition TGeoManagerEditor.cxx:928

TGeoManagerEditor::fMediumName
TGTextEntry * fMediumName
Definition TGeoManagerEditor.h:48

TGeoManagerEditor::DoCreateTrd1
void DoCreateTrd1()
Create a Trd1.
Definition TGeoManagerEditor.cxx:848

TGeoManagerEditor::fEditVolume
TGTextButton * fEditVolume
Definition TGeoManagerEditor.h:90

TGeoManagerEditor::fSelectedMedium2
TGeoMedium * fSelectedMedium2
Definition TGeoManagerEditor.h:71

TGeoManagerEditor::DisconnectSelected
void DisconnectSelected()
Definition TGeoManagerEditor.cxx:674

TGeoManagerEditor::DoCreateGtra
void DoCreateGtra()
Create a twisted trapezoid.
Definition TGeoManagerEditor.cxx:887

TGeoManagerEditor::fEditMaterial
TGTextButton * fEditMaterial
Definition TGeoManagerEditor.h:88

TGeoManagerEditor::fLSelShape2
TGLabel * fLSelShape2
Definition TGeoManagerEditor.h:64

TGeoManagerEditor::DoEditMatrix
void DoEditMatrix()
Slot for editing selected matrix.
Definition TGeoManagerEditor.cxx:1250

TGeoManagerEditor::DoCloseGeometry
void DoCloseGeometry()
Slot for closing the geometry.
Definition TGeoManagerEditor.cxx:1368

TGeoManagerEditor::fBSelShape2
TGPictureButton * fBSelShape2
Definition TGeoManagerEditor.h:66

TGeoManagerEditor::DoCreateParab
void DoCreateParab()
Create a paraboloid.
Definition TGeoManagerEditor.cxx:1063

TGeoManagerEditor::f2
TGCompositeFrame * f2
Definition TGeoManagerEditor.h:95

TGeoManagerEditor::DoSelectMedium2
void DoSelectMedium2()
Slot for selecting an existing medium for making a volume.
Definition TGeoManagerEditor.cxx:1331

TGeoManagerEditor::DoCreateBox
void DoCreateBox()
Create a box.
Definition TGeoManagerEditor.cxx:821

TGeoManagerEditor::fElementList
TGComboBox * fElementList
Definition TGeoManagerEditor.h:82

TGeoManagerEditor::DoSetTopVolume
void DoSetTopVolume()
Set top volume for the geometry.
Definition TGeoManagerEditor.cxx:1196

TGeoManagerEditor::fEditShape
TGTextButton * fEditShape
Definition TGeoManagerEditor.h:86

TGeoManagerEditor::fManagerName
TGTextEntry * fManagerName
Definition TGeoManagerEditor.h:46

TGeoManagerEditor::fIsModified
Bool_t fIsModified
Definition TGeoManagerEditor.h:44

TGeoManagerEditor::DoSelectVolume
void DoSelectVolume()
Slot for selecting an existing volume.
Definition TGeoManagerEditor.cxx:1343

TGeoManagerEditor::DoName
void DoName()
Change name/title of the geometry.
Definition TGeoManagerEditor.cxx:797

TGeoManagerEditor::DoEditMaterial
void DoEditMaterial()
Slot for editing selected material.
Definition TGeoManagerEditor.cxx:1241

TGeoManagerEditor::ConnectSignals2Slots
virtual void ConnectSignals2Slots()
Connect signals to slots.
Definition TGeoManagerEditor.cxx:687

TGeoManagerEditor::f3
TGCompositeFrame * f3
Definition TGeoManagerEditor.h:96

TGeoManagerEditor::DoCreateTranslation
void DoCreateTranslation()
Create a new translation.
Definition TGeoManagerEditor.cxx:1126

TGeoManagerEditor::DoCreateMixture
void DoCreateMixture()
Create a new mixture.
Definition TGeoManagerEditor.cxx:1096

TGeoManagerEditor::fBSelMaterial
TGPictureButton * fBSelMaterial
Definition TGeoManagerEditor.h:56

TGeoManagerEditor::fSelectedMaterial2
TGeoMaterial * fSelectedMaterial2
Definition TGeoManagerEditor.h:53

TGeoManagerEditor::fVolumeName
TGTextEntry * fVolumeName
Definition TGeoManagerEditor.h:51

TGeoManagerEditor::fBSelVolume
TGPictureButton * fBSelVolume
Definition TGeoManagerEditor.h:60

TGeoManagerEditor::ShowSelectMaterial
void ShowSelectMaterial(Bool_t show=kTRUE)
Show/hide interface for material selection.
Definition TGeoManagerEditor.cxx:1400

TGeoManagerEditor::DoCreateTrd2
void DoCreateTrd2()
Create a Trd2.
Definition TGeoManagerEditor.cxx:861

TGeoManagerEditor::fSelectedMatrix
TGeoMatrix * fSelectedMatrix
Definition TGeoManagerEditor.h:67

TGeoManagerEditor::DoCreateVolume
void DoCreateVolume()
Create a new volume.
Definition TGeoManagerEditor.cxx:1154

TGeoManagerEditor::DoCreateCone
void DoCreateCone()
Create a cone.
Definition TGeoManagerEditor.cxx:941

TGeoManagerEditor::DoCreateXtru
void DoCreateXtru()
Create an extruded polygone.
Definition TGeoManagerEditor.cxx:900

TGeoManagerEditor::fSetTopVolume
TGTextButton * fSetTopVolume
Definition TGeoManagerEditor.h:91

TGeoManagerEditor::f4
TGCompositeFrame * f4
Definition TGeoManagerEditor.h:97

TGeoManagerEditor::fLSelMaterial
TGLabel * fLSelMaterial
Definition TGeoManagerEditor.h:54

TGeoManagerEditor::fLSelTop
TGLabel * fLSelTop
Definition TGeoManagerEditor.h:92

TGeoManagerEditor::fSelectedShape
TGeoShape * fSelectedShape
Definition TGeoManagerEditor.h:61

TGeoManagerEditor::fSelectedVolume
TGeoVolume * fSelectedVolume
Definition TGeoManagerEditor.h:58

TGeoManagerEditor::DoExportGeometry
void DoExportGeometry()
Export geometry as .root or .C file.
Definition TGeoManagerEditor.cxx:806

TGeoManagerEditor::fMatrixName
TGTextEntry * fMatrixName
Definition TGeoManagerEditor.h:49

TGeoManagerEditor::DoCreateTube
void DoCreateTube()
Create a tube.
Definition TGeoManagerEditor.cxx:915

TGeoManagerEditor::fBSelMaterial2
TGPictureButton * fBSelMaterial2
Definition TGeoManagerEditor.h:57

TGeoManagerEditor::fEditMatrix
TGTextButton * fEditMatrix
Definition TGeoManagerEditor.h:89

TGeoManagerEditor::fExportButton
TGTextButton * fExportButton
Definition TGeoManagerEditor.h:81

TGeoManagerEditor::fSelectedMedium
TGeoMedium * fSelectedMedium
Definition TGeoManagerEditor.h:70

TGeoManagerEditor::fMaterialName
TGTextEntry * fMaterialName
Definition TGeoManagerEditor.h:50

TGeoManagerEditor::f6
TGCompositeFrame * f6
Definition TGeoManagerEditor.h:99

TGeoManagerEditor::DoCreatePcon
void DoCreatePcon()
Create a polycone shape.
Definition TGeoManagerEditor.cxx:1020

TGeoManagerEditor::fManagerTitle
TGTextEntry * fManagerTitle
Definition TGeoManagerEditor.h:47

TGeoManagerEditor::f7
TGCompositeFrame * f7
Definition TGeoManagerEditor.h:100

TGeoManagerEditor::DoCreateTorus
void DoCreateTorus()
Create a torus shape.
Definition TGeoManagerEditor.cxx:1006

TGeoManagerEditor::DoCreateTrap
void DoCreateTrap()
Create a general trapezoid.
Definition TGeoManagerEditor.cxx:874

TGeoManagerEditor::fCloseGeometry
TGTextButton * fCloseGeometry
Definition TGeoManagerEditor.h:94

TGeoManagerEditor::DoCreateSphe
void DoCreateSphe()
Create a sphere.
Definition TGeoManagerEditor.cxx:967

TGeoManagerEditor::fBSelShape
TGPictureButton * fBSelShape
Definition TGeoManagerEditor.h:65

TGeoManagerEditor::fExportOption
TGRadioButton * fExportOption[2]
Definition TGeoManagerEditor.h:80

TGeoManagerEditor::DoSelectMaterial2
void DoSelectMaterial2()
Slot for selecting an existing material and making a medium.
Definition TGeoManagerEditor.cxx:1307

TGeoManagerEditor::DoCreateMaterial
void DoCreateMaterial()
Create a new material.
Definition TGeoManagerEditor.cxx:1077

TGeoManagerEditor::fBSelTop
TGPictureButton * fBSelTop
Definition TGeoManagerEditor.h:93

TGeoManagerEditor::fLSelMaterial2
TGLabel * fLSelMaterial2
Definition TGeoManagerEditor.h:55

TGeoManagerEditor::fGeometry
TGeoManager * fGeometry
Definition TGeoManagerEditor.h:40

TGeoManagerEditor::fLSelMatrix
TGLabel * fLSelMatrix
Definition TGeoManagerEditor.h:68

TGeoManagerEditor::ShowSelectMedium
void ShowSelectMedium(Bool_t show=kTRUE)
Show/hide interface for medium selection.
Definition TGeoManagerEditor.cxx:1410

TGeoManagerEditor::fCategories
TGShutter * fCategories
Definition TGeoManagerEditor.h:45

TGeoManagerEditor::SelectedSlot
virtual void SelectedSlot(TVirtualPad *pad, TObject *obj, Int_t event)
Connected to TCanvas::Selected.
Definition TGeoManagerEditor.cxx:655

TGeoManagerEditor::fSelectedShape2
TGeoShape * fSelectedShape2
Definition TGeoManagerEditor.h:62

TGeoManagerEditor::ShowSelectVolume
void ShowSelectVolume(Bool_t show=kTRUE)
Show/hide interface for volume selection.
Definition TGeoManagerEditor.cxx:1387

TGeoManagerEditor::fTab
TGTab * fTab
Definition TGeoManagerEditor.h:42

TGeoManagerEditor::DoCreateMedium
void DoCreateMedium()
Create a new medium.
Definition TGeoManagerEditor.cxx:1110

TGeoManagerEditor::fConnectedCanvas
TCanvas * fConnectedCanvas
Definition TGeoManagerEditor.h:101

TGeoManagerEditor::ShowSelectShape
void ShowSelectShape(Bool_t show=kTRUE)
Show/hide interface for shape selection.
Definition TGeoManagerEditor.cxx:1377

TGeoManagerEditor::ShowSelectMatrix
void ShowSelectMatrix(Bool_t show=kTRUE)
Show/hide interface for matrix selection.
Definition TGeoManagerEditor.cxx:1420

TGeoManagerEditor::fLSelMedium
TGLabel * fLSelMedium
Definition TGeoManagerEditor.h:72

TGeoManagerEditor::DoSelectMatrix
void DoSelectMatrix()
Slot for selecting an existing matrix.
Definition TGeoManagerEditor.cxx:1259

TGeoManagerEditor::fMaterialButton
TGPictureButton * fMaterialButton[2]
Definition TGeoManagerEditor.h:79

TGeoManagerEditor::fEntryDensity
TGNumberEntry * fEntryDensity
Definition TGeoManagerEditor.h:83

TGeoManagerEditor::DoEditShape
void DoEditShape()
Slot for editing selected shape.
Definition TGeoManagerEditor.cxx:1206

TGeoManagerEditor::~TGeoManagerEditor
virtual ~TGeoManagerEditor()
Destructor.
Definition TGeoManagerEditor.cxx:619

TGeoManagerEditor::fLSelVolume
TGLabel * fLSelVolume
Definition TGeoManagerEditor.h:59

TGeoManagerEditor::SetModel
virtual void SetModel(TObject *obj)
Refresh editor according the selected obj.
Definition TGeoManagerEditor.cxx:743

TGeoManagerEditor::DoCreateEltu
void DoCreateEltu()
Create an elliptical tube.
Definition TGeoManagerEditor.cxx:993

TGeoManagerEditor::DoCreateCombi
void DoCreateCombi()
Create a new translation + rotation.
Definition TGeoManagerEditor.cxx:1181

TGeoManagerEditor::DoCreateComposite
void DoCreateComposite()
Create a composite shape.
Definition TGeoManagerEditor.cxx:1070

TGeoManagerEditor::DoCreateRotation
void DoCreateRotation()
Create a new rotation.
Definition TGeoManagerEditor.cxx:1140

TGeoManagerEditor::fBSelMedium
TGPictureButton * fBSelMedium
Definition TGeoManagerEditor.h:74

TGeoManagerEditor::fShapeButton
TGPictureButton * fShapeButton[21]
Definition TGeoManagerEditor.h:76

TGeoManagerEditor::DoCreateCtub
void DoCreateCtub()
Create a cut tube.
Definition TGeoManagerEditor.cxx:980

TGeoManager
The manager class for any TGeo geometry.
Definition TGeoManager.h:45

TGeoManager::GetListOfMedia
TList * GetListOfMedia() const
Definition TGeoManager.h:492

TGeoManager::GetElementTable
TGeoElementTable * GetElementTable()
Returns material table. Creates it if not existing.
Definition TGeoManager.cxx:3378

TGeoManager::GetListOfVolumes
TObjArray * GetListOfVolumes() const
Definition TGeoManager.h:493

TGeoManager::GetListOfMatrices
TObjArray * GetListOfMatrices() const
Definition TGeoManager.h:490

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:3713

TGeoManager::GetMasterVolume
TGeoVolume * GetMasterVolume() const
Definition TGeoManager.h:531

TGeoManager::IsClosed
Bool_t IsClosed() const
Definition TGeoManager.h:305

TGeoManager::CloseGeometry
void CloseGeometry(Option_t *option="d")
Closing geometry implies checking the geometry validity, fixing shapes with negative parameters (run-...
Definition TGeoManager.cxx:1360

TGeoManager::SetTopVolume
void SetTopVolume(TGeoVolume *vol)
Set the top volume and corresponding node as starting point of the geometry.
Definition TGeoManager.cxx:3409

TGeoManager::BuildDefaultMaterials
void BuildDefaultMaterials()
Now just a shortcut for GetElementTable.
Definition TGeoManager.cxx:3369

TGeoManager::GetListOfMaterials
TList * GetListOfMaterials() const
Definition TGeoManager.h:491

TGeoManager::GetListOfShapes
TObjArray * GetListOfShapes() const
Definition TGeoManager.h:495

TGeoManager::GetTopVolume
TGeoVolume * GetTopVolume() const
Definition TGeoManager.h:532

TGeoMaterialDialog
Definition TGeoTabManager.h:200

TGeoMaterial
Base class describing materials.
Definition TGeoMaterial.h:36

TGeoMatrixDialog
Definition TGeoTabManager.h:225

TGeoMatrix
Geometrical transformation package.
Definition TGeoMatrix.h:41

TGeoMatrix::kGeoTranslation
@ kGeoTranslation
Definition TGeoMatrix.h:46

TGeoMatrix::kGeoRotation
@ kGeoRotation
Definition TGeoMatrix.h:47

TGeoMatrix::RegisterYourself
virtual void RegisterYourself()
Register the matrix in the current manager, which will become the owner.
Definition TGeoMatrix.cxx:526

TGeoMediumDialog
Definition TGeoTabManager.h:175

TGeoMedium
Media are used to store properties related to tracking and which are useful only when using geometry ...
Definition TGeoMedium.h:24

TGeoMixture
Mixtures of elements.
Definition TGeoMaterial.h:157

TGeoPara
Parallelepiped class.
Definition TGeoPara.h:18

TGeoPcon
A polycone is represented by a sequence of tubes/cones, glued together at defined Z planes.
Definition TGeoPcon.h:18

TGeoPgon
Polygons are defined in the same way as polycones, the difference being just that the segments betwee...
Definition TGeoPgon.h:21

TGeoRotation
Class describing rotations.
Definition TGeoMatrix.h:175

TGeoShapeDialog
Definition TGeoTabManager.h:150

TGeoShape
Base abstract class for all shapes.
Definition TGeoShape.h:26

TGeoShape::GetName
virtual const char * GetName() const
Get the shape name.
Definition TGeoShape.cxx:248

TGeoShape::Draw
virtual void Draw(Option_t *option="")
Draw this shape.
Definition TGeoShape.cxx:721

TGeoSphere
TGeoSphere are not just balls having internal and external radii, but sectors of a sphere having defi...
Definition TGeoSphere.h:18

TGeoTabManager::GetPad
TVirtualPad * GetPad() const
Definition TGeoTabManager.h:64

TGeoTabManager::GetVolumeEditor
void GetVolumeEditor(TGeoVolume *vol)
Get editor for a volume.
Definition TGeoTabManager.cxx:119

TGeoTabManager::fVolumeTab
TGCompositeFrame * fVolumeTab
Definition TGeoTabManager.h:53

TGeoTabManager::GetMaterialEditor
void GetMaterialEditor(TGeoMaterial *material)
Get editor for a material.
Definition TGeoTabManager.cxx:159

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:200

TGeoTabManager::GetVolumeTab
TGCompositeFrame * GetVolumeTab() const
Definition TGeoTabManager.h:78

TGeoTabManager::GetMediumEditor
void GetMediumEditor(TGeoMedium *medium)
Get editor for a medium.
Definition TGeoTabManager.cxx:145

TGeoTabManager::Cleanup
static void Cleanup(TGCompositeFrame *frame)
Static method to cleanup hierarchically all daughters of a composite frame.
Definition TGeoTabManager.cxx:88

TGeoTabManager::GetShapeEditor
void GetShapeEditor(TGeoShape *shape)
Get editor for a shape.
Definition TGeoTabManager.cxx:106

TGeoTabManager::SetTab
void SetTab()
Set a given tab element as active one.
Definition TGeoTabManager.cxx:272

TGeoTabManager::SetVolTabEnabled
void SetVolTabEnabled(Bool_t flag=kTRUE)
Enable/disable tabs.
Definition TGeoTabManager.cxx:248

TGeoTabManager::GetMatrixEditor
void GetMatrixEditor(TGeoMatrix *matrix)
Get editor for a matrix.
Definition TGeoTabManager.cxx:132

TGeoTorus
The torus is defined by its axial radius, its inner and outer radius.
Definition TGeoTorus.h:18

TGeoTranslation
Class describing translations.
Definition TGeoMatrix.h:122

TGeoTrap
A general trapezoid.
Definition TGeoArb8.h:92

TGeoTrd1
A trapezoid with only X varying with Z.
Definition TGeoTrd1.h:18

TGeoTrd2
A trapezoid with only X varying with Z.
Definition TGeoTrd2.h:18

TGeoTreeDialog::GetSelected
static TObject * GetSelected()
static; return selected object
Definition TGeoTabManager.cxx:284

TGeoTubeSeg
A tube segment is a tube having a range in phi.
Definition TGeoTube.h:92

TGeoTube
Cylindrical tube class.
Definition TGeoTube.h:18

TGeoVolumeAssembly
Volume assemblies.
Definition TGeoVolume.h:305

TGeoVolumeDialog
Definition TGeoTabManager.h:125

TGeoVolume
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition TGeoVolume.h:49

TGeoVolume::Draw
virtual void Draw(Option_t *option="")
draw top volume according to option
Definition TGeoVolume.cxx:1147

TNamed::SetTitle
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164

TNamed::SetName
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140

TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition TNamed.h:48

TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition TNamed.h:47

TObjArray::GetEntries
Int_t GetEntries() const
Return the number of objects in array (i.e.
Definition TObjArray.cxx:523

TObject
Mother of all ROOT objects.
Definition TObject.h:41

TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:766

TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:515

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:869

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:1027

TString
Basic string class.
Definition TString.h:136

TString::Strip
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition TString.cxx:1131

TString::Data
const char * Data() const
Definition TString.h:369

TString::Remove
TString & Remove(Ssiz_t pos)
Definition TString.h:673

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:2336

TView::ShowAxis
virtual void ShowAxis()=0

TVirtualPad
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51

TVirtualPad::GetView
virtual TView * GetView() const =0

bool

int

unsigned int

f1
TF1 * f1
Definition legend1.C:11

v
@ v
Definition rootcling_impl.cxx:3670

event
Definition triangle.c:553