-2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
-
- * TPCLoaderEditor.cxx:
- * TPCLoaderEditor.h:
- * TPCSector2DEditor.cxx:
- * TPCSector2DEditor.h:
- * TPCSector3DEditor.cxx:
- * TPCSector3DEditor.h:
- * TPCSectorVizEditor.cxx:
- * TPCSectorVizEditor.h:
- Conform to new TGedFrame paradigm in ROOT.
-
2006-09-06 Matevz Tadel <matevz.tadel@cern.ch>
* MUONDigitsInfo.cxx:
ClassImp(TPCLoaderEditor)
-TPCLoaderEditor::TPCLoaderEditor(const TGWindow *p,
+TPCLoaderEditor::TPCLoaderEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fM (0),
"Alieve::TPCLoaderEditor", this, "DoDeleteSectors3D()");
AddFrame(f, new TGLayoutHints(kLHintsExpandX, 8,8,8,0));
}
+
+ // Register the editor.
+ TClass *cl = TPCLoader::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
TPCLoaderEditor::~TPCLoaderEditor()
/**************************************************************************/
-void TPCLoaderEditor::SetModel(TObject* obj)
+void TPCLoaderEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t /*event*/)
{
- fM = dynamic_cast<TPCLoader*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(TPCLoader::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fM = dynamic_cast<TPCLoader*>(fModel);
// !!!! order changed, need TGTextEntry::SetText NO BLOODY EMIT.
fFile->SetToolTipText(gSystem->DirName(fM->fFile));
fEvent->SetValue(fM->fEvent);
fEvent->SetEnabled(fM->fEvent >= 0);
fDoubleSR->SetState(fM->fDoubleSR ? kButtonDown : kButtonUp);
+
+ SetActive();
}
/**************************************************************************/
void TPCLoaderEditor::DoOpen()
{
fM->OpenFile();
- SetModel(fM);
+ SetModel(fPad, fModel, 0);
}
/**************************************************************************/
void TPCLoaderEditor::DoEvent()
{
fM->GotoEvent((Int_t) fEvent->GetValue());
- SetModel(fM);
+ SetModel(fPad, fModel, 0);
}
void TPCLoaderEditor::DoDoubleSR()
TGTextButton* fDeleteSectors3D;
public:
- TPCLoaderEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ TPCLoaderEditor(const TGWindow* p=0, Int_t id=-1, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
~TPCLoaderEditor();
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void FileSelect();
void FileChanged();
ClassImp(TPCSector2DEditor)
-TPCSector2DEditor::TPCSector2DEditor(const TGWindow *p,
+TPCSector2DEditor::TPCSector2DEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fM(0),
fShowMax(0), fAverage(0), fUseTexture(0)
{
fAverage->Connect("Toggled(Bool_t)","Alieve::TPCSector2DEditor", this, "DoAverage()");
AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
}
+
+ // Register the editor.
+ TClass *cl = TPCSector2DEditor::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
TPCSector2DEditor::~TPCSector2DEditor()
/**************************************************************************/
-void TPCSector2DEditor::SetModel(TObject* obj)
+void TPCSector2DEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
{
- fM = dynamic_cast<TPCSector2D*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(TPCSector2D::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fM = dynamic_cast<TPCSector2D*>(fModel);
fShowMax->SetState(fM->fShowMax ? kButtonDown : kButtonUp);
SetupAverage();
fUseTexture->SetState(fM->fUseTexture ? kButtonDown : kButtonUp);
+
+ SetActive();
}
/**************************************************************************/
TGCheckButton* fUseTexture;
public:
- TPCSector2DEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ TPCSector2DEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
~TPCSector2DEditor();
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoShowMax();
void DoAverage();
ClassImp(TPCSector3DEditor)
-TPCSector3DEditor::TPCSector3DEditor(const TGWindow *p,
+TPCSector3DEditor::TPCSector3DEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fM(0),
fRnrFrame(0), fDriftVel(0), fPointFrac(0), fPointSize(0)
{
fPointSize->Connect("ValueSet(Double_t)",
"Alieve::TPCSector3DEditor", this, "DoPointSize()");
AddFrame(fPointSize, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
+
+ // Register the editor.
+ TClass *cl = TPCSector3D::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
TPCSector3DEditor::~TPCSector3DEditor()
/**************************************************************************/
-void TPCSector3DEditor::SetModel(TObject* obj)
+void TPCSector3DEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t /*event*/)
{
- fM = dynamic_cast<TPCSector3D*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(TPCSector3D::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fM = dynamic_cast<TPCSector3D*>(fModel);
fRnrFrame->SetState(fM->fRnrFrame ? kButtonDown : kButtonUp);
fDriftVel->SetValue(fM->fDriftVel);
fPointFrac->SetValue(fM->fPointFrac);
fPointSize->SetValue(fM->fPointSize);
+
+ SetActive();
}
/**************************************************************************/
Reve::RGValuator* fPointSize;
public:
- TPCSector3DEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
+ TPCSector3DEditor(const TGWindow* p, Int_t id, Int_t width=170, Int_t height=30,
UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
virtual ~TPCSector3DEditor();
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoRnrFrame();
void DoDriftVel();
ClassImp(TPCSectorVizEditor)
-TPCSectorVizEditor::TPCSectorVizEditor(const TGWindow *p,
+TPCSectorVizEditor::TPCSectorVizEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fM(0),
fSectorID (0), fTrans (0),
fRnrInn (0), fRnrOut1 (0), fRnrOut2(0),
fTime->Connect("ValueSet()",
"Alieve::TPCSectorVizEditor", this, "DoTime()");
AddFrame(fTime, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
+
+
+ // Register the editor.
+ TClass *cl = TPCSectorViz::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
TPCSectorVizEditor::~TPCSectorVizEditor()
/**************************************************************************/
-void TPCSectorVizEditor::SetModel(TObject* obj)
+void TPCSectorVizEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t /*event*/)
{
- fM = dynamic_cast<TPCSectorViz*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(TPCSectorViz::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fM = dynamic_cast<TPCSectorViz*>(fModel);
fSectorID->SetValue(fM->fSectorID);
fTrans->SetState(fM->fTrans ? kButtonDown : kButtonUp);
fMaxVal->SetValue(fM->fMaxVal);
fTime->SetValues(fM->fMinTime, fM->fMaxTime);
+
+ SetActive();
}
/**************************************************************************/
Reve::RGDoubleValuator* fTime;
public:
- TPCSectorVizEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ TPCSectorVizEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
~TPCSectorVizEditor();
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoSectorID();
void DoTrans();
-2006-09-27 Matevz TADEL <matevz.tadel@ijs.si>
-
- Merged HEAD to EVE-dev. Tagged EVE-dev(EVE-dev-after-merge).
-
-2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
-
- * alice-macros/clusters_from_label.C:
- Add point-set containing clusters directly as render element (it
- was wrapped in a RenderElementObjPtr by mistake (not fixed when
- changing it from TPolyMarker3D)).
-
- * alice-macros/primary_vertex.C:
- Removed code that gave vertex markers some volume (to avoid being
- discarded by a too smart GLViewer).
-
2006-09-04 Matevz Tadel <matevz.tadel@cern.ch>
* alice-macros/its_hits.C:
-2006-09-27 Matevz Tadel <matevz.tadel@cern.ch>
-
- * RGTopFrame.cxx:
- * RGTopFrame.h:
- * VSDSelector.cxx:
- Made GLCanvas un-editable to prevent users from drawing things
- over 3D scene; renamed the canvas data member from fCC to
- fGLCanvas. Renamed local variables not to dress-up as
- data-members.
-
-2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
-
- * RGBrowser.cxx:
- Hack to fix RenderElementObjPtr's colors in tree-view is no longer
- needed.
-
- * RGEditor.cxx:
- * RGEditor.h:
- Properly update items of render-elements; call gReve::Redraw3D()
- instead of pad modified/update. Added separate method
- DisplayRenderElement() that caches the render-element in a
- data-member to update it on change (needed for RenderElementObjPtr).
-
- * RGTopFrame.cxx:
- Use RGEditor::DisplayRenderElement() instead of
- DisplayObject(). Removed some never-used static structures.
-
- * RenderElement.cxx:
- Removed Redraw3D() from UpdateItems() as it can now be called from
- RGEditor::Update(); optimized item-updates in SetRnrElement() and
- SetMainColor().
-
- * PointSetArrayEditor.cxx:
- * TrackEditors.cxx:
- Added call to Update() in SetRange() methods.
-
-2006-09-26 Matevz Tadel <matevz.tadel@cern.ch>
-
- * RGBrowser.cxx:
- * RGEditor.cxx:
- * RGEditor.h:
- Use new functionality from TGedEditor.
-
- * PointSetArrayEditor.cxx:
- * PointSetArrayEditor.h:
- * RGeoNodeEditors.cxx:
- * RGeoNodeEditors.h:
- * RenderElementEditor.cxx:
- * RenderElementEditor.h:
- * TrackEditors.cxx:
- * TrackEditors.h:
- Conform to new TGedFrame paradigm in ROOT.
-
2006-09-04 Matevz Tadel <matevz.tadel@cern.ch>
* MCHelixLine.hi:
ClassImp(PointSetArrayEditor)
-PointSetArrayEditor::PointSetArrayEditor(const TGWindow *p,
- Int_t width, Int_t height,
- UInt_t options, Pixel_t back) :
- TGedFrame(p,width, height, options | kVerticalFrame, back),
+PointSetArrayEditor::PointSetArrayEditor(const TGWindow *p, Int_t id, Int_t width, Int_t height,
+ UInt_t options, Pixel_t back) :
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fM(0),
fRange(0)
{
fRange->Connect("ValueSet()",
"Reve::PointSetArrayEditor", this, "DoRange()");
AddFrame(fRange, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
+
+ // Register the editor.
+ TClass *cl = PointSetArray::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
PointSetArrayEditor::~PointSetArrayEditor()
/**************************************************************************/
-void PointSetArrayEditor::SetModel(TObject* obj)
+void PointSetArrayEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
{
- fM = dynamic_cast<PointSetArray*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(PointSetArray::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fM = dynamic_cast<PointSetArray*>(fModel);
// printf("FullRange(%f, %f) Selected(%f,%f)\n",
// fM->GetMin(), fM->GetMax(), fM->GetCurMin(), fM->GetCurMax());
fRange->SetLimits(fM->fMin, fM->fMax, TGNumberFormat::kNESRealTwo);
fRange->SetValues(fM->fCurMin, fM->fCurMax);
+
+ SetActive();
}
/**************************************************************************/
void PointSetArrayEditor::DoRange()
{
fM->SetRange(fRange->GetMin(), fRange->GetMax());
- Update();
}
Reve::RGDoubleValuator* fRange;
public:
- PointSetArrayEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ PointSetArrayEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
~PointSetArrayEditor();
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoRange();
fV2->MapSubwindows();
editor = new RGEditor(glpad);
- editor->GetTGCanvas()->ChangeOptions(0);
+ editor->GetCan()->ChangeOptions(0);
editor->SetWindowName("Reve Editor");
}
{
fClient->SetRoot(fV2);
editor = new RGEditor(glpad);
- editor->GetTGCanvas()->ChangeOptions(0);
+ editor->GetCan()->ChangeOptions(0);
fV2->RemoveFrame(editor);
fV2->AddFrame(editor, new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 0, 0, 2, 2));
fClient->SetRoot();
fClient->SetRoot(fV1);
editor = new RGEditor(glpad);
- editor->GetTGCanvas()->ChangeOptions(0);
+ editor->GetCan()->ChangeOptions(0);
editor->ChangeOptions(editor->GetOptions() | kFixedHeight);
fV1->RemoveFrame(editor);
fV1->AddFrame(editor, new TGLayoutHints(kLHintsTop | kLHintsExpandX, 0,2,2,2));
if(re == 0) return;
TObject* obj = re->GetObject();
+ // A pathetic hack to get at least a bit of color coordination
+ // for RenderElementObjPtr.
+ if(item->GetColor() != re->GetMainColor()) {
+ item->SetColor(re->GetMainColor());
+ fListTree->GetClient()->NeedRedraw(fListTree);
+ }
+
if(btn == 3) {
if (obj) {
fCtxMenu->Popup(x, y, obj);
// $Header$
#include "RGEditor.h"
-#include "RenderElement.h"
-#include "RGTopFrame.h"
#include <TGedFrame.h>
#include <TGCanvas.h>
RGEditor::RGEditor(TCanvas* canvas) : TGedEditor(canvas)
{}
-void RGEditor::DisplayRenderElement(RenderElement* re)
-{
- fRnrElement = re;
- TObject* obj = fRnrElement ? fRnrElement->GetObject() : 0;
- SetModel(fPad, obj, kButton1Down);
-}
-
void RGEditor::DisplayObject(TObject* obj)
{
- fRnrElement = 0;
- SetModel(fPad, obj, kButton1Down);
-}
-
-void RGEditor::Update(TGedFrame* /*gframe*/)
-{
- // Virtual method from TGedEditor ... called on every change.
-
- if (fRnrElement) {
- fRnrElement->UpdateItems();
+ fModel = obj;
+
+ if(obj) {
+ if(obj->IsA() != fClass && !obj->IsA()->InheritsFrom(fClass)) {
+ fClass = obj->IsA();
+ GetEditors();
+ }
+ } else {
+ fCan->UnmapWindow();
+ return;
}
- gReve->Redraw3D();
+ TGFrameElement *el;
+ TIter next(fStyle->GetList());
+ while ((el = (TGFrameElement *) next())) {
+ if ((el->fFrame)->InheritsFrom(TGedFrame::Class()))
+ ((TGedFrame *)(el->fFrame))->SetModel(fPad, fModel, 0);
+ }
+ fCan->MapWindow();
}
namespace Reve {
-class RenderElement;
-
class RGEditor : public TGedEditor
{
protected:
- RenderElement* fRnrElement;
public:
RGEditor(TCanvas* canvas=0);
virtual ~RGEditor() {}
- void DisplayRenderElement(RenderElement* re);
void DisplayObject(TObject* obj);
-
- virtual void Update(TGedFrame* gframe=0);
+ TGCanvas * GetCan() const {return fCan;}
ClassDef(RGEditor, 1);
}; // endclass RGEditor
Reve::RGTopFrame* gReve = 0;
+namespace {
+
+enum RGBrowserMT {
+ M_LAYOUT_1,
+ M_LAYOUT_2,
+ M_LAYOUT_3
+};
+
+const char *xpm_names[] = {
+ "lay1.xpm",
+ "lay2.xpm",
+ "lay3.xpm",
+ 0
+};
+
+ToolBarData_t tb_data[] = {
+ { "", "Standard list layout", kFALSE, M_LAYOUT_1, NULL },
+ { "", "TParticle latout", kFALSE, M_LAYOUT_2, NULL },
+ { "", "TGeo layout", kFALSE, M_LAYOUT_3, NULL },
+ { NULL, NULL, 0, 0, NULL }
+};
+
+} // unnamed namespace
+
/**************************************************************************/
RGTopFrame::RGTopFrame(const TGWindow *p, UInt_t w, UInt_t h, LookType_e look) :
TGMainFrame(p, w, h),
- fGLCanvas (0),
+ fCC (0),
+ fHistoCanvas (0),
fSelector (0),
fBrowser (0),
fStatusBar (0),
// Build GUI
- TGLayoutHints *lay0 = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY | kLHintsExpandY | kLHintsExpandX);
- TGLayoutHints *lay1 = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY | kLHintsExpandY | kLHintsExpandX, 2, 0, 2, 2);
- TGLayoutHints *lay2 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2);
-
- TGCompositeFrame* mainFrame = new TGCompositeFrame(this, w, h, kHorizontalFrame | kRaisedFrame);
- TGVerticalFrame* fV2 = new TGVerticalFrame(mainFrame, GetWidth()-40, GetHeight()-40, kSunkenFrame);
+ TGLayoutHints *fL0 = new TGLayoutHints(kLHintsCenterX |kLHintsCenterY | kLHintsExpandY| kLHintsExpandX);
+ TGLayoutHints *fL1 = new TGLayoutHints(kLHintsCenterX |kLHintsCenterY | kLHintsExpandY| kLHintsExpandX,2,0,2,2);
+ TGLayoutHints* fL2 = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX | kLHintsExpandY,
+ 2, 2, 2, 2);
+ TGCompositeFrame* fMainFrame = new TGCompositeFrame(this, w, h,kHorizontalFrame | kRaisedFrame);
+ fMainFrame->SetCleanup(kDeepCleanup);
+ TGVerticalFrame* fV2 = new TGVerticalFrame(fMainFrame, GetWidth()-40, GetHeight()-40, kSunkenFrame);
- mainFrame->AddFrame(fV2, lay1);
+ fMainFrame->AddFrame(fV2, fL1);
- TGTab* mainTab = new TGTab(fV2, GetWidth(), GetHeight());
+ // ??? TGCanvas* fCanvasWindow = new TGCanvas(fV2,w,h);
+ TGTab* fDisplayFrame = new TGTab(fV2, GetWidth(), GetHeight());
// browser tab
- TGCompositeFrame* tframe1 = mainTab->AddTab("Object Browser");
- fBrowser = new RGBrowser(tframe1, w, h);
- tframe1->AddFrame(fBrowser, lay2);
+ TGCompositeFrame* tFrame1 = fDisplayFrame->AddTab("Object Browser");
+ fBrowser = new RGBrowser(tFrame1, w, h);
+ tFrame1->AddFrame(fBrowser, fL2);
// tree selection tab
- TGCompositeFrame* tframe2 = mainTab->AddTab("Tree Selections");
- fSelector = new VSDSelector(fBrowser->GetListTree(), tframe2);
+ TGCompositeFrame* tFrame2 = fDisplayFrame->AddTab("Tree Selections");
+ fSelector = new VSDSelector(fBrowser->GetListTree(), tFrame2);
- // gl-canvas
+ // canvas
Reve::PushPad();
- TGCompositeFrame* tframe3 = mainTab->AddTab("GLCanvas");
- TRootEmbeddedCanvas* ecanvas3 = new TRootEmbeddedCanvas("GLCanvas", tframe3, 580, 360);
- tframe3->AddFrame(ecanvas3, lay2);
- fGLCanvas = ecanvas3->GetCanvas();
- fGLCanvas->SetEditable(kFALSE);
+ TGCompositeFrame* tFrame3 = fDisplayFrame->AddTab("Canvas");
+ TRootEmbeddedCanvas* fEmbeddedCanvas3 = new TRootEmbeddedCanvas("fEmbeddedCanvas3", tFrame3, 580, 360);
+ tFrame3->AddFrame(fEmbeddedCanvas3, fL2);
+ fEmbeddedCanvas3->GetCanvas()->SetBorderMode(0);
+ fCC = fEmbeddedCanvas3->GetCanvas();
+ // fCC->SetFillColor(1);
Reve::PopPad();
- fV2->AddFrame(mainTab, lay0);
- AddFrame(mainFrame, lay0);
+ // histo canvas
+ TGCompositeFrame* frame4 = fDisplayFrame->AddTab("HistoCanvas");
+ TRootEmbeddedCanvas* ecanvas4 = new TRootEmbeddedCanvas("HistoCanvas", frame4, 580, 360);
+ frame4->AddFrame(ecanvas4, fL2);
+ fHistoCanvas = ecanvas4->GetCanvas();
+ fHistoCanvas->SetBorderMode(0);
+
+ fV2->AddFrame(fDisplayFrame, fL0);
+ AddFrame(fMainFrame, fL0);
// Create status bar
Int_t parts[] = {45, 45, 10};
fStatusBar = new TGStatusBar(this, 50, 10, kHorizontalFrame);
fStatusBar->SetParts(parts, 3);
- TGLayoutHints* lay6 = new TGLayoutHints(kLHintsBottom| kLHintsExpandX, 0, 0, 0, 0);
- AddFrame(fStatusBar, lay6);
+ TGLayoutHints* fL6 = new TGLayoutHints(kLHintsBottom| kLHintsExpandX, 0, 0, 0, 0);
+ AddFrame(fStatusBar, fL6);
fStatusBar->SetText("GUI created", 0);
MapSubwindows();
/**************************************************************************/
/**************************************************************************/
+
switch(look) {
case LT_Classic: {
- fBrowser->SetupClassicLook(fEditor, fGLCanvas);
- fGLCanvas->GetViewer3D("ogl");
+ fBrowser->SetupClassicLook(fEditor, fCC);
+ fCC->GetViewer3D("ogl");
break;
}
case LT_Editor: {
- fBrowser->SetupEditorLook(fEditor, fGLCanvas);
- fGLCanvas->GetViewer3D("ogl");
+ fBrowser->SetupEditorLook(fEditor, fCC);
+ fCC->GetViewer3D("ogl");
break;
}
case LT_GLViewer: {
- fBrowser->SetupGLViewerLook(fEditor, fGLCanvas);
+ fBrowser->SetupGLViewerLook(fEditor, fCC);
break;
}
}
}
- TGLViewer* glv = dynamic_cast<TGLViewer*>(fGLCanvas->GetViewer3D());
+ TGLViewer* glv = dynamic_cast<TGLViewer*>(fCC->GetViewer3D());
if(glv) {
glv->SetSmartRefresh(kTRUE);
glv->SetResetCamerasOnUpdate(kFALSE);
{
static const Exc_t eH("RGTopFrame::EditRenderElement ");
- fEditor->DisplayRenderElement(rnr_element);
+ TObject* tobj = 0;
+ if(rnr_element) tobj = rnr_element->GetObject();
+ fEditor->DisplayObject(tobj);
}
/**************************************************************************/
{
// printf("RGTopFrame::DoRedraw3D redraw triggered\n");
if (fResetCameras) {
- fGLCanvas->GetViewer3D()->ResetCamerasAfterNextUpdate();
+ fCC->GetViewer3D()->ResetCamerasAfterNextUpdate();
fResetCameras = kFALSE;
}
-
- fGLCanvas->Modified();
- fGLCanvas->Update();
+ fCC->Modified();
+ fCC->Update();
fTimerActive = kFALSE;
}
TRint theApp("App", &argc, argv);
/* gReve = */ new RGTopFrame(gClient->GetRoot(), w, h, revemode);
-
run_loop:
try {
theApp.Run();
void RGTopFrame::DrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
{
- if(pad == 0) pad = fGLCanvas;
-
+ if(pad == 0) pad = GetCC();
{ Reve::PadHolder pHolder(false, pad);
- if (pad == fGLCanvas) fGLCanvas->SetEditable(kTRUE);
rnr_element->GetObject()->Draw();
- if (pad == fGLCanvas) fGLCanvas->SetEditable(kFALSE);
}
Redraw3D();
}
void RGTopFrame::UndrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
{
- if(pad == 0) pad = fGLCanvas;
+ if(pad == 0) pad = GetCC();
{ Reve::PadHolder pHolder(false, pad);
pad->GetListOfPrimitives()->Remove(rnr_element->GetObject());
}
RenderElement* rnrEl = (RenderElement*) obj;
rnrEl->SetRnrElement(state);
- Redraw3D();
}
/**************************************************************************/
enum LookType_e { LT_Classic, LT_Editor, LT_GLViewer };
private:
- TCanvas *fGLCanvas;
+ TCanvas *fCC;
+ TCanvas *fHistoCanvas;
VSDSelector *fSelector;
RGBrowser *fBrowser;
TGStatusBar *fStatusBar;
public:
RGTopFrame(const TGWindow *p, UInt_t w, UInt_t h, LookType_e look=LT_Classic);
- TCanvas* GetGLCanvas() { return fGLCanvas; }
+ TCanvas* GetCC() { return fCC; }
VSDSelector* GetSelector() { return fSelector; }
RGBrowser* GetBrowser() { return fBrowser; }
TGStatusBar* GetStatusBar() { return fStatusBar; }
ClassImp(GeoNodeRnrElEditor)
-GeoNodeRnrElEditor::GeoNodeRnrElEditor(const TGWindow *p,
+GeoNodeRnrElEditor::GeoNodeRnrElEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p,width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fNodeRE (0),
"Reve::GeoNodeRnrElEditor", this, "DoTransparency()");
AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
}
+
+
+ // What is this crap?
+ TClass *cl = GeoNodeRnrEl::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
/**************************************************************************/
-void GeoNodeRnrElEditor::SetModel(TObject* obj)
+void GeoNodeRnrElEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
{
- fNodeRE = dynamic_cast<GeoNodeRnrEl*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(GeoNodeRnrEl::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fNodeRE = dynamic_cast<GeoNodeRnrEl*>(fModel);
TGeoNode* node = fNodeRE->fNode;
TGeoVolume* vol = node->GetVolume();
fVizVolumeDaughters->SetState(vol->IsVisDaughters() ? kButtonDown : kButtonUp);
fTransparency->SetNumber(vol->GetTransparency());
+
+ SetActive();
}
/**************************************************************************/
ClassImp(GeoTopNodeRnrElEditor)
-GeoTopNodeRnrElEditor::GeoTopNodeRnrElEditor(const TGWindow *p,
+GeoTopNodeRnrElEditor::GeoTopNodeRnrElEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fTopNodeRE (0),
fVisOption (0),
"Reve::GeoTopNodeRnrElEditor", this, "DoVisLevel()");
AddFrame(f, new TGLayoutHints(kLHintsTop, 1, 1, 1, 1));
}
+
+
+ // What is this crap?
+ TClass *cl = GeoNodeRnrEl::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
/**************************************************************************/
-void GeoTopNodeRnrElEditor::SetModel(TObject* obj)
+void GeoTopNodeRnrElEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
{
- fTopNodeRE = dynamic_cast<GeoTopNodeRnrEl*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(GeoTopNodeRnrEl::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fTopNodeRE = dynamic_cast<GeoTopNodeRnrEl*>(fModel);
fVisOption->SetNumber(fTopNodeRE->GetVisOption());
fVisLevel->SetNumber(fTopNodeRE->GetVisLevel());
+
+ SetActive();
}
/**************************************************************************/
TGNumberEntry* fTransparency;
public:
- GeoNodeRnrElEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ GeoNodeRnrElEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
virtual ~GeoNodeRnrElEditor() {}
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoVizNode();
void DoVizNodeDaughters();
TGNumberEntry* fVisLevel;
public:
- GeoTopNodeRnrElEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ GeoTopNodeRnrElEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
virtual ~GeoTopNodeRnrElEditor() {}
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoVisOption();
void DoVisLevel();
if(fMainColorPtr != 0) i->fItem->SetColor(GetMainColor());
gClient->NeedRedraw(i->fTree);
}
+ gReve->Redraw3D(); // This will go away once editor can notify ALL changes.
}
/**************************************************************************/
{
if(rnr != fRnrElement) {
fRnrElement = rnr;
- for(sLTI_i i=fItems.begin(); i!=fItems.end(); ++i) {
- if (i->fItem->IsChecked() != rnr) {
- i->fItem->CheckItem(fRnrElement);
- gClient->NeedRedraw(i->fTree);
- }
- }
+ UpdateItems();
}
}
{
if (fMainColorPtr) {
*fMainColorPtr = color;
- for(sLTI_i i=fItems.begin(); i!=fItems.end(); ++i) {
- if(i->fItem->GetColor() != color) {
- i->fItem->SetColor(GetMainColor());
- gClient->NeedRedraw(i->fTree);
- }
- }
+ UpdateItems();
}
}
ClassImp(RenderElementEditor)
-RenderElementEditor::RenderElementEditor(const TGWindow *p,
+RenderElementEditor::RenderElementEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fRE (0),
fHFrame (0),
"Reve::RenderElementEditor", this, "DoRnrElement()");
AddFrame(fHFrame, new TGLayoutHints(kLHintsTop, 0, 0, 1, 1));
+
+ // Register the editor.
+ TClass *cl = RenderElement::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
RenderElementEditor::~RenderElementEditor()
/**************************************************************************/
-void RenderElementEditor::SetModel(TObject* obj)
+void RenderElementEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
{
- fRE = dynamic_cast<RenderElement*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(RenderElement::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fRE = dynamic_cast<RenderElement*>(fModel);
if (fRE->CanEditRnrElement()) {
fRnrElement->SetState(fRE->GetRnrElement() ? kButtonDown : kButtonUp);
}
fHFrame->Layout();
+
+ SetActive();
}
/**************************************************************************/
TGColorSelect* fMainColor;
public:
- RenderElementEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ RenderElementEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
~RenderElementEditor();
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoRnrElement();
void DoMainColor(Pixel_t color);
ClassImp(TrackListEditor)
-TrackListEditor::TrackListEditor(const TGWindow *p,
+TrackListEditor::TrackListEditor(const TGWindow *p, Int_t id,
Int_t width, Int_t height,
UInt_t options, Pixel_t back) :
- TGedFrame(p, width, height, options | kVerticalFrame, back),
+ TGedFrame(p, id, width, height, options | kVerticalFrame, back),
fTC (0),
fPtRange->Connect("ValueSet()",
"Reve::TrackListEditor", this, "DoPtRange()");
AddFrame(fPtRange, new TGLayoutHints(kLHintsTop, 1, 1, 2, 1));
+
+ // Register the editor.
+ TClass *cl = TrackList::Class();
+ TGedElement *ge = new TGedElement;
+ ge->fGedFrame = this;
+ ge->fCanvas = 0;
+ cl->GetEditorList()->Add(ge);
}
TrackListEditor::~TrackListEditor()
/**************************************************************************/
-void TrackListEditor::SetModel(TObject* obj)
+void TrackListEditor::SetModel(TVirtualPad* pad, TObject* obj, Int_t )
{
- fTC = dynamic_cast<TrackList*>(obj);
+ fModel = 0;
+ fPad = 0;
+
+ if (!obj || !obj->InheritsFrom(TrackList::Class()) || obj->InheritsFrom(TVirtualPad::Class())) {
+ SetActive(kFALSE);
+ return;
+ }
+
+ fModel = obj;
+ fPad = pad;
+
+ fTC = dynamic_cast<TrackList*>(fModel);
fMaxR->SetNumber(fTC->GetMaxR());
fMaxZ->SetNumber(fTC->GetMaxZ());
fFitDecay->SetState(fTC->GetFitDecay() ? kButtonDown : kButtonUp);
fPtRange->SetValues(0.1, 10);
+
+ SetActive();
}
/**************************************************************************/
void TrackListEditor::DoPtRange()
{
fTC->SelectByPt(fPtRange->GetMin(), fPtRange->GetMax());
- Update();
}
RGDoubleValuator* fPtRange;
public:
- TrackListEditor(const TGWindow* p=0, Int_t width=170, Int_t height=30,
- UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrameBackground());
+ TrackListEditor(const TGWindow* p, Int_t id, Int_t width = 170, Int_t height = 30, UInt_t options = kChildFrame, Pixel_t back = GetDefaultFrameBackground());
~TrackListEditor();
- virtual void SetModel(TObject* obj);
+ virtual void SetModel(TVirtualPad* pad, TObject* obj, Int_t event);
void DoMaxR();
void DoMaxZ();
// printf("%d entries in selection '%s'.\n", n, selection);
if(n > 0) {
- Reve::PadHolder pHolder(true, gReve->GetGLCanvas());
+ Reve::PadHolder pHolder(true, gReve->GetCC());
for(Int_t i=0; i<n; i++) {
Int_t label = evl.GetEntry(i);
mTreeK->GetEntry(label);
throw (eH + "No entries found in ESD data.");
if(n > 0) {
- Reve::PadHolder pHolder(true, gReve->GetGLCanvas());
+ Reve::PadHolder pHolder(true, gReve->GetCC());
TGListTreeItem* parent = fListTree->FindItemByPathname("Event0");
TrackList* cont = new TrackList();
}
}
clusters->SetMarkerStyle(2);
- clusters->SetMarkerSize(0.5);
+ clusters->SetMarkerSize(5);
clusters->SetMarkerColor(4);
clusters->SetName(Form("Clusters lab=%d", label));
using namespace Reve;
- gReve->AddRenderElement(clusters);
+ Color_t* colp = FindColorVar(clusters, "fMarkerColor");
+ RenderElementObjPtr* rnrEl = new RenderElementObjPtr(clusters, *colp);
+ gReve->AddRenderElement(rnrEl);
gReve->Redraw3D();
}
TPolyMarker3D* m = new TPolyMarker3D(8);
m->SetName(name);
+
+ // Problem with volume/length suppression of objects in TGLViewer
+ /*
+ m->SetPoint(0, x[0]+e[0], x[1]+e[1], x[2]+e[2]);
+ m->SetPoint(1, x[0]+e[0], x[1]-e[1], x[2]+e[2]);
+ m->SetPoint(2, x[0]-e[0], x[1]-e[1], x[2]+e[2]);
+ m->SetPoint(3, x[0]-e[0], x[1]+e[1], x[2]+e[2]);
+
+ m->SetPoint(4, x[0]+e[0], x[1]+e[1], x[2]-e[2]);
+ m->SetPoint(5, x[0]+e[0], x[1]-e[1], x[2]-e[2]);
+ m->SetPoint(6, x[0]-e[0], x[1]+e[1], x[2]-e[2]);
+ m->SetPoint(7, x[0]-e[0], x[1]-e[1], x[2]-e[2]);
+ */
m->SetPoint(0, x[0], x[1], x[2]);
return m;
HDRS := $(SRCS:.cxx=.h)
DHDR := Reve/LinkDef.h
-all-EVE: all-Reve all-reve all-Alieve all-alieve
+all-EVE: all-Reve all-reve all-Alieve
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff