doc/master/TGeoVolumeEditor_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 TGeoVolumeEditor

\ingroup Geometry_builder


Editor for geometry volumes and assemblies of volumes. Besides the volume

name and line attributes, a TGeoVolume has the following editable categories

split vertically by a shutter:


  - Properties: one can edit the shape and medium components from here. It is

    also possible to change the existing ones.

  - Daughters: the main category allowing defining, editing, removing or

    positioning daughter volumes inside the current edited volume. To add a

    daughter, one needs to select first a volume and a matrix. Currently no check

    is performed if the daughter volume creates an extrusion (illegal for tracking).

    To remove or change the position of an existing daughter, one should simply

    select the desired daughter from the combo box with the existing ones, then

    simply click the appropriate button.

  - Visualization: One can set the visibility of the volume and of its daughters,

    set the visibility depth and the view type. Selecting "All" will draw the

    volume and all visible daughters down to the selected level starting from the

    edited volume. Selecting "Leaves" will draw just the deepest daughters within

    the selected visibility level, without displaying the containers, while "Only"

    will just draw the edited volume.

  - Division: The category becomes active only if there are no daughters of the

    edited volume added by normal positioning (e.g. from `<Daughters>` category). The

    minimum allowed starting value for the selected division axis is automatically

    selected, while the slicing step is set to 0 - meaning that only the number

    of slices matter.

*/


#include "TGeoVolumeEditor.h"

#include "TGeoVolume.h"

#include "TGeoPatternFinder.h"

#include "TGeoManager.h"

#include "TGeoMatrix.h"

#include "TGTab.h"

#include "TGComboBox.h"

#include "TGButton.h"

#include "TGButtonGroup.h"

#include "TGTextEntry.h"

#include "TGNumberEntry.h"

#include "TGLabel.h"

#include "TGShutter.h"

#include "TG3DLine.h"

#include "TGeoTabManager.h"

#include "TGedEditor.h"


enum ETGeoVolumeWid {

   kVOL_NAME,

   kVOL_TITLE,

   kVOL_SHAPE_SELECT,

   kVOL_MEDIA_SELECT,

   kVOL_NODE_SELECT,

   kVOL_VOL_SELECT,

   kVOL_MATRIX_SELECT,

   kVOL_EDIT_SHAPE,

   kVOL_EDIT_MEDIUM,

   kVOL_NODEID,

   kVOL_APPLY,

   kVOL_CANCEL,

   kVOL_UNDO,

   kVOL_VISLEVEL,

   kVOL_DIVSTART,

   kVOL_DIVEND,

   kVOL_DIVSTEP,

   kVOL_DIVN,

   kCAT_GENERAL,

   kCAT_DAUGHTERS,

   kCAT_DIVISION,

   kCAT_VIS,

   kDIV_NAME

};


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

/// Constructor for volume editor.


TGeoVolumeEditor::TGeoVolumeEditor(const TGWindow *p, Int_t width, Int_t height, UInt_t options, Pixel_t back)

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

