doc/master/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 = nullptr;

   fTab = nullptr;

   fConnectedCanvas = nullptr;


   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 = nullptr;

   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 = nullptr;

   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 = nullptr;

   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 = nullptr;

   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 = nullptr;

   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 = nullptr;

   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 | kFitWidth | 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 = nullptr;

   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 = nullptr;

   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 == nullptr) {

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

}


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

/// Dummy static function, used to load plugin


void TGeoManagerEditor::LoadLib() {}

kSunkenFrame
@ kSunkenFrame
Definition GuiTypes.h:383

kVerticalFrame
@ kVerticalFrame
Definition GuiTypes.h:381

kDoubleBorder
@ kDoubleBorder
Definition GuiTypes.h:385

kFixedWidth
@ kFixedWidth
Definition GuiTypes.h:387

kFitWidth
@ kFitWidth
Definition GuiTypes.h:386

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
constexpr Bool_t kFALSE
Definition RtypesCore.h:101

kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:100

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

TCanvas.h

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

TG3DLine.h

TGButtonGroup.h

TGButton.h

gClient
#define gClient
Definition TGClient.h:156

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

p
winID h TVirtualViewer3D TVirtualGLPainter p
Definition TGWin32VirtualGLProxy.cxx:51

width
Option_t Option_t width
Definition TGWin32VirtualXProxy.cxx:56

height
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t height
Definition TGWin32VirtualXProxy.cxx:164

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

kMANAGER_MATERIAL_SELECT
@ kMANAGER_MATERIAL_SELECT
Definition TGeoManagerEditor.cxx:93

kCAT_VOLUMES
@ kCAT_VOLUMES
Definition TGeoManagerEditor.cxx:111

kMANAGER_MEDIUM_SELECT
@ kMANAGER_MEDIUM_SELECT
Definition TGeoManagerEditor.cxx:103

kMANAGER_TITLE
@ kMANAGER_TITLE
Definition TGeoManagerEditor.cxx:90

kMANAGER_VOLUME_SELECT
@ kMANAGER_VOLUME_SELECT
Definition TGeoManagerEditor.cxx:97

kCREATE_XTRU
@ kCREATE_XTRU
Definition TGeoManagerEditor.cxx:121

kCREATE_CONS
@ kCREATE_CONS
Definition TGeoManagerEditor.cxx:126

kCREATE_TRD1
@ kCREATE_TRD1
Definition TGeoManagerEditor.cxx:117

kMATRIX_NAME
@ kMATRIX_NAME
Definition TGeoManagerEditor.cxx:146

kMANAGER_MATERIAL_SELECT2
@ kMANAGER_MATERIAL_SELECT2
Definition TGeoManagerEditor.cxx:102

kCREATE_ROTATION
@ kCREATE_ROTATION
Definition TGeoManagerEditor.cxx:142

kMANAGER_ELEMENT_SELECT
@ kMANAGER_ELEMENT_SELECT
Definition TGeoManagerEditor.cxx:94

kCREATE_TUBS
@ kCREATE_TUBS
Definition TGeoManagerEditor.cxx:124

kEXPORT_ROOT
@ kEXPORT_ROOT
Definition TGeoManagerEditor.cxx:106

kCREATE_TUBE
@ kCREATE_TUBE
Definition TGeoManagerEditor.cxx:123

kCREATE_TRANSLATION
@ kCREATE_TRANSLATION
Definition TGeoManagerEditor.cxx:141

kCAT_SHAPES
@ kCAT_SHAPES
Definition TGeoManagerEditor.cxx:110

kCREATE_CONE
@ kCREATE_CONE
Definition TGeoManagerEditor.cxx:125

kCREATE_SPHE
@ kCREATE_SPHE
Definition TGeoManagerEditor.cxx:127

kMANAGER_SHAPE_SELECT2
@ kMANAGER_SHAPE_SELECT2
Definition TGeoManagerEditor.cxx:95

kMANAGER_CANCEL
@ kMANAGER_CANCEL
Definition TGeoManagerEditor.cxx:150

kCAT_MATERIALS
@ kCAT_MATERIALS
Definition TGeoManagerEditor.cxx:113

kCREATE_GTRA
@ kCREATE_GTRA
Definition TGeoManagerEditor.cxx:120

kCREATE_COMP
@ kCREATE_COMP
Definition TGeoManagerEditor.cxx:135

kMEDIUM_ID
@ kMEDIUM_ID
Definition TGeoManagerEditor.cxx:145

