TGeoHypeEditor.cxx

Go to the documentation of this file.

// @(#):$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 TGeoHypeEditor
\ingroup Geometry_builder

Editor for a TGeoHype.

\image html geom_hype_pic.png

\image html geom_hype_ed.png

*/

#include "TGeoHypeEditor.h"
#include "TGeoTabManager.h"
#include "TGeoHype.h"
#include "TGeoManager.h"
#include "TVirtualGeoPainter.h"
#include "TPad.h"
#include "TView.h"
#include "TMath.h"
#include "TGTab.h"
#include "TGComboBox.h"
#include "TGButton.h"
#include "TGTextEntry.h"
#include "TGNumberEntry.h"
#include "TGLabel.h"

ClassImp(TGeoHypeEditor);

enum ETGeoHypeWid {
   kHYPE_NAME, kHYPE_RIN, kHYPE_ROUT,  kHYPE_DZ, kHYPE_STIN,
   kHYPE_STOUT, kHYPE_APPLY, kHYPE_UNDO
};

////////////////////////////////////////////////////////////////////////////////
/// Constructor for Hype editor

TGeoHypeEditor::TGeoHypeEditor(const TGWindow *p, Int_t width,
                                   Int_t height, UInt_t options, Pixel_t back)
   : TGeoGedFrame(p, width, height, options | kVerticalFrame, back)
{
   fShape   = 0;
   fRini = fRouti = fStIni = fStOuti = 0.0;
   fNamei = "";
   fIsModified = kFALSE;
   fIsShapeEditable = kTRUE;

   // TextEntry for shape name
   MakeTitle("Name");
   fShapeName = new TGTextEntry(this, new TGTextBuffer(50), kHYPE_NAME);
   fShapeName->Resize(135, fShapeName->GetDefaultHeight());
   fShapeName->SetToolTipText("Enter the hyperboloid name");
   fShapeName->Associate(this);
   AddFrame(fShapeName, new TGLayoutHints(kLHintsLeft, 3, 1, 2, 5));

   TGTextEntry *nef;
   MakeTitle("Dimensions");
   // Number entry for Rin
   TGCompositeFrame *f1 = new TGCompositeFrame(this, 155, 10, kHorizontalFrame | kFixedWidth);
   f1->AddFrame(new TGLabel(f1, "Rin"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
   fERin = new TGNumberEntry(f1, 0., 5, kHYPE_RIN);
   fERin->SetNumAttr(TGNumberFormat::kNEAPositive);
   fERin->Resize(100, fERin->GetDefaultHeight());
   nef = (TGTextEntry*)fERin->GetNumberEntry();
   nef->SetToolTipText("Enter the  inner radius ");
   fERin->Associate(this);
   f1->AddFrame(fERin, new TGLayoutHints(kLHintsRight, 2, 2, 4, 4));
   AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 4));

   // Number entry for Rout
   f1 = new TGCompositeFrame(this, 155, 10, kHorizontalFrame | kFixedWidth);
   f1->AddFrame(new TGLabel(f1, "Rout"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
   fERout = new TGNumberEntry(f1, 0., 5, kHYPE_ROUT);
   fERout->SetNumAttr(TGNumberFormat::kNEAPositive);
   fERout->Resize(100, fERout->GetDefaultHeight());
   nef = (TGTextEntry*)fERout->GetNumberEntry();
   nef->SetToolTipText("Enter the outer radius");
   fERout->Associate(this);
   f1->AddFrame(fERout, new TGLayoutHints(kLHintsRight, 2, 2, 4, 4));
   AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 4));

   // Number entry for Dz
   f1 = new TGCompositeFrame(this, 155, 10, kHorizontalFrame | kFixedWidth);
   f1->AddFrame(new TGLabel(f1, "Dz"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
   fEDz = new TGNumberEntry(f1, 0., 5, kHYPE_DZ);
   fEDz->SetNumAttr(TGNumberFormat::kNEAPositive);
   fEDz->Resize(100, fEDz->GetDefaultHeight());
   nef = (TGTextEntry*)fEDz->GetNumberEntry();
   nef->SetToolTipText("Enter the half-length in Dz");
   fEDz->Associate(this);
   f1->AddFrame(fEDz, new TGLayoutHints(kLHintsRight, 2, 2, 4, 4));
   AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 4));

   // Number entry for StIn.
   f1 = new TGCompositeFrame(this, 155, 10, kHorizontalFrame | kFixedWidth);
   f1->AddFrame(new TGLabel(f1, "StIn"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
   fEStIn = new TGNumberEntry(f1, 0., 5, kHYPE_STIN);
   fEStIn->Resize(100, fEStIn->GetDefaultHeight());
   nef = (TGTextEntry*)fEStIn->GetNumberEntry();
   nef->SetToolTipText("Enter the stereo angle for inner surface");
   fEStIn->Associate(this);
   f1->AddFrame(fEStIn, new TGLayoutHints(kLHintsRight, 2, 2, 4, 4));
   AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 4));

   // Number entry for StOut.
   f1 = new TGCompositeFrame(this, 155, 10, kHorizontalFrame | kFixedWidth);
   f1->AddFrame(new TGLabel(f1, "StOut"), new TGLayoutHints(kLHintsLeft, 1, 1, 6, 0));
   fEStOut = new TGNumberEntry(f1, 0., 5, kHYPE_STOUT);
   fEStOut->SetNumAttr(TGNumberFormat::kNEAPositive);
   fEStOut->Resize(100, fEStOut->GetDefaultHeight());
   nef = (TGTextEntry*)fEStOut->GetNumberEntry();
   nef->SetToolTipText("Enter the stereo angle for outer surface");
   fEStOut->Associate(this);
   f1->AddFrame(fEStOut, new TGLayoutHints(kLHintsRight, 2, 2, 4, 4));
   AddFrame(f1, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 4));

   // Delayed draw
   f1 = new TGCompositeFrame(this, 155, 10, kHorizontalFrame | kFixedWidth | kSunkenFrame);
   fDelayed = new TGCheckButton(f1, "Delayed draw");
   f1->AddFrame(fDelayed, new TGLayoutHints(kLHintsLeft , 2, 2, 4, 4));
   AddFrame(f1,  new TGLayoutHints(kLHintsLeft, 6, 6, 4, 4));

   // Buttons
   f1 = new TGCompositeFrame(this, 155, 10, kHorizontalFrame | kFixedWidth);
   fApply = new TGTextButton(f1, "Apply");
   f1->AddFrame(fApply, new TGLayoutHints(kLHintsLeft, 2, 2, 4, 4));
   fApply->Associate(this);
   fUndo = new TGTextButton(f1, "Undo");
   f1->AddFrame(fUndo, new TGLayoutHints(kLHintsRight , 2, 2, 4, 4));
   fUndo->Associate(this);
   AddFrame(f1,  new TGLayoutHints(kLHintsLeft, 6, 6, 4, 4));
   fUndo->SetSize(fApply->GetSize());
}