{

   fGeometry = nullptr;

   fVolume = nullptr;


   fIsModified = kFALSE;

   fIsAssembly = kFALSE;

   fIsDivided = kFALSE;


   // TGShutter for categories

   fCategories = new TGShutter(this, kSunkenFrame);

   TGCompositeFrame *container, *f1;

   Pixel_t color;

   TGLabel *label;


   // General settings

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

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

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);


   // TextEntry for volume name

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

   f1->AddFrame(label = new TGLabel(f1, "Volume name"), 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));

   fVolumeName = new TGTextEntry(container, "", kVOL_NAME);

   fVolumeName->SetDefaultSize(135, fVolumeName->GetDefaultHeight());

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

   container->AddFrame(fVolumeName, new TGLayoutHints(kLHintsLeft | kLHintsExpandX, 3, 1, 2, 5));


   // Current shape

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

   f1->AddFrame(label = new TGLabel(f1, "Shape and 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, 10, 0));

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

   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"), kVOL_SHAPE_SELECT);

   fBSelShape->SetToolTipText("Replace with 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(kLHintsLeft, 1, 1, 2, 2));

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

   fEditShape->Associate(this);

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


   // Current medium

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

   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"), kVOL_MEDIA_SELECT);

   fBSelMedium->SetToolTipText("Replace with 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(kLHintsLeft, 1, 1, 2, 2));

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

   fEditMedium->Associate(this);

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


   // List of daughters

   si = new TGShutterItem(fCategories, new TGHotString("Daughters"), kCAT_DAUGHTERS);

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

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);


   // Existing daughters

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

   f1->AddFrame(label = new TGLabel(f1, "Existing daughters"), 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 | kRaisedFrame);

   fNodeList = new TGComboBox(f1, kVOL_NODE_SELECT);

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

   fNodeList->Associate(this);

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

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

   // Buttons for editing matrix and removing node

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

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

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

   fEditMatrix->SetToolTipText("Edit the position of selected node");

   fEditMatrix->Associate(this);

   fRemoveNode = new TGTextButton(f1, "Remove");

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

   fRemoveNode->SetToolTipText("Remove the selected node. Cannot undo !)");

   fRemoveNode->Associate(this);

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


   // Adding daughters

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

   f1->AddFrame(label = new TGLabel(f1, "Add daughter"), 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, 10, 0));


   // Select from existing volumes

   f1 = new TGCompositeFrame(container, 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"), kVOL_VOL_SELECT);

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

   fBSelVolume->Associate(this);

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

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


   // Matrix selection for nodes

   f1 = new TGCompositeFrame(container, 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"), kVOL_MATRIX_SELECT);

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

   fBSelMatrix->Associate(this);

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

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


   // Copy number

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

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

   fCopyNumber = new TGNumberEntry(f1, 0., 5, kVOL_NODEID);

   fCopyNumber->SetNumStyle(TGNumberFormat::kNESInteger);

   fCopyNumber->SetNumAttr(TGNumberFormat::kNEANonNegative);

   fCopyNumber->Resize(20, fCopyNumber->GetDefaultHeight());

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

   nef->SetToolTipText("Enter node copy number");

   fCopyNumber->Associate(this);

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

   fAddNode = new TGTextButton(f1, "Add");

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

   fAddNode->Associate(this);

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


   // Visualization

   si = new TGShutterItem(fCategories, new TGHotString("Visualization"), kCAT_VIS);

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

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);


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

   f1->AddFrame(/* label = */ new TGLabel(f1, "Visibility"), 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, 10, kHorizontalFrame | kFixedWidth | kSunkenFrame | kDoubleBorder);

   fBVis[0] = new TGCheckButton(f1, "Volume");

   fBVis[1] = new TGCheckButton(f1, "Nodes");

   f1->AddFrame(fBVis[0], new TGLayoutHints(kLHintsLeft, 2, 2, 0, 0));

   f1->AddFrame(fBVis[1], new TGLayoutHints(kLHintsRight, 2, 2, 0, 0));

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


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

   f1->AddFrame(new TGLabel(f1, "Depth"), new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));

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

   //   label->SetTextColor(color);

   fEVisLevel = new TGNumberEntry(f1, 0, 5, kVOL_VISLEVEL);

   fEVisLevel->SetNumStyle(TGNumberFormat::kNESInteger);

   fEVisLevel->SetNumAttr(TGNumberFormat::kNEAPositive);

   fEVisLevel->Resize(40, fEVisLevel->GetDefaultHeight());

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

   nef->SetToolTipText("Set visibility level here");

   fEVisLevel->SetNumber(3);

   fEVisLevel->Associate(this);

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

   fBAuto = new TGCheckButton(f1, "Auto");

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

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


   TString stitle = "View";

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

   fBView[0] = new TGRadioButton(bg, "All");

   fBView[1] = new TGRadioButton(bg, "Leaves");

   fBView[2] = new TGRadioButton(bg, "Only");

   bg->SetRadioButtonExclusive();

   bg->Show();

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


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

   fBRaytrace = new TGCheckButton(f1, "Raytrace");

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

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


   // Division

   si = new TGShutterItem(fCategories, new TGHotString("Division"), kCAT_DIVISION);

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

   container->SetBackgroundColor(GetDefaultFrameBackground());

   fCategories->AddItem(si);

   // TextEntry for division name

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

   f1->AddFrame(label = new TGLabel(f1, "Division name"), 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));

   fDivName = new TGTextEntry(container, new TGTextBuffer(50), kDIV_NAME);

   fDivName->Resize(135, fVolumeName->GetDefaultHeight());

   fDivName->SetToolTipText("Enter the volume name");

   container->AddFrame(fDivName, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 5));

   // Axis selection

   stitle = "Axis";

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

   bg = new TGVButtonGroup(f1, stitle);

   fBDiv[0] = new TGRadioButton(bg, "Axis 1");

   fBDiv[1] = new TGRadioButton(bg, "Axis 2");

   fBDiv[2] = new TGRadioButton(bg, "Axis 3");

   bg->Insert(fBDiv[0]);

   bg->Insert(fBDiv[1]);

   bg->Insert(fBDiv[2]);

   bg->SetRadioButtonExclusive();

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

   fApplyDiv = new TGTextButton(f1, "Apply");

   fApplyDiv->SetToolTipText("Apply new division settings");

   f1->AddFrame(fApplyDiv, new TGLayoutHints(kLHintsRight, 0, 2, 30, 0));

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

   // Division range

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

   f1->AddFrame(/* label = */ new TGLabel(f1, "Division parameters"), 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, 10, kHorizontalFrame | kFixedWidth);

   f1->AddFrame(/* label = */ new TGLabel(f1, "From"), new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));

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

   //   label->SetTextColor(color);

   fEDivFrom = new TGNumberEntry(f1, 0, 5, kVOL_DIVSTART);

   //   fEDivFrom->SetNumStyle(TGNumberFormat::kNESInteger);

   //   fEDivFrom->SetNumAttr(TGNumberFormat::kNEAPositive);

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

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

   nef->SetToolTipText("Set start value");

   fEDivFrom->Associate(this);

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

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


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

   f1->AddFrame(/* label = */ new TGLabel(f1, "Step"), new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));

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

   //   label->SetTextColor(color);

   fEDivStep = new TGNumberEntry(f1, 0, 5, kVOL_DIVSTEP);

   //   fEDivFrom->SetNumStyle(TGNumberFormat::kNESInteger);

   fEDivStep->SetNumAttr(TGNumberFormat::kNEANonNegative);

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

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

   nef->SetToolTipText("Set division step");

   fEDivStep->Associate(this);

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

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


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

   f1->AddFrame(/* label = */ new TGLabel(f1, "Nslices"), new TGLayoutHints(kLHintsLeft, 2, 2, 4, 0));

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

   //   label->SetTextColor(color);

   fEDivN = new TGNumberEntry(f1, 0, 5, kVOL_DIVN);

   fEDivN->SetNumStyle(TGNumberFormat::kNESInteger);

   fEDivN->SetNumAttr(TGNumberFormat::kNEAPositive);

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

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

   nef->SetToolTipText("Set number of slices");

   fEDivN->Associate(this);

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

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


   fCategories->Resize(163, 340);

   AddFrame(fCategories, new TGLayoutHints(kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 0, 0, 4, 4));


   fCategories->Layout();

   fCategories->SetDefaultSize(GetDefaultWidth(), GetDefaultHeight());

}


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

/// Destructor


TGeoVolumeEditor::~TGeoVolumeEditor()

{

   TGCompositeFrame *cont;

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

   TGeoTabManager::Cleanup(cont);

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

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

   TGeoTabManager::Cleanup(cont);

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

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

   TGeoTabManager::Cleanup(cont);

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

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

   TGeoTabManager::Cleanup(cont);

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


   delete fBView[0];

   delete fBView[1];

   delete fBView[2];

   delete fBDiv[0];

   delete fBDiv[1];

   delete fBDiv[2];

   Cleanup();

}


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

/// Connect signals to slots.


void TGeoVolumeEditor::ConnectSignals2Slots()

{

   fVolumeName->Connect("TextChanged(const char *)", "TGeoVolumeEditor", this, "DoVolumeName()");

   fDivName->Connect("TextChanged(const char *)", "TGeoVolumeEditor", this, "DoDivName()");

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

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

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

   fAddNode->Connect("Clicked()", "TGeoVolumeEditor", this, "DoAddNode()");

   fRemoveNode->Connect("Clicked()", "TGeoVolumeEditor", this, "DoRemoveNode()");

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

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

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

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

   fBVis[0]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoVisVolume()");

   fBVis[1]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoVisDaughters()");

   fBAuto->Connect("Clicked()", "TGeoVolumeEditor", this, "DoVisAuto()");

   fEVisLevel->Connect("ValueSet(Long_t)", "TGeoVolumeEditor", this, "DoVisLevel()");

   fBView[0]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoViewAll()");

   fBView[1]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoViewLeaves()");

   fBView[2]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoViewOnly()");

   fBDiv[0]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoDivSelAxis()");

   fBDiv[1]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoDivSelAxis()");

   fBDiv[2]->Connect("Clicked()", "TGeoVolumeEditor", this, "DoDivSelAxis()");

   fEDivFrom->Connect("ValueSet(Long_t)", "TGeoVolumeEditor", this, "DoDivFromTo()");

   fEDivStep->Connect("ValueSet(Long_t)", "TGeoVolumeEditor", this, "DoDivStep()");

   fEDivN->Connect("ValueSet(Long_t)", "TGeoVolumeEditor", this, "DoDivN()");

   fBRaytrace->Connect("Clicked()", "TGeoVolumeEditor", this, "DoRaytrace()");

   fApplyDiv->Connect("Clicked()", "TGeoVolumeEditor", this, "DoApplyDiv()");

}


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

/// Connect to the picked volume.


void TGeoVolumeEditor::SetModel(TObject *obj)

{

   if (obj == nullptr || !obj->InheritsFrom(TGeoVolume::Class())) {

      SetActive(kFALSE);

      return;

   }

   fVolume = (TGeoVolume *)obj;

   fGeometry = fVolume->GetGeoManager();

   const char *vname = fVolume->GetName();

   fVolumeName->SetText(vname);

   fSelectedShape = fVolume->GetShape();

   if (fSelectedShape)

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

   fSelectedMedium = fVolume->GetMedium();

   if (fSelectedMedium)

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


   fNodeList->RemoveEntries(0, fNodeList->GetNumberOfEntries() + 1);

   TIter next2(fVolume->GetNodes());

   TGeoNode *node;

   Int_t icrt = 0;

   while ((node = (TGeoNode *)next2()))

      fNodeList->AddEntry(node->GetName(), icrt++);

   fNodeList->Select(0);

   fCopyNumber->SetNumber(fVolume->GetNdaughters() + 1);

   if (!fVolume->GetNdaughters() || fVolume->GetFinder()) {

      fEditMatrix->SetEnabled(kFALSE);

      fRemoveNode->SetEnabled(kFALSE);

   } else {

      fEditMatrix->SetEnabled(kTRUE);

      fRemoveNode->SetEnabled(kTRUE);

   }

   if (!fSelectedVolume)

      fAddNode->SetEnabled(kFALSE);

   if (fVolume->IsAssembly()) {

      fBSelShape->SetEnabled(kFALSE);

      fBSelMedium->SetEnabled(kFALSE);

   }

   fBVis[0]->SetState((fVolume->IsVisible()) ? kButtonDown : kButtonUp);

   fBVis[1]->SetState((fVolume->IsVisibleDaughters()) ? kButtonDown : kButtonUp);

   fBView[0]->SetState((fVolume->IsVisContainers()) ? kButtonDown : kButtonUp, kTRUE);

   fBView[1]->SetState((fVolume->IsVisLeaves()) ? kButtonDown : kButtonUp, kTRUE);

   fBView[2]->SetState((fVolume->IsVisOnly()) ? kButtonDown : kButtonUp, kTRUE);

   fBRaytrace->SetState((fVolume->IsRaytracing()) ? kButtonDown : kButtonUp);

   fBAuto->SetState((fGeometry->GetVisLevel()) ? kButtonUp : kButtonDown);

   fEVisLevel->SetNumber(fGeometry->GetVisLevel());

   fApplyDiv->SetEnabled(kFALSE);

   if ((!fVolume->GetFinder() && fVolume->GetNdaughters()) || fVolume->IsAssembly()) {

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

   } else {

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

      Double_t start = 0., step = 0., end = 0.;

      Int_t ndiv = 2, iaxis = 1;

      TString axis_name;

      for (Int_t i = 0; i < 3; i++) {

         axis_name = fVolume->GetShape()->GetAxisName(i + 1);

         fBDiv[i]->SetText(axis_name);

      }


      if (fVolume->GetFinder()) {

         fDivName->SetText(fVolume->GetNode(0)->GetVolume()->GetName());

         iaxis = fVolume->GetFinder()->GetDivAxis();

         start = fVolume->GetFinder()->GetStart();

         step = fVolume->GetFinder()->GetStep();

         ndiv = fVolume->GetFinder()->GetNdiv();

      } else {

         fDivName->SetText("Enter name");

         fSelectedShape->GetAxisRange(iaxis, start, end);

         step = 0;

      }

      fBDiv[iaxis - 1]->SetState(kButtonDown, kTRUE);

      fEDivFrom->SetNumber(start);

      fEDivStep->SetNumber(step);

      fEDivN->SetNumber(ndiv);

   }


   if (fInit)

      ConnectSignals2Slots();

   SetActive();

   if (GetParent() == fTabMgr->GetVolumeTab())

      fTab->Layout();

}


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

/// Add editors to fGedFrame and exclude TLineEditor.


void TGeoVolumeEditor::ActivateBaseClassEditors(TClass *cl)

{

   fGedEditor->ExcludeClassEditor(TAttFill::Class());

   TGedFrame::ActivateBaseClassEditors(cl);

}


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

/// Modify volume name.


void TGeoVolumeEditor::DoVolumeName()

{

   fVolume->SetName(fVolumeName->GetText());

}


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

/// Select a new shape.


void TGeoVolumeEditor::DoSelectShape()

{

   TGeoShape *shape = fSelectedShape;

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

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

   if (fSelectedShape)

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

   else

      fSelectedShape = shape;

}


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

/// Select a new medium.


void TGeoVolumeEditor::DoSelectMedium()

{

   TGeoMedium *med = fSelectedMedium;

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

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

   if (fSelectedMedium)

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

   else

      fSelectedMedium = med;

}


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

/// Select a matrix for positioning.


void TGeoVolumeEditor::DoSelectMatrix()

{

   TGeoMatrix *matrix = fSelectedMatrix;

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

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

   if (fSelectedMatrix)

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

   else

      fSelectedMatrix = matrix;

}


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

/// Select a daughter volume.


void TGeoVolumeEditor::DoSelectVolume()

{

   TGeoVolume *vol = fSelectedVolume;

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

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

   if (fSelectedVolume)

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

   else

      fSelectedVolume = vol;

   if (fSelectedVolume)

      fAddNode->SetEnabled(kTRUE);

}


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

/// Edit the shape of the volume.


void TGeoVolumeEditor::DoEditShape()

{

   fTabMgr->GetShapeEditor(fVolume->GetShape());

}


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

/// Edit the medium of the volume.


void TGeoVolumeEditor::DoEditMedium()

{

   fTabMgr->GetMediumEditor(fVolume->GetMedium());

}


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

/// Edit the position of the selected node.


void TGeoVolumeEditor::DoEditMatrix()

{

   if (!fVolume->GetNdaughters())

      return;

   Int_t i = fNodeList->GetSelected();

   if (i < 0)

      return;

   fTabMgr->GetMatrixEditor(fVolume->GetNode(i)->GetMatrix());

}


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

/// Add a daughter.


void TGeoVolumeEditor::DoAddNode()