kMATERIAL_NAME
@ kMATERIAL_NAME
Definition TGeoManagerEditor.cxx:147

kMANAGER_APPLY
@ kMANAGER_APPLY
Definition TGeoManagerEditor.cxx:149

kMANAGER_MATRIX_SELECT
@ kMANAGER_MATRIX_SELECT
Definition TGeoManagerEditor.cxx:104

kMANAGER_MEDIUM_SELECT2
@ kMANAGER_MEDIUM_SELECT2
Definition TGeoManagerEditor.cxx:96

kVOLUME_NAME
@ kVOLUME_NAME
Definition TGeoManagerEditor.cxx:148

kCREATE_CTUB
@ kCREATE_CTUB
Definition TGeoManagerEditor.cxx:128

kMANAGER_NELEM_SELECT
@ kMANAGER_NELEM_SELECT
Definition TGeoManagerEditor.cxx:101

kCREATE_TRAP
@ kCREATE_TRAP
Definition TGeoManagerEditor.cxx:119

kCREATE_VOLUME
@ kCREATE_VOLUME
Definition TGeoManagerEditor.cxx:139

kCREATE_ELTU
@ kCREATE_ELTU
Definition TGeoManagerEditor.cxx:129

kCREATE_PGON
@ kCREATE_PGON
Definition TGeoManagerEditor.cxx:132

kCREATE_TORUS
@ kCREATE_TORUS
Definition TGeoManagerEditor.cxx:130

kMANAGER_NAME
@ kMANAGER_NAME
Definition TGeoManagerEditor.cxx:89

kCREATE_ASSEMBLY
@ kCREATE_ASSEMBLY
Definition TGeoManagerEditor.cxx:140

kMANAGER_DENSITY_SELECT
@ kMANAGER_DENSITY_SELECT
Definition TGeoManagerEditor.cxx:100

kCREATE_MEDIUM
@ kCREATE_MEDIUM
Definition TGeoManagerEditor.cxx:138

kCREATE_PCON
@ kCREATE_PCON
Definition TGeoManagerEditor.cxx:131

kMANAGER_MEDIA_SELECT
@ kMANAGER_MEDIA_SELECT
Definition TGeoManagerEditor.cxx:92

kCREATE_ARB8
@ kCREATE_ARB8
Definition TGeoManagerEditor.cxx:122

kMEDIUM_NAME
@ kMEDIUM_NAME
Definition TGeoManagerEditor.cxx:144

kCREATE_COMBI
@ kCREATE_COMBI
Definition TGeoManagerEditor.cxx:143

kEXPORT_GEOMETRY
@ kEXPORT_GEOMETRY
Definition TGeoManagerEditor.cxx:108

kCREATE_PARAB
@ kCREATE_PARAB
Definition TGeoManagerEditor.cxx:134

kMANAGER_EDIT_MEDIUM
@ kMANAGER_EDIT_MEDIUM
Definition TGeoManagerEditor.cxx:99

kEXPORT_C
@ kEXPORT_C
Definition TGeoManagerEditor.cxx:107

kCAT_MATRICES
@ kCAT_MATRICES
Definition TGeoManagerEditor.cxx:114

kMANAGER_TOP_SELECT
@ kMANAGER_TOP_SELECT
Definition TGeoManagerEditor.cxx:105

kCREATE_BOX
@ kCREATE_BOX
Definition TGeoManagerEditor.cxx:115

kMANAGER_EDIT_SHAPE
@ kMANAGER_EDIT_SHAPE
Definition TGeoManagerEditor.cxx:98

kMANAGER_SHAPE_SELECT
@ kMANAGER_SHAPE_SELECT
Definition TGeoManagerEditor.cxx:91

kCREATE_MATERIAL
@ kCREATE_MATERIAL
Definition TGeoManagerEditor.cxx:136

kCREATE_PARA
@ kCREATE_PARA
Definition TGeoManagerEditor.cxx:116

kCAT_GENERAL
@ kCAT_GENERAL
Definition TGeoManagerEditor.cxx:109

kMANAGER_UNDO
@ kMANAGER_UNDO
Definition TGeoManagerEditor.cxx:151

kCAT_MEDIA
@ kCAT_MEDIA
Definition TGeoManagerEditor.cxx:112

kCREATE_TRD2
@ kCREATE_TRD2
Definition TGeoManagerEditor.cxx:118

kCREATE_MIXTURE
@ kCREATE_MIXTURE
Definition TGeoManagerEditor.cxx:137

TGeoManagerEditor.h

TGeoManager.h

gGeoManager
R__EXTERN TGeoManager * gGeoManager
Definition TGeoManager.h:608

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=nullptr)
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::ShowFrame
virtual void ShowFrame(TGFrame *f)
Show sub frame.
Definition TGFrame.cxx:1204

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

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::Resize
void Resize(UInt_t w=0, UInt_t h=0) override
Resize the frame.
Definition TGFrame.cxx:605

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

TGFrame::SetBackgroundColor
void SetBackgroundColor(Pixel_t back) override
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

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::GetNumberEntry
TGNumberEntryField * GetNumberEntry() const
Get the number entry field.
Definition TGNumberEntry.h:261

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

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::GetDefaultHeight
UInt_t GetDefaultHeight() const override
Definition TGNumberEntry.h:269

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

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

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

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

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

TGRadioButton
Selects different options.
Definition TGButton.h:321

TGRadioButton::IsDown
Bool_t IsDown() const override
Definition TGButton.h:370

TGShutterItem
Definition TGShutter.h:25

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

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

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

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
void Layout() override
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:17

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

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::GetCanvas
TCanvas * GetCanvas() const override
Definition TGedEditor.h:77

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

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

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

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

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

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

TGeoElementTable
Table of elements.
Definition TGeoElement.h:398

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

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

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

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

TGeoGtra
A twisted trapezoid.
Definition TGeoArb8.h:149

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TGeoManagerEditor::SetModel
void SetModel(TObject *obj) override
Refresh editor according the selected obj.
Definition TGeoManagerEditor.cxx:795

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TGeoManagerEditor::fIsModified
Bool_t fIsModified
Definition TGeoManagerEditor.h:43

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

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

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

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

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

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

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

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

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

TGeoManagerEditor::fVolumeName
TGTextEntry * fVolumeName
Definition TGeoManagerEditor.h:50

TGeoManagerEditor::fBSelVolume
TGPictureButton * fBSelVolume
Definition TGeoManagerEditor.h:59

TGeoManagerEditor::ShowSelectMaterial
void ShowSelectMaterial(Bool_t show=kTRUE)
Show/hide interface for material selection.
Definition TGeoManagerEditor.cxx:1491

TGeoManagerEditor::DoCreateTrd2
void DoCreateTrd2()
Create a Trd2.
Definition TGeoManagerEditor.cxx:927

TGeoManagerEditor::fSelectedMatrix
TGeoMatrix * fSelectedMatrix
Definition TGeoManagerEditor.h:66

TGeoManagerEditor::DoCreateVolume
void DoCreateVolume()
Create a new volume.
Definition TGeoManagerEditor.cxx:1213

TGeoManagerEditor::DoCreateCone
void DoCreateCone()
Create a cone.
Definition TGeoManagerEditor.cxx:1004

TGeoManagerEditor::DoCreateXtru
void DoCreateXtru()
Create an extruded polygone.
Definition TGeoManagerEditor.cxx:967

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

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

TGeoManagerEditor::fLSelMaterial
TGLabel * fLSelMaterial
Definition TGeoManagerEditor.h:53

TGeoManagerEditor::fLSelTop
TGLabel * fLSelTop
Definition TGeoManagerEditor.h:91

TGeoManagerEditor::fSelectedShape
TGeoShape * fSelectedShape
Definition TGeoManagerEditor.h:60

TGeoManagerEditor::fSelectedVolume
TGeoVolume * fSelectedVolume
Definition TGeoManagerEditor.h:57

TGeoManagerEditor::DoExportGeometry
void DoExportGeometry()
Export geometry as .root or .C file.
Definition TGeoManagerEditor.cxx:870

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

TGeoManagerEditor::DoCreateTube
void DoCreateTube()
Create a tube.
Definition TGeoManagerEditor.cxx:978

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

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

TGeoManagerEditor::fExportButton
TGTextButton * fExportButton
Definition TGeoManagerEditor.h:80

TGeoManagerEditor::fSelectedMedium
TGeoMedium * fSelectedMedium
Definition TGeoManagerEditor.h:69

TGeoManagerEditor::fMaterialName
TGTextEntry * fMaterialName
Definition TGeoManagerEditor.h:49

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

TGeoManagerEditor::DoCreatePcon
void DoCreatePcon()
Create a polycone shape.
Definition TGeoManagerEditor.cxx:1082

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

TGeoManagerEditor::f7
TGCompositeFrame * f7
Definition TGeoManagerEditor.h:99

TGeoManagerEditor::DoCreateTorus
void DoCreateTorus()
Create a torus shape.
Definition TGeoManagerEditor.cxx:1069

TGeoManagerEditor::DoCreateTrap
void DoCreateTrap()
Create a general trapezoid.
Definition TGeoManagerEditor.cxx:940

TGeoManagerEditor::fCloseGeometry
TGTextButton * fCloseGeometry
Definition TGeoManagerEditor.h:93

TGeoManagerEditor::DoCreateSphe
void DoCreateSphe()
Create a sphere.
Definition TGeoManagerEditor.cxx:1030

TGeoManagerEditor::fBSelShape
TGPictureButton * fBSelShape
Definition TGeoManagerEditor.h:64

TGeoManagerEditor::fExportOption
TGRadioButton * fExportOption[2]
Definition TGeoManagerEditor.h:79

TGeoManagerEditor::DoSelectMaterial2
void DoSelectMaterial2()
Slot for selecting an existing material and making a medium.
Definition TGeoManagerEditor.cxx:1380

TGeoManagerEditor::DoCreateMaterial
void DoCreateMaterial()
Create a new material.
Definition TGeoManagerEditor.cxx:1135

TGeoManagerEditor::fBSelTop
TGPictureButton * fBSelTop
Definition TGeoManagerEditor.h:92

TGeoManagerEditor::fLSelMaterial2
TGLabel * fLSelMaterial2
Definition TGeoManagerEditor.h:54

TGeoManagerEditor::fGeometry
TGeoManager * fGeometry
Definition TGeoManagerEditor.h:39

TGeoManagerEditor::~TGeoManagerEditor
~TGeoManagerEditor() override
Destructor.
Definition TGeoManagerEditor.cxx:671

TGeoManagerEditor::fLSelMatrix
TGLabel * fLSelMatrix
Definition TGeoManagerEditor.h:67

TGeoManagerEditor::ShowSelectMedium
void ShowSelectMedium(Bool_t show=kTRUE)
Show/hide interface for medium selection.
Definition TGeoManagerEditor.cxx:1503

TGeoManagerEditor::fCategories
TGShutter * fCategories
Definition TGeoManagerEditor.h:44

TGeoManagerEditor::SelectedSlot
virtual void SelectedSlot(TVirtualPad *pad, TObject *obj, Int_t event)
Connected to TCanvas::Selected.
Definition TGeoManagerEditor.cxx:708

TGeoManagerEditor::fSelectedShape2
TGeoShape * fSelectedShape2
Definition TGeoManagerEditor.h:61

TGeoManagerEditor::ShowSelectVolume
void ShowSelectVolume(Bool_t show=kTRUE)
Show/hide interface for volume selection.
Definition TGeoManagerEditor.cxx:1474

TGeoManagerEditor::fTab
TGTab * fTab
Definition TGeoManagerEditor.h:41

TGeoManagerEditor::DoCreateMedium
void DoCreateMedium()
Create a new medium.
Definition TGeoManagerEditor.cxx:1168

TGeoManagerEditor::fConnectedCanvas
TCanvas * fConnectedCanvas
Definition TGeoManagerEditor.h:100

TGeoManagerEditor::ShowSelectShape
void ShowSelectShape(Bool_t show=kTRUE)
Show/hide interface for shape selection.
Definition TGeoManagerEditor.cxx:1462

TGeoManagerEditor::ShowSelectMatrix
void ShowSelectMatrix(Bool_t show=kTRUE)
Show/hide interface for matrix selection.
Definition TGeoManagerEditor.cxx:1515

TGeoManagerEditor::fLSelMedium
TGLabel * fLSelMedium
Definition TGeoManagerEditor.h:71

TGeoManagerEditor::DoSelectMatrix
void DoSelectMatrix()
Slot for selecting an existing matrix.
Definition TGeoManagerEditor.cxx:1324

TGeoManagerEditor::LoadLib
static void LoadLib()
Dummy static function, used to load plugin.
Definition TGeoManagerEditor.cxx:1527

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

TGeoManagerEditor::fEntryDensity
TGNumberEntry * fEntryDensity
Definition TGeoManagerEditor.h:82

TGeoManagerEditor::DoEditShape
void DoEditShape()
Slot for editing selected shape.
Definition TGeoManagerEditor.cxx:1267

TGeoManagerEditor::fLSelVolume
TGLabel * fLSelVolume
Definition TGeoManagerEditor.h:58

TGeoManagerEditor::DoCreateEltu
void DoCreateEltu()
Create an elliptical tube.
Definition TGeoManagerEditor.cxx:1056

TGeoManagerEditor::DoCreateCombi
void DoCreateCombi()
Create a new translation + rotation.
Definition TGeoManagerEditor.cxx:1241

TGeoManagerEditor::DoCreateComposite
void DoCreateComposite()
Create a composite shape.
Definition TGeoManagerEditor.cxx:1130

TGeoManagerEditor::DoCreateRotation
void DoCreateRotation()
Create a new rotation.
Definition TGeoManagerEditor.cxx:1199

TGeoManagerEditor::fBSelMedium
TGPictureButton * fBSelMedium
Definition TGeoManagerEditor.h:73

TGeoManagerEditor::fShapeButton
TGPictureButton * fShapeButton[21]
Definition TGeoManagerEditor.h:75

TGeoManagerEditor::DoCreateCtub
void DoCreateCtub()
Create a cut tube.
Definition TGeoManagerEditor.cxx:1043

TGeoManagerEditor::TGeoManagerEditor
TGeoManagerEditor(const TGWindow *p=nullptr, Int_t width=140, Int_t height=30, UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground())
Constructor for manager editor.
Definition TGeoManagerEditor.cxx:157

TGeoManager
The manager class for any TGeo geometry.
Definition TGeoManager.h:44

TGeoManager::GetListOfMedia
TList * GetListOfMedia() const
Definition TGeoManager.h:472

TGeoManager::GetElementTable
TGeoElementTable * GetElementTable()
Returns material table. Creates it if not existing.
Definition TGeoManager.cxx:3624

TGeoManager::GetListOfVolumes
TObjArray * GetListOfVolumes() const
Definition TGeoManager.h:473

TGeoManager::GetListOfMatrices
TObjArray * GetListOfMatrices() const
Definition TGeoManager.h:470

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

TGeoManager::GetMasterVolume
TGeoVolume * GetMasterVolume() const
Definition TGeoManager.h:511

TGeoManager::IsClosed
Bool_t IsClosed() const
Definition TGeoManager.h:297