////////////////////////////////////////////////////////////////////////////////
/// Destructor

TGeoHypeEditor::~TGeoHypeEditor()
{
   TGFrameElement *el;
   TIter next(GetList());
   while ((el = (TGFrameElement *)next())) {
      if (el->fFrame->IsComposite())
         TGeoTabManager::Cleanup((TGCompositeFrame*)el->fFrame);
   }
   Cleanup();
}

////////////////////////////////////////////////////////////////////////////////
/// Connect signals to slots.

void TGeoHypeEditor::ConnectSignals2Slots()
{
   fApply->Connect("Clicked()", "TGeoHypeEditor", this, "DoApply()");
   fUndo->Connect("Clicked()", "TGeoHypeEditor", this, "DoUndo()");
   fShapeName->Connect("TextChanged(const char *)", "TGeoHypeEditor", this, "DoModified()");
   fERin->Connect("ValueSet(Long_t)", "TGeoHypeEditor", this, "DoRin()");
   fERout->Connect("ValueSet(Long_t)", "TGeoHypeEditor", this, "DoRout()");
   fEDz->Connect("ValueSet(Long_t)", "TGeoHypeEditor", this, "DoDz()");
   fEStIn->Connect("ValueSet(Long_t)", "TGeoHypeEditor", this, "DoStIn()");
   fEStOut->Connect("ValueSet(Long_t)", "TGeoHypeEditor", this, "DoStOut()");
   fERin->GetNumberEntry()->Connect("TextChanged(const char *)", "TGeoHypeEditor", this, "DoModified()");
   fERout->GetNumberEntry()->Connect("TextChanged(const char *)", "TGeoHypeEditor", this, "DoModified()");
   fEDz->GetNumberEntry()->Connect("TextChanged(const char *)", "TGeoHypeEditor", this, "DoModified()");
   fEStIn->GetNumberEntry()->Connect("TextChanged(const char *)", "TGeoHypeEditor", this, "DoModified()");
   fEStOut->GetNumberEntry()->Connect("TextChanged(const char *)", "TGeoHypeEditor", this, "DoModified()");
   fInit = kFALSE;
}