{

   if (!fSelectedVolume || fVolume->GetFinder())

      return;

   Int_t icopy = fCopyNumber->GetIntNumber();

   fVolume->AddNode(fSelectedVolume, icopy, fSelectedMatrix);

   Int_t nd = fVolume->GetNdaughters();

   fNodeList->AddEntry(fVolume->GetNode(nd - 1)->GetName(), nd - 1);

   fNodeList->Select(nd - 1);

   fCopyNumber->SetNumber(nd + 1);

   if (fSelectedMatrix)

      fEditMatrix->SetEnabled(kTRUE);

   fRemoveNode->SetEnabled(kTRUE);

   fGeometry->SetTopVisible();

   fEditMatrix->SetEnabled(kTRUE);

   fRemoveNode->SetEnabled(kTRUE);

   Update();

}


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

/// Remove a daughter.


void TGeoVolumeEditor::DoRemoveNode()

{

   if (!fVolume->GetNdaughters() || fVolume->GetFinder()) {

      fRemoveNode->SetEnabled(kFALSE);

      fEditMatrix->SetEnabled(kFALSE);

      return;

   }

   Int_t i = fNodeList->GetSelected();

   if (i < 0)

      return;

   fVolume->RemoveNode(fVolume->GetNode(i));

   fNodeList->RemoveEntries(0, fNodeList->GetNumberOfEntries() + 1);

   TIter next(fVolume->GetNodes());

   TGeoNode *node;

   i = 0;

   while ((node = (TGeoNode *)next()))

      fNodeList->AddEntry(node->GetName(), i++);

   fNodeList->Select(0);

   fCopyNumber->SetNumber(fVolume->GetNdaughters() + 1);

   if (!fVolume->GetNdaughters()) {

      fRemoveNode->SetEnabled(kFALSE);

      fEditMatrix->SetEnabled(kFALSE);

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

      Double_t start = 0., step = 0., end = 0.;

      Int_t ndiv = 2, iaxis = 1;

      fSelectedShape->GetAxisRange(iaxis, start, end);

      step = end - start;

      fBDiv[iaxis - 1]->SetState(kButtonDown, kTRUE);

      fEDivFrom->SetNumber(start);

      fEDivStep->SetNumber(step);

      fEDivN->SetNumber(ndiv);

   }

   Update();

}


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

/// Slot for setting volume visible/invisible.


void TGeoVolumeEditor::DoVisVolume()

{

   Bool_t on = (fBVis[0]->GetState() == kButtonDown) ? kTRUE : kFALSE;

   if (fVolume->IsVisible() == on)

      return;

   fVolume->SetVisibility(on);

   Update();

}


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

/// Slot for setting daughters visible/invisible.


void TGeoVolumeEditor::DoVisDaughters()

{

   Bool_t on = (fBVis[1]->GetState() == kButtonDown) ? kTRUE : kFALSE;

   if (fVolume->IsVisibleDaughters() == on)

      return;

   fVolume->VisibleDaughters(on);

   Update();

}


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

/// Slot for setting visibility depth auto.


void TGeoVolumeEditor::DoVisAuto()

{

   Bool_t on = (fBAuto->GetState() == kButtonDown) ? kTRUE : kFALSE;

   if ((fGeometry->GetVisLevel() == 0) == on)

      return;

   if (on)

      fGeometry->SetVisLevel(0);

   else

      fGeometry->SetVisLevel(fEVisLevel->GetIntNumber());

   Update();

}


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

/// Slot for visibility level.


void TGeoVolumeEditor::DoVisLevel()

{

   fBAuto->SetState(kButtonUp);

   fGeometry->SetVisLevel(fEVisLevel->GetIntNumber());

   Update();

}


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

/// Slot for viewing volume and containers.


void TGeoVolumeEditor::DoViewAll()

{

   Bool_t on = (fBView[0]->GetState() == kButtonDown) ? kTRUE : kFALSE;

   if (!on)

      return;

   if (fVolume->IsVisContainers() == on)

      return;

   if (fVolume->IsRaytracing()) {

      fVolume->Raytrace(kFALSE);

      fBRaytrace->SetState(kButtonUp);

   }

   fVolume->SetVisContainers(on);

   Update();

}


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

/// Slot for viewing last leaves only.


void TGeoVolumeEditor::DoViewLeaves()

{

   Bool_t on = (fBView[1]->GetState() == kButtonDown) ? kTRUE : kFALSE;

   if (!on)

      return;

   if (fVolume->IsVisLeaves() == on)

      return;

   if (fVolume->IsRaytracing()) {

      fVolume->Raytrace(kFALSE);

      fBRaytrace->SetState(kButtonUp);

   }

   fVolume->SetVisLeaves(on);

   Update();

}


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

/// Slot for viewing volume only.


void TGeoVolumeEditor::DoViewOnly()

{

   Bool_t on = (fBView[2]->GetState() == kButtonDown) ? kTRUE : kFALSE;

   if (!on)

      return;

   if (fVolume->IsVisOnly() == on)

      return;

   if (fVolume->IsRaytracing()) {

      fVolume->Raytrace(kFALSE);

      fBRaytrace->SetState(kButtonUp);

   }

   fVolume->SetVisOnly(on);

   Update();

}


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

/// Slot for raytracing.


void TGeoVolumeEditor::DoRaytrace()

{

   Bool_t on = (fBRaytrace->GetState() == kButtonDown) ? kTRUE : kFALSE;

   if (fVolume->IsRaytracing() == on)

      return;

   fVolume->Raytrace(on);

   Update();

}


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

/// Modify division name.


void TGeoVolumeEditor::DoDivName()

{

   fApplyDiv->SetEnabled(kTRUE);

}


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

/// Change division axis and preserve number of slices.


void TGeoVolumeEditor::DoDivSelAxis()

{

   Int_t iaxis = 1;

   for (Int_t i = 0; i < 3; i++) {

      if (fBDiv[i]->GetState() != kButtonDown)

         continue;

      iaxis = i + 1;

      break;

   }

   TGeoShape *shape = fVolume->GetShape();

   if (!shape) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   Double_t xlo, xhi;

   shape->GetAxisRange(iaxis, xlo, xhi);

   if (xhi <= xlo) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   fEDivFrom->SetNumber(xlo);

   fEDivStep->SetNumber(0);

   fApplyDiv->SetEnabled(kTRUE);

}


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

/// Handle division range modification.


void TGeoVolumeEditor::DoDivFromTo()

{

   Double_t min, max, xlo, xhi, step;

   Int_t iaxis = 1;

   Int_t ndiv;

   for (Int_t i = 0; i < 3; i++) {

      if (fBDiv[i]->GetState() != kButtonDown)

         continue;

      iaxis = i + 1;

      break;

   }

   TGeoShape *shape = fVolume->GetShape();

   if (!shape) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   shape->GetAxisRange(iaxis, xlo, xhi);

   if (xhi - xlo <= 0) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   min = fEDivFrom->GetNumber();

   step = fEDivStep->GetNumber();

   ndiv = fEDivN->GetIntNumber();

   if (min < xlo) {

      min = xlo;

      fEDivFrom->SetNumber(xlo);

   }

   max = min + ndiv * step;

   if (max > xhi) {

      max = xhi;

      step = (max - min) / ndiv;

      fEDivStep->SetNumber(step);

   }

   if (min >= max) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   fApplyDiv->SetEnabled(kTRUE);

}


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