TGeoManager::CloseGeometry
void CloseGeometry(Option_t *option="d")
Closing geometry implies checking the geometry validity, fixing shapes with negative parameters (run-...
Definition TGeoManager.cxx:1480

TGeoManager::SetTopVolume
void SetTopVolume(TGeoVolume *vol)
Set the top volume and corresponding node as starting point of the geometry.
Definition TGeoManager.cxx:3655

TGeoManager::BuildDefaultMaterials
void BuildDefaultMaterials()
Now just a shortcut for GetElementTable.
Definition TGeoManager.cxx:3615

TGeoManager::GetListOfMaterials
TList * GetListOfMaterials() const
Definition TGeoManager.h:471

TGeoManager::GetListOfShapes
TObjArray * GetListOfShapes() const
Definition TGeoManager.h:475

TGeoManager::GetTopVolume
TGeoVolume * GetTopVolume() const
Definition TGeoManager.h:512

TGeoMaterialDialog
Definition TGeoTabManager.h:203

TGeoMaterial
Base class describing materials.
Definition TGeoMaterial.h:34

TGeoMatrixDialog
Definition TGeoTabManager.h:228

TGeoMatrix
Geometrical transformation package.
Definition TGeoMatrix.h:38

TGeoMatrix::kGeoTranslation
@ kGeoTranslation
Definition TGeoMatrix.h:43

TGeoMatrix::kGeoRotation
@ kGeoRotation
Definition TGeoMatrix.h:44

TGeoMatrix::RegisterYourself
virtual void RegisterYourself()
Register the matrix in the current manager, which will become the owner.
Definition TGeoMatrix.cxx:516

TGeoMediumDialog
Definition TGeoTabManager.h:178

TGeoMedium
Media are used to store properties related to tracking and which are useful only when using geometry ...
Definition TGeoMedium.h:23

TGeoMixture
Mixtures of elements.
Definition TGeoMaterial.h:159

TGeoPara
Parallelepiped class.
Definition TGeoPara.h:17

TGeoPcon
A polycone is represented by a sequence of tubes/cones, glued together at defined Z planes.
Definition TGeoPcon.h:17

TGeoPgon
Polygons are defined in the same way as polycones, the difference being just that the segments betwee...
Definition TGeoPgon.h:20

TGeoRotation
Class describing rotations.
Definition TGeoMatrix.h:168

TGeoShapeDialog
Definition TGeoTabManager.h:153

TGeoShape
Base abstract class for all shapes.
Definition TGeoShape.h:25

TGeoShape::Draw
void Draw(Option_t *option="") override
Draw this shape.
Definition TGeoShape.cxx:771

TGeoShape::GetName
const char * GetName() const override
Get the shape name.
Definition TGeoShape.cxx:250

TGeoSphere
TGeoSphere are not just balls having internal and external radii, but sectors of a sphere having defi...
Definition TGeoSphere.h:17

TGeoTabManager::GetPad
TVirtualPad * GetPad() const
Definition TGeoTabManager.h:66

TGeoTabManager::GetVolumeEditor
void GetVolumeEditor(TGeoVolume *vol)
Get editor for a volume.
Definition TGeoTabManager.cxx:125

TGeoTabManager::fVolumeTab
TGCompositeFrame * fVolumeTab
Definition TGeoTabManager.h:54

TGeoTabManager::GetMaterialEditor
void GetMaterialEditor(TGeoMaterial *material)
Get editor for a material.
Definition TGeoTabManager.cxx:170

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

TGeoTabManager::GetVolumeTab
TGCompositeFrame * GetVolumeTab() const
Definition TGeoTabManager.h:80

TGeoTabManager::GetMediumEditor
void GetMediumEditor(TGeoMedium *medium)
Get editor for a medium.
Definition TGeoTabManager.cxx:154

TGeoTabManager::Cleanup
static void Cleanup(TGCompositeFrame *frame)
Static method to cleanup hierarchically all daughters of a composite frame.
Definition TGeoTabManager.cxx:92

TGeoTabManager::GetShapeEditor
void GetShapeEditor(TGeoShape *shape)
Get editor for a shape.
Definition TGeoTabManager.cxx:110

TGeoTabManager::SetTab
void SetTab()
Set a given tab element as active one.
Definition TGeoTabManager.cxx:291

TGeoTabManager::SetVolTabEnabled
void SetVolTabEnabled(Bool_t flag=kTRUE)
Enable/disable tabs.
Definition TGeoTabManager.cxx:267

TGeoTabManager::GetMatrixEditor
void GetMatrixEditor(TGeoMatrix *matrix)
Get editor for a matrix.
Definition TGeoTabManager.cxx:139

TGeoTorus
The torus is defined by its axial radius, its inner and outer radius.
Definition TGeoTorus.h:17

TGeoTranslation
Class describing translations.
Definition TGeoMatrix.h:116

TGeoTrap
A general trapezoid.
Definition TGeoArb8.h:96

TGeoTrd1
A trapezoid with only X varying with Z.
Definition TGeoTrd1.h:17

TGeoTrd2
A trapezoid with only X varying with Z.
Definition TGeoTrd2.h:17

TGeoTreeDialog::GetSelected
static TObject * GetSelected()
static; return selected object
Definition TGeoTabManager.cxx:303

TGeoTubeSeg
A tube segment is a tube having a range in phi.
Definition TGeoTube.h:94

TGeoTube
Cylindrical tube class.
Definition TGeoTube.h:17

TGeoVolumeAssembly
Volume assemblies.
Definition TGeoVolume.h:316

TGeoVolumeDialog
Definition TGeoTabManager.h:128

TGeoVolume
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition TGeoVolume.h:43

TGeoVolume::Draw
void Draw(Option_t *option="") override
draw top volume according to option
Definition TGeoVolume.cxx:1206

TGeoVolume::Class
static TClass * Class()

TNamed::SetTitle
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164

TNamed::GetName
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47

TNamed::GetTitle
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:48

TNamed::SetName
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140

TObjArray::GetEntries
Int_t GetEntries() const override
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:780

TObject::InheritsFrom
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:525

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=nullptr, void *receiver=nullptr, const char *slot=nullptr)
Disconnects signal of this object from slot of receiver.
Definition TQObject.cxx:1027

TString
Basic string class.
Definition TString.h:139

TString::Strip
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition TString.cxx:1163

TString::Data
const char * Data() const
Definition TString.h:376

TString::Remove
TString & Remove(Ssiz_t pos)
Definition TString.h:685

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

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

double

int

unsigned int

f1
TF1 * f1
Definition legend1.C:11

v
@ v
Definition rootcling_impl.cxx:3687