////////////////////////////////////////////////////////////////////////////////
/// Connect to the selected object.

void TGeoHypeEditor::SetModel(TObject* obj)
{
   if (obj == 0 || (obj->IsA()!=TGeoHype::Class())) {
      SetActive(kFALSE);
      return;
   }
   fShape = (TGeoHype*)obj;
   fRini = fShape->GetRmin();
   fRouti = fShape->GetRmax();
   fDzi = fShape->GetDz();
   fStIni = fShape->GetStIn();
   fStOuti = fShape->GetStOut();
   const char *sname = fShape->GetName();
   if (!strcmp(sname, fShape->ClassName())) fShapeName->SetText("-no_name");
   else {
      fShapeName->SetText(sname);
      fNamei = sname;
   }
   fERin->SetNumber(fRini);
   fERout->SetNumber(fRouti);
   fEDz->SetNumber(fDzi);
   fEStIn->SetNumber(fStIni);
   fEStOut->SetNumber(fStOuti);
   fApply->SetEnabled(kFALSE);
   fUndo->SetEnabled(kFALSE);

   if (fInit) ConnectSignals2Slots();
   SetActive();
}

////////////////////////////////////////////////////////////////////////////////
/// Check if shape drawing is delayed.

Bool_t TGeoHypeEditor::IsDelayed() const
{
   return (fDelayed->GetState() == kButtonDown);
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for name.

void TGeoHypeEditor::DoName()
{
   DoModified();
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for applying current settings.

void TGeoHypeEditor::DoApply()
{
   const char *name = fShapeName->GetText();
   if (strcmp(name,fShape->GetName())) fShape->SetName(name);
   Double_t rin = fERin->GetNumber();
   Double_t rout = fERout->GetNumber();
   Double_t dz = fEDz->GetNumber();
   Double_t stin = fEStIn->GetNumber();
   Double_t stout = fEStOut->GetNumber();
   Double_t tin = TMath::Tan(stin*TMath::DegToRad());
   Double_t tout = TMath::Tan(stout*TMath::DegToRad());
   if ((dz<=0) || (rin<0) || (rin>rout) ||
       (rin*rin+tin*tin*dz*dz > rout*rout+tout*tout*dz*dz)) {
      fUndo->SetEnabled();
      fApply->SetEnabled(kFALSE);
      return;
   }
   Double_t param[5];
   param[0] = dz;
   param[1] = rin;
   param[2] = stin;
   param[3] = rout;
   param[4] = stout;
   fShape->SetDimensions(param);
   fShape->ComputeBBox();
   fUndo->SetEnabled();
   fApply->SetEnabled(kFALSE);
   if (fPad) {
      if (gGeoManager && gGeoManager->GetPainter() && gGeoManager->GetPainter()->IsPaintingShape()) {
         TView *view = fPad->GetView();
         if (!view) {
            fShape->Draw();
            fPad->GetView()->ShowAxis();
         } else {
            view->SetRange(-fShape->GetDX(), -fShape->GetDY(), -fShape->GetDZ(),
                           fShape->GetDX(), fShape->GetDY(), fShape->GetDZ());
            Update();
         }
      } else Update();
   }
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for notifying modifications.

void TGeoHypeEditor::DoModified()
{
   fApply->SetEnabled();
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for undoing last operation.

void TGeoHypeEditor::DoUndo()
{
   fERin->SetNumber(fRini);
   fERout->SetNumber(fRouti);
   fEDz->SetNumber(fDzi);
   fEStIn->SetNumber(fStIni);
   fEStOut->SetNumber(fStOuti);
   DoApply();
   fUndo->SetEnabled(kFALSE);
   fApply->SetEnabled(kFALSE);
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for Rin.

void TGeoHypeEditor::DoRin()
{
   Double_t rin = fERin->GetNumber();
   Double_t rout = fERout->GetNumber();
   Double_t dz = fEDz->GetNumber();
   Double_t stin = fEStIn->GetNumber();
   Double_t stout = fEStOut->GetNumber();
   Double_t tin = TMath::Tan(stin*TMath::DegToRad());
   Double_t tout = TMath::Tan(stout*TMath::DegToRad());
   if (rin<0) {
      rin = 0;
      fERin->SetNumber(rin);
   }
   Double_t rinmax = TMath::Sqrt((rout*rout+tout*tout*dz*dz)/(tin*tin*dz*dz));
   rinmax = TMath::Min(rinmax, rout);
   if (rin > rinmax) {
      rin = rinmax-1.e-6;
      fERin->SetNumber(rin);
   }
   DoModified();
   if (!IsDelayed()) DoApply();
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for Rout.

void TGeoHypeEditor::DoRout()
{
   Double_t rin = fERin->GetNumber();
   Double_t rout = fERout->GetNumber();
   Double_t dz = fEDz->GetNumber();
   Double_t stin = fEStIn->GetNumber();
   Double_t stout = fEStOut->GetNumber();
   Double_t tin = TMath::Tan(stin*TMath::DegToRad());
   Double_t tout = TMath::Tan(stout*TMath::DegToRad());
   Double_t routmin = TMath::Sqrt((rin*rin+tin*tin*dz*dz)/(tout*tout*dz*dz));
   routmin = TMath::Max(routmin,rin);
   if (rout < routmin) {
      rout = routmin+1.e-6;
      fERout->SetNumber(rout);
   }
   DoModified();
   if (!IsDelayed()) DoApply();
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for Z.

void TGeoHypeEditor::DoDz()
{
   Double_t rin = fERin->GetNumber();
   Double_t rout = fERout->GetNumber();
   Double_t dz = fEDz->GetNumber();
   Double_t stin = fEStIn->GetNumber();
   Double_t stout = fEStOut->GetNumber();
   if (TMath::Abs(stin-stout)<1.e-6) {
      stin = stout+1.;
      fEStIn->SetNumber(stin);
   }
   Double_t tin = TMath::Tan(stin*TMath::DegToRad());
   Double_t tout = TMath::Tan(stout*TMath::DegToRad());
   if (dz<=0) {
      dz = 0.1;
      fEDz->SetNumber(dz);
   }
   Double_t dzmax = TMath::Sqrt((rout*rout-rin*rin)/(tin*tin-tout*tout));
   if (dz>dzmax) {
      dz = dzmax;
      fEDz->SetNumber(dz);
   }
   DoModified();
   if (!IsDelayed()) DoApply();
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for StIn.

void TGeoHypeEditor::DoStIn()
{
   Double_t rin = fERin->GetNumber();
   Double_t rout = fERout->GetNumber();
   Double_t dz = fEDz->GetNumber();
   Double_t stin = fEStIn->GetNumber();
   Double_t stout = fEStOut->GetNumber();
   if (stin >= 90) {
      stin = 89.;
      fEStIn->SetNumber(stin);
   }
   Double_t tin = TMath::Tan(stin*TMath::DegToRad());
   Double_t tout = TMath::Tan(stout*TMath::DegToRad());
   Double_t tinmax = TMath::Sqrt(tout*tout+(rout*rout-rin*rin)/(dz*dz));
   if (tin>tinmax) {
      tin = tinmax-1.e-6;
      stin = TMath::RadToDeg()*TMath::ATan(tin);
      fEStIn->SetNumber(stin);
   }
   DoModified();
   if (!IsDelayed()) DoApply();
}

////////////////////////////////////////////////////////////////////////////////
/// Slot for StOut.

void TGeoHypeEditor::DoStOut()
{
   Double_t rin = fERin->GetNumber();
   Double_t rout = fERout->GetNumber();
   Double_t dz = fEDz->GetNumber();
   Double_t stin = fEStIn->GetNumber();
   Double_t stout = fEStOut->GetNumber();
   if (stout > 90) {
      stout = 89;
      fEStOut->SetNumber(stout);
   }
   Double_t tin = TMath::Tan(stin*TMath::DegToRad());
   Double_t tout = TMath::Tan(stout*TMath::DegToRad());
   Double_t tinmin = TMath::Sqrt((rout*rout-rin*rin)/(dz*dz));
   if (tin < tinmin) {
      tin = tinmin;
      stin = TMath::RadToDeg()*TMath::ATan(tin);
      fEStIn->SetNumber(stin);
   }
   Double_t toutmin = TMath::Sqrt(tin*tin -tinmin*tinmin);
   if (tout < toutmin) {
      tout = toutmin+1.e-6;
      stout = TMath::RadToDeg()*TMath::ATan(tout);
      fEStOut->SetNumber(stout);
   }
   DoModified();
   if (!IsDelayed()) DoApply();
}