/// Handle division step modification.


void TGeoVolumeEditor::DoDivStep()

{

   Double_t min, max, xlo, xhi;

   Int_t iaxis = 1;

   for (Int_t i = 0; i < 3; i++) {

      if (fBDiv[i]->GetState() != kButtonDown)

         continue;

      iaxis = i + 1;

      break;

   }

   TGeoShape *shape = fVolume->GetShape();

   if (!shape) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   shape->GetAxisRange(iaxis, xlo, xhi);

   if (xhi - xlo <= 0) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   min = fEDivFrom->GetNumber();

   Double_t step = fEDivStep->GetNumber();

   Int_t ndiv = fEDivN->GetIntNumber();

   max = min + ndiv * step;


   // Check if ndiv*step < max-min

   if (max <= xhi) {

      fApplyDiv->SetEnabled(kTRUE);

      return;

   }

   // Step too big - set value to fit range

   max = xhi;

   step = (max - min) / ndiv;

   fEDivStep->SetNumber(step);

   if (step < 0) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   fApplyDiv->SetEnabled(kTRUE);

}


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

/// Handle division N modification.


void TGeoVolumeEditor::DoDivN()

{

   Double_t min, max, xlo, xhi;

   Int_t iaxis = 1;

   for (Int_t i = 0; i < 3; i++) {

      if (fBDiv[i]->GetState() != kButtonDown)

         continue;

      iaxis = i + 1;

      break;

   }

   TGeoShape *shape = fVolume->GetShape();

   if (!shape) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   shape->GetAxisRange(iaxis, xlo, xhi);

   if (xhi - xlo <= 0) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   Double_t step = fEDivStep->GetNumber();

   // If step=0 it is discounted

   if (step == 0) {

      fApplyDiv->SetEnabled(kTRUE);

      return;

   }

   Int_t ndiv = fEDivN->GetIntNumber();

   min = fEDivFrom->GetNumber();

   max = min + ndiv * step;

   // Check if ndiv*step < max-min

   if (max <= xhi) {

      fApplyDiv->SetEnabled(kTRUE);

      return;

   }

   max = xhi;

   ndiv = (Int_t)((max - min) / step);

   fEDivN->SetNumber(ndiv);

   fApplyDiv->SetEnabled(kTRUE);

}


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

/// Apply current division settings


void TGeoVolumeEditor::DoApplyDiv()

{

   Double_t xlo, xhi, step;

   Int_t iaxis = 1;

   Int_t ndiv;

   for (Int_t i = 0; i < 3; i++) {

      if (fBDiv[i]->GetState() != kButtonDown)

         continue;

      iaxis = i + 1;

      break;

   }

   TGeoShape *shape = fVolume->GetShape();

   if (!shape) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   shape->GetAxisRange(iaxis, xlo, xhi);

   if (xhi - xlo <= 0) {

      fApplyDiv->SetEnabled(kFALSE);

      return;

   }

   xlo = fEDivFrom->GetNumber();

   step = fEDivStep->GetNumber();

   ndiv = fEDivN->GetIntNumber();

   TGeoPatternFinder *finder = fVolume->GetFinder();

   if (finder) {

      // we have to remove first the existing division

      TObjArray *nodes = fVolume->GetNodes();

      nodes->Delete();

      nodes->Clear();

      delete finder;

      fVolume->SetFinder(nullptr);

   }

   fVolume->Divide(fDivName->GetText(), iaxis, ndiv, xlo, step);

   fApplyDiv->SetEnabled(kFALSE);

   fGeometry->SetTopVisible();

   Update();

   //   fVolume->Draw();

}


kRaisedFrame
@ kRaisedFrame
Definition GuiTypes.h:384

kSunkenFrame
@ kSunkenFrame
Definition GuiTypes.h:383

kVerticalFrame
@ kVerticalFrame
Definition GuiTypes.h:381

kDoubleBorder
@ kDoubleBorder
Definition GuiTypes.h:385

kFixedWidth
@ kFixedWidth
Definition GuiTypes.h:387

kHorizontalFrame
@ kHorizontalFrame
Definition GuiTypes.h:382

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

Int_t
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59

kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:108

kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:107

TRangeDynCast
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Definition TCollection.h:358

TG3DLine.h

TGButtonGroup.h

TGButton.h

kButtonDown
@ kButtonDown
Definition TGButton.h:54

kButtonUp
@ kButtonUp
Definition TGButton.h:53

gClient
#define gClient
Definition TGClient.h:157

TGComboBox.h

TGLabel.h

kLHintsRight
@ kLHintsRight
Definition TGLayout.h:26

kLHintsExpandY
@ kLHintsExpandY
Definition TGLayout.h:31

kLHintsLeft
@ kLHintsLeft
Definition TGLayout.h:24

kLHintsTop
@ kLHintsTop
Definition TGLayout.h:27

kLHintsExpandX
@ kLHintsExpandX
Definition TGLayout.h:30

TGNumberEntry.h

TGShutter.h

TGTab.h

TGTextEntry.h

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

on
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void on
Definition TGWin32VirtualXProxy.cxx:106

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

TGedEditor.h

ETGeoVolumeWid
ETGeoVolumeWid
Definition TGeoManagerEditor.cxx:87

kCAT_GENERAL
@ kCAT_GENERAL
Definition TGeoManagerEditor.cxx:108

TGeoManager.h

TGeoMatrix.h

TGeoPatternFinder.h

TGeoTabManager.h

kVOL_NODEID
@ kVOL_NODEID
Definition TGeoVolumeEditor.cxx:69

kVOL_DIVSTEP
@ kVOL_DIVSTEP
Definition TGeoVolumeEditor.cxx:76

kCAT_VIS
@ kCAT_VIS
Definition TGeoVolumeEditor.cxx:81

kVOL_DIVEND
@ kVOL_DIVEND
Definition TGeoVolumeEditor.cxx:75

kVOL_EDIT_SHAPE
@ kVOL_EDIT_SHAPE
Definition TGeoVolumeEditor.cxx:67

kVOL_EDIT_MEDIUM
@ kVOL_EDIT_MEDIUM
Definition TGeoVolumeEditor.cxx:68

kVOL_MATRIX_SELECT
@ kVOL_MATRIX_SELECT
Definition TGeoVolumeEditor.cxx:66

kVOL_NAME
@ kVOL_NAME
Definition TGeoVolumeEditor.cxx:60

kVOL_NODE_SELECT
@ kVOL_NODE_SELECT
Definition TGeoVolumeEditor.cxx:64

kVOL_UNDO
@ kVOL_UNDO
Definition TGeoVolumeEditor.cxx:72

kVOL_SHAPE_SELECT
@ kVOL_SHAPE_SELECT
Definition TGeoVolumeEditor.cxx:62

kVOL_VISLEVEL
@ kVOL_VISLEVEL
Definition TGeoVolumeEditor.cxx:73

kCAT_DIVISION
@ kCAT_DIVISION
Definition TGeoVolumeEditor.cxx:80

kVOL_APPLY
@ kVOL_APPLY
Definition TGeoVolumeEditor.cxx:70

kVOL_DIVSTART
@ kVOL_DIVSTART
Definition TGeoVolumeEditor.cxx:74

kVOL_MEDIA_SELECT
@ kVOL_MEDIA_SELECT
Definition TGeoVolumeEditor.cxx:63

kCAT_GENERAL
@ kCAT_GENERAL
Definition TGeoVolumeEditor.cxx:78

kVOL_CANCEL
@ kVOL_CANCEL
Definition TGeoVolumeEditor.cxx:71

kCAT_DAUGHTERS
@ kCAT_DAUGHTERS
Definition TGeoVolumeEditor.cxx:79

kDIV_NAME
@ kDIV_NAME
Definition TGeoVolumeEditor.cxx:82

kVOL_DIVN
@ kVOL_DIVN
Definition TGeoVolumeEditor.cxx:77

kVOL_VOL_SELECT
@ kVOL_VOL_SELECT
Definition TGeoVolumeEditor.cxx:65

kVOL_TITLE
@ kVOL_TITLE
Definition TGeoVolumeEditor.cxx:61

TGeoVolumeEditor.h

TGeoVolume.h

ROOT::Detail::TRangeCast
Definition TCollection.h:311

TAttFill::Class
static TClass * Class()

TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:84

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

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

TGButton::GetState
virtual EButtonState GetState() const
Definition TGButton.h:112

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

TGCheckButton
Selects different options.
Definition TGButton.h:264

TGCheckButton::SetState
void SetState(EButtonState state, Bool_t emit=kFALSE) override
Set check button state.
Definition TGButton.cxx:1244

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

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::RemoveEntries
virtual void RemoveEntries(Int_t from_ID, Int_t to_ID)
Definition TGComboBox.h:105

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

TGComboBox::GetNumberOfEntries
virtual Int_t GetNumberOfEntries() const
Definition TGComboBox.h:107

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

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

TGCompositeFrame::GetDefaultWidth
UInt_t GetDefaultWidth() const override
Definition TGFrame.h:314

TGCompositeFrame::GetState
Int_t GetState(TGFrame *f) const
Get state of sub frame.
Definition TGFrame.cxx:1210

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

TGCompositeFrame::GetDefaultHeight
UInt_t GetDefaultHeight() const override
Definition TGFrame.h:316

TGCompositeFrame::TGCompositeFrame
TGCompositeFrame(const TGCompositeFrame &)=delete

TGCompositeFrame::Layout
void Layout() override
Layout the elements of the composite frame.
Definition TGFrame.cxx:1249

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

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

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

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

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

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

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

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

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::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::SetState
void SetState(EButtonState state, Bool_t emit=kFALSE) override
Set radio button state.
Definition TGButton.cxx:1607

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

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

TGShutter::SetDefaultSize
virtual void SetDefaultSize(UInt_t w, UInt_t h)
Set the default / minimal size of the widget.
Definition TGShutter.cxx:330

TGShutter::Layout
void Layout() override
Layout shutter items.
Definition TGShutter.cxx:216

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

TGTextButton::SetText
virtual void SetText(TGHotString *new_label)
Set new button text.
Definition TGButton.cxx:638

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

TGTextEntry::SetDefaultSize
virtual void SetDefaultSize(UInt_t w, UInt_t h)
Set the default / minimal size of the widget.
Definition TGTextEntry.cxx:383

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

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

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

TGWindow::GetParent
const TGWindow * GetParent() const
Definition TGWindow.h:83

TGedEditor::ExcludeClassEditor
void ExcludeClassEditor(TClass *cl, Bool_t recurse=kFALSE)
Exclude editor for class cl from current construction.
Definition TGedEditor.cxx:573

TGedFrame::ActivateBaseClassEditors
virtual void ActivateBaseClassEditors(TClass *cl)
Provide list of editors for base-classes.
Definition TGedFrame.cxx:166

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

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

TGeoGedFrame
Common base class for geombuilder editors.
Definition TGeoGedFrame.h:13

TGeoGedFrame::Update
void Update() override
Override Update from TGedFrame as fGedEditor can be null.
Definition TGeoGedFrame.cxx:52

TGeoGedFrame::fTab
TGTab * fTab
Definition TGeoGedFrame.h:16

TGeoGedFrame::SetActive
virtual void SetActive(Bool_t active=kTRUE)
Set active GUI attribute frames related to the selected object.
Definition TGeoGedFrame.cxx:32

TGeoGedFrame::fTabMgr
TGeoTabManager * fTabMgr
Definition TGeoGedFrame.h:17

TGeoManager::SetVisLevel
void SetVisLevel(Int_t level=3)
set default level down to which visualization is performed
Definition TGeoManager.cxx:2462

TGeoManager::GetVisLevel
Int_t GetVisLevel() const
Returns current depth to which geometry is drawn.
Definition TGeoManager.cxx:2152

TGeoManager::SetTopVisible
void SetTopVisible(Bool_t vis=kTRUE)
make top volume visible on screen
Definition TGeoManager.cxx:2399

TGeoMatrixDialog
Definition TGeoTabManager.h:228

TGeoMatrix
Geometrical transformation package.
Definition TGeoMatrix.h:38

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

TGeoNode
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition TGeoNode.h:39

TGeoNode::GetVolume
TGeoVolume * GetVolume() const
Definition TGeoNode.h:99

TGeoNode::GetMatrix
virtual TGeoMatrix * GetMatrix() const =0

TGeoPatternFinder
base finder class for patterns. A pattern is specifying a division type
Definition TGeoPatternFinder.h:25

TGeoPatternFinder::GetDivAxis
virtual Int_t GetDivAxis()
Definition TGeoPatternFinder.h:74

TGeoPatternFinder::GetNdiv
Int_t GetNdiv() const
Definition TGeoPatternFinder.h:76

TGeoPatternFinder::GetStep
Double_t GetStep() const
Definition TGeoPatternFinder.h:80

TGeoPatternFinder::GetStart
Double_t GetStart() const
Definition TGeoPatternFinder.h:79

TGeoShapeDialog
Definition TGeoTabManager.h:153

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

TGeoShape::GetAxisRange
virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const =0

TGeoShape::GetAxisName
virtual const char * GetAxisName(Int_t iaxis) const =0

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

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

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

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

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

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

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

TGeoVolumeDialog
Definition TGeoTabManager.h:128

TGeoVolumeEditor::fIsModified
Bool_t fIsModified
Definition TGeoVolumeEditor.h:41

TGeoVolumeEditor::fBSelMatrix
TGPictureButton * fBSelMatrix
Definition TGeoVolumeEditor.h:57

TGeoVolumeEditor::ConnectSignals2Slots
virtual void ConnectSignals2Slots()
Connect signals to slots.
Definition TGeoVolumeEditor.cxx:418

TGeoVolumeEditor::fIsDivided
Bool_t fIsDivided
Definition TGeoVolumeEditor.h:43

TGeoVolumeEditor::fApplyDiv
TGTextButton * fApplyDiv
Definition TGeoVolumeEditor.h:70

TGeoVolumeEditor::DoApplyDiv
void DoApplyDiv()
Apply current division settings.
Definition TGeoVolumeEditor.cxx:983

TGeoVolumeEditor::fAddNode
TGTextButton * fAddNode
Definition TGeoVolumeEditor.h:59

TGeoVolumeEditor::fBSelShape
TGPictureButton * fBSelShape
Definition TGeoVolumeEditor.h:48

TGeoVolumeEditor::DoRemoveNode
void DoRemoveNode()
Remove a daughter.
Definition TGeoVolumeEditor.cxx:663

TGeoVolumeEditor::fVolumeName
TGTextEntry * fVolumeName
Definition TGeoVolumeEditor.h:45

TGeoVolumeEditor::fEDivFrom
TGNumberEntry * fEDivFrom
Definition TGeoVolumeEditor.h:73

TGeoVolumeEditor::DoSelectMatrix
void DoSelectMatrix()
Select a matrix for positioning.
Definition TGeoVolumeEditor.cxx:582

TGeoVolumeEditor::DoEditMatrix
void DoEditMatrix()
Edit the position of the selected node.
Definition TGeoVolumeEditor.cxx:628

TGeoVolumeEditor::DoSelectMedium
void DoSelectMedium()
Select a new medium.
Definition TGeoVolumeEditor.cxx:568

TGeoVolumeEditor::fNodeList
TGComboBox * fNodeList
Definition TGeoVolumeEditor.h:62

TGeoVolumeEditor::DoVisDaughters
void DoVisDaughters()
Slot for setting daughters visible/invisible.
Definition TGeoVolumeEditor.cxx:713

TGeoVolumeEditor::fEVisLevel
TGNumberEntry * fEVisLevel
Definition TGeoVolumeEditor.h:69

TGeoVolumeEditor::fEditMatrix
TGTextButton * fEditMatrix
Definition TGeoVolumeEditor.h:63

TGeoVolumeEditor::fEDivN
TGNumberEntry * fEDivN
Definition TGeoVolumeEditor.h:75

TGeoVolumeEditor::fLSelMatrix
TGLabel * fLSelMatrix
Definition TGeoVolumeEditor.h:56

TGeoVolumeEditor::fVolume
TGeoVolume * fVolume
Definition TGeoVolumeEditor.h:40

TGeoVolumeEditor::fEditShape
TGTextButton * fEditShape
Definition TGeoVolumeEditor.h:60

TGeoVolumeEditor::fSelectedMedium
TGeoMedium * fSelectedMedium
Definition TGeoVolumeEditor.h:49

TGeoVolumeEditor::fSelectedVolume
TGeoVolume * fSelectedVolume
Definition TGeoVolumeEditor.h:52

TGeoVolumeEditor::fBView
TGRadioButton * fBView[3]
Definition TGeoVolumeEditor.h:66

TGeoVolumeEditor::DoVisVolume
void DoVisVolume()
Slot for setting volume visible/invisible.
Definition TGeoVolumeEditor.cxx:701

TGeoVolumeEditor::fSelectedShape
TGeoShape * fSelectedShape
Definition TGeoVolumeEditor.h:46

TGeoVolumeEditor::~TGeoVolumeEditor
~TGeoVolumeEditor() override
Destructor.
Definition TGeoVolumeEditor.cxx:390

TGeoVolumeEditor::DoDivFromTo
void DoDivFromTo()
Handle division range modification.
Definition TGeoVolumeEditor.cxx:852

TGeoVolumeEditor::DoVisAuto
void DoVisAuto()
Slot for setting visibility depth auto.
Definition TGeoVolumeEditor.cxx:725

TGeoVolumeEditor::DoViewLeaves
void DoViewLeaves()
Slot for viewing last leaves only.
Definition TGeoVolumeEditor.cxx:768

TGeoVolumeEditor::DoViewOnly
void DoViewOnly()
Slot for viewing volume only.
Definition TGeoVolumeEditor.cxx:786

TGeoVolumeEditor::fBVis
TGCheckButton * fBVis[2]
Definition TGeoVolumeEditor.h:65

TGeoVolumeEditor::fEDivStep
TGNumberEntry * fEDivStep
Definition TGeoVolumeEditor.h:74

TGeoVolumeEditor::fRemoveNode
TGTextButton * fRemoveNode
Definition TGeoVolumeEditor.h:64

TGeoVolumeEditor::DoDivStep
void DoDivStep()
Handle division step modification.
Definition TGeoVolumeEditor.cxx:896

TGeoVolumeEditor::DoVisLevel
void DoVisLevel()
Slot for visibility level.
Definition TGeoVolumeEditor.cxx:740

TGeoVolumeEditor::fSelectedMatrix
TGeoMatrix * fSelectedMatrix
Definition TGeoVolumeEditor.h:55

TGeoVolumeEditor::DoRaytrace
void DoRaytrace()
Slot for raytracing.
Definition TGeoVolumeEditor.cxx:804

TGeoVolumeEditor::DoSelectVolume
void DoSelectVolume()
Select a daughter volume.
Definition TGeoVolumeEditor.cxx:596

TGeoVolumeEditor::DoEditShape
void DoEditShape()
Edit the shape of the volume.
Definition TGeoVolumeEditor.cxx:612

TGeoVolumeEditor::fIsAssembly
Bool_t fIsAssembly
Definition TGeoVolumeEditor.h:42

TGeoVolumeEditor::fDivName
TGTextEntry * fDivName
Definition TGeoVolumeEditor.h:71

TGeoVolumeEditor::fLSelMedium
TGLabel * fLSelMedium
Definition TGeoVolumeEditor.h:50

TGeoVolumeEditor::fBRaytrace
TGCheckButton * fBRaytrace
Definition TGeoVolumeEditor.h:67

TGeoVolumeEditor::fLSelShape
TGLabel * fLSelShape
Definition TGeoVolumeEditor.h:47

TGeoVolumeEditor::fLSelVolume
TGLabel * fLSelVolume
Definition TGeoVolumeEditor.h:53

TGeoVolumeEditor::fCopyNumber
TGNumberEntry * fCopyNumber
Definition TGeoVolumeEditor.h:58

TGeoVolumeEditor::fBSelVolume
TGPictureButton * fBSelVolume
Definition TGeoVolumeEditor.h:54

TGeoVolumeEditor::fBAuto
TGCheckButton * fBAuto
Definition TGeoVolumeEditor.h:68

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

TGeoVolumeEditor::DoEditMedium
void DoEditMedium()
Edit the medium of the volume.
Definition TGeoVolumeEditor.cxx:620

TGeoVolumeEditor::SetModel
void SetModel(TObject *obj) override
Connect to the picked volume.
Definition TGeoVolumeEditor.cxx:451

TGeoVolumeEditor::fEditMedium
TGTextButton * fEditMedium
Definition TGeoVolumeEditor.h:61

TGeoVolumeEditor::fBSelMedium
TGPictureButton * fBSelMedium
Definition TGeoVolumeEditor.h:51

TGeoVolumeEditor::DoDivN
void DoDivN()
Handle division N modification.
Definition TGeoVolumeEditor.cxx:940

TGeoVolumeEditor::ActivateBaseClassEditors
void ActivateBaseClassEditors(TClass *cl) override
Add editors to fGedFrame and exclude TLineEditor.
Definition TGeoVolumeEditor.cxx:537

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

TGeoVolumeEditor::DoSelectShape
void DoSelectShape()
Select a new shape.
Definition TGeoVolumeEditor.cxx:554

TGeoVolumeEditor::DoViewAll
void DoViewAll()
Slot for viewing volume and containers.
Definition TGeoVolumeEditor.cxx:750

TGeoVolumeEditor::DoAddNode
void DoAddNode()
Add a daughter.
Definition TGeoVolumeEditor.cxx:641

TGeoVolumeEditor::fBDiv
TGRadioButton * fBDiv[3]
Definition TGeoVolumeEditor.h:72

TGeoVolumeEditor::DoDivSelAxis
void DoDivSelAxis()
Change division axis and preserve number of slices.
Definition TGeoVolumeEditor.cxx:824

TGeoVolumeEditor::DoDivName
void DoDivName()
Modify division name.
Definition TGeoVolumeEditor.cxx:816

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

TGeoVolumeEditor::DoVolumeName
void DoVolumeName()
Modify volume name.
Definition TGeoVolumeEditor.cxx:546

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

TGeoVolume::SetVisContainers
void SetVisContainers(Bool_t flag=kTRUE) override
Set visibility for containers.
Definition TGeoVolume.cxx:2365

TGeoVolume::SetVisibility
void SetVisibility(Bool_t vis=kTRUE) override
set visibility of this volume
Definition TGeoVolume.cxx:2347

TGeoVolume::IsVisContainers
Bool_t IsVisContainers() const
Definition TGeoVolume.h:157

TGeoVolume::RemoveNode
void RemoveNode(TGeoNode *node)
Remove an existing daughter.
Definition TGeoVolume.cxx:2251

TGeoVolume::Raytrace
void Raytrace(Bool_t flag=kTRUE)
Draw this volume with current settings and perform raytracing in the pad.
Definition TGeoVolume.cxx:1427

TGeoVolume::GetMedium
TGeoMedium * GetMedium() const
Definition TGeoVolume.h:175

TGeoVolume::GetGeoManager
TGeoManager * GetGeoManager() const
Definition TGeoVolume.h:173

TGeoVolume::AddNode
virtual TGeoNode * AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=nullptr, Option_t *option="")
Add a TGeoNode to the list of nodes.
Definition TGeoVolume.cxx:975

TGeoVolume::SetVisOnly
void SetVisOnly(Bool_t flag=kTRUE) override
Set visibility for leaves.
Definition TGeoVolume.cxx:2393

TGeoVolume::SetFinder
void SetFinder(TGeoPatternFinder *finder)
Definition TGeoVolume.h:244

TGeoVolume::GetNdaughters
Int_t GetNdaughters() const
Definition TGeoVolume.h:362

TGeoVolume::Class
static TClass * Class()

TGeoVolume::GetNodes
TObjArray * GetNodes()
Definition TGeoVolume.h:169

TGeoVolume::VisibleDaughters
void VisibleDaughters(Bool_t vis=kTRUE)
set visibility for daughters
Definition TGeoVolume.cxx:2453

TGeoVolume::GetNode
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
Definition TGeoVolume.cxx:2193

TGeoVolume::IsVisibleDaughters
Bool_t IsVisibleDaughters() const
Definition TGeoVolume.h:156

TGeoVolume::GetFinder
TGeoPatternFinder * GetFinder() const
Definition TGeoVolume.h:177

TGeoVolume::GetShape
TGeoShape * GetShape() const
Definition TGeoVolume.h:190

TGeoVolume::Divide
virtual TGeoVolume * Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="")
Division a la G3.
Definition TGeoVolume.cxx:1103

TGeoVolume::IsRaytracing
Bool_t IsRaytracing() const
Check if the painter is currently ray-tracing the content of this volume.
Definition TGeoVolume.cxx:857

TGeoVolume::IsVisLeaves
Bool_t IsVisLeaves() const
Definition TGeoVolume.h:158

TGeoVolume::IsVisOnly
Bool_t IsVisOnly() const
Definition TGeoVolume.h:159

TGeoVolume::IsAssembly
virtual Bool_t IsAssembly() const
Returns true if the volume is an assembly or a scaled assembly.
Definition TGeoVolume.cxx:1822

TGeoVolume::IsVisible
virtual Bool_t IsVisible() const
Definition TGeoVolume.h:155

TGeoVolume::SetVisLeaves
void SetVisLeaves(Bool_t flag=kTRUE) override
Set visibility for leaves.
Definition TGeoVolume.cxx:2379

TIter
Definition TCollection.h:235

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

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

TObjArray
An array of TObjects.
Definition TObjArray.h:31

TObjArray::Clear
void Clear(Option_t *option="") override
Remove all objects from the array.
Definition TObjArray.cxx:320

TObjArray::Delete
void Delete(Option_t *option="") override
Remove all objects from the array AND delete all heap based objects.
Definition TObjArray.cxx:355

TObject
Mother of all ROOT objects.
Definition TObject.h:41

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

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

TString
Basic string class.
Definition TString.h:138

bool

double

int

unsigned int

f1
TF1 * f1
Definition legend1.C:11