[u/mrichter/AliRoot.git] / EVE / Reve / RGTopFrame.cxx

#include "RGTopFrame.h"

#include "RGBrowser.h"
#include "RGEditor.h"
#include "VSDSelector.h"

#include <Reve/RenderElement.h>

#include <TGMenu.h>
#include <TGTab.h>
#include <TGToolBar.h>
#include <TGLabel.h>
#include <TGTextEntry.h>
#include <TGSplitter.h>
#include <TRootEmbeddedCanvas.h>
#include <TGMimeTypes.h>

#include <TGLSAViewer.h>
#include <TH1F.h>
#include <TView.h>

#include <TROOT.h>
#include <TFile.h>
#include <TMacro.h>
#include <TFolder.h>
#include <TStyle.h>
#include <TPad.h>
#include <TCanvas.h>
#include <TSystem.h>
#include <TRint.h>
#include <TVirtualX.h>
#include <TPolyLine3D.h>
#include <TPolyMarker3D.h>
#include <TEnv.h>
#include <TStyle.h>
#include <KeySymbols.h>
#include "TVirtualGL.h"
#include "TPluginManager.h"

#include <iostream>

using namespace Reve;
using namespace Reve;

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

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


void RGTopFrame::Init(){
  fCC          = 0;
  fHistoCanvas = 0;
  fSelector    = 0;
  fBrowser     = 0;
  fStatusBar   = 0;
  fVSDFile     = "";

  fMacroFolder = new TFolder("EVE", "Visualization macros");
  gROOT->GetListOfBrowsables()->Add(fMacroFolder);

  fClient->GetMimeTypeList()->AddType("root/tmacro", "Reve::RMacro",
                                      "tmacro_s.xpm", "tmacro_t.xpm", "");

  fEditor = 0;

  fCurrentEvent    = 0;
  fCurrentEventLTI = 0;
  fGeometryLTI     = 0;

  fRedrawDisabled = false;
  fTimerActive    = false;
  fRedrawTimer.Connect("Timeout()", "Reve::RGTopFrame", this, "DoRedraw3D()");
}


RGTopFrame::RGTopFrame(const TGWindow *p, UInt_t w, UInt_t h, LookType_e look)
  : TGMainFrame(p, w, h)
{
  Init();
  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);

  fMainFrame->AddFrame(fV2, fL1);

  // ??? TGCanvas* fCanvasWindow = new TGCanvas(fV2,w,h);
  TGTab*    fDisplayFrame = new TGTab(fV2, GetWidth(), GetHeight());  

  // browser tab
  TGCompositeFrame* tFrame1 = fDisplayFrame->AddTab("Object Browser");
  fBrowser = new RGBrowser(tFrame1, w, h);
  tFrame1->AddFrame(fBrowser, fL2);

  // tree selection tab
  TGCompositeFrame* tFrame2 = fDisplayFrame->AddTab("Tree Selections");  
  fSelector = new VSDSelector(fBrowser->GetListTree(), tFrame2);

  // canvas
  Reve::PushPad();
  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();

  // 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* fL6 = new TGLayoutHints(kLHintsBottom| kLHintsExpandX, 0, 0, 0, 0);
  AddFrame(fStatusBar, fL6);
  fStatusBar->SetText("GUI created", 0);

  MapSubwindows();

  /**************************************************************************/
  /**************************************************************************/
  
  fEditor = new RGEditor(fCC);
  fEditor->GetCan()->ChangeOptions(0);

  switch(look) {
  case LT_Classic: {
    fBrowser->SetupClassicLook();
    // Need push/pop pad around here? Not.
    fCC->GetViewer3D("ogl");
    break;
  }

  case LT_Editor: {
    fBrowser->SetupEditorLook(fEditor);
    fCC->GetViewer3D("ogl");
    break;
  }

  case LT_GLViewer: {
    fBrowser->SetupGLViewerLook(fEditor, fCC);
    printf("Crap1 %d %d\n", GetWidth(), GetHeight());
    break;
  }

  default: {
    printf("RGTopFrame unknown look-type, ignoring.\n");
    break;
  }
  }

  TGLViewer* glv = dynamic_cast<TGLViewer*>(fCC->GetViewer3D());
  if(glv) {
    glv->SetSmartRefresh(true);
  }

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

  fGeometryLTI = GetListTree()->AddItem(0, "Geometry");
  GetListTree()->OpenItem(fGeometryLTI);

  Resize(GetDefaultSize()); // this is used here to init layout algorithm
  SetWindowName("Reve");
  MapWindow();

  fEditor->DisplayObject(0);

  gSystem->ProcessEvents();
}

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

TGListTree* RGTopFrame::GetListTree()
{
  return fBrowser->GetListTree();
}

TGListTreeItem* RGTopFrame::GetEventTreeItem()
{
  // return fBrowser->GetListTree()->FindItemByPathname("Event");
  return fCurrentEventLTI;
}

TGListTreeItem* RGTopFrame::GetGlobalTreeItem()
{
  return fGeometryLTI;
}

/**************************************************************************/
// Macro management
/**************************************************************************/

TMacro* RGTopFrame::GetMacro(const Text_t* name) const
{
  return dynamic_cast<TMacro*>(fMacroFolder->FindObject(name));
}

/**************************************************************************/
// Editor
/**************************************************************************/

void RGTopFrame::EditRenderElement(RenderElement* rnr_element)
{
  static const Exc_t eH("RGTopFrame::EditRenderElement ");

  TObject* tobj = 0;
  if(rnr_element) tobj = rnr_element->GetObject();
  fEditor->DisplayObject(tobj);
}

/**************************************************************************/
// 3D Pad management
/**************************************************************************/

void RGTopFrame::RegisterRedraw3D()
{
  fRedrawTimer.Start(0, kTRUE);
  fTimerActive = true;
}

void RGTopFrame::DoRedraw3D()
{
  // printf("RGTopFrame::DoRedraw3D redraw triggered\n");
  fCC->Modified();
  fCC->Update();
  fTimerActive = false;
}

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

int RGTopFrame::SpawnGuiAndRun(int argc, char **argv)
{
  LookType_e revemode = LT_Editor;
  if(argc >= 3 && (strcmp(argv[1], "-revemode")==0 || strcmp(argv[1], "-mode")==0)) {
    LookType_e m = LookType_e(atoi(argv[2]));
    if(m >= LT_Classic && m <= LT_GLViewer)
      revemode = m;
    printf("revemode = %d\n", revemode);
  }

  TRint theApp("App", &argc, argv);
  Int_t w = 800;
  Int_t h = 600;

  gReve = new RGTopFrame(gClient->GetRoot(), w, h, revemode);
 run_loop:
  try {
    theApp.Run();
  }
  catch(std::string exc) {
    gReve->GetStatusBar()->SetText(exc.c_str());
    fprintf(stderr, "Exception: %s\n", exc.c_str());
    goto run_loop;
  }
  return 0;
}

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

TGListTreeItem* RGTopFrame::AddEvent(TObject* event)
{
  fCurrentEvent = event;
  RenderElementObjPtr* rnrEv = new RenderElementObjPtr(event);
  fCurrentEventLTI = rnrEv->AddIntoListTree(GetListTree(), 0);
  GetListTree()->OpenItem(fCurrentEventLTI);
  return fCurrentEventLTI;
}

TGListTreeItem* RGTopFrame::AddRenderElement(RenderElement* rnr_element)
{
  return AddRenderElement(GetEventTreeItem(), rnr_element);
}

TGListTreeItem* RGTopFrame::AddRenderElement(TGListTreeItem* parent,
					     RenderElement* rnr_element)
{
  static const Exc_t eH("RGTopFrame::AddRenderElement ");

  // Here could route rnr-element to several browsers/pads.

  TGListTreeItem* newitem =
    rnr_element->AddIntoListTree(GetListTree(), parent);
  NotifyBrowser();

  return newitem;
}

TGListTreeItem* RGTopFrame::AddGlobalRenderElement(RenderElement* rnr_element)
{
  return AddGlobalRenderElement(GetGlobalTreeItem(), rnr_element);
}

TGListTreeItem* RGTopFrame::AddGlobalRenderElement(TGListTreeItem* parent,
						   RenderElement* rnr_element)
{
  static const Exc_t eH("RGTopFrame::AddGlobalRenderElement ");

  // Here could route rnr-element to several browsers/pads.

  TGListTreeItem* newitem =
    rnr_element->AddIntoListTree(GetListTree(), parent);
  NotifyBrowser();

  return newitem;
}

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

void RGTopFrame::DrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
{
  if(pad == 0) pad = GetCC();
  { Reve::PadHolder pHolder(false, pad);
    rnr_element->GetObject()->Draw();
  }
  Redraw3D();
}

void RGTopFrame::UndrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
{
  if(pad == 0) pad = GetCC();
  { Reve::PadHolder pHolder(false, pad);
    pad->GetListOfPrimitives()->Remove(rnr_element->GetObject());
  }
  Redraw3D();
}

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

void RGTopFrame::RenderElementChecked(TObject* obj, Bool_t state)
{
  // Item's user-data is blindly casted into TObject.
  // We recast it blindly back into the render element.

  RenderElement* rnrEl = (RenderElement*) obj;
  rnrEl->SetRnrElement(state);
}

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

void RGTopFrame::NotifyBrowser(TGListTreeItem* parent)
{
  TGListTree* l_tree = GetListTree();
  if(parent)
    l_tree->OpenItem(parent);
  gClient->NeedRedraw(l_tree);
}

/**************************************************************************/
// GeoManager registration
/**************************************************************************/

TGeoManager* RGTopFrame::GetGeometry(const TString& filename)
{
  static const Exc_t eH("RGTopFrame::GetGeometry ");

  TString exp_filename = filename;
  gSystem->ExpandPathName(exp_filename);
  printf("%s loading: '%s' -> '%s'.\n", eH.Data(),
	 filename.Data(), exp_filename.Data());

  std::map<TString, TGeoManager*>::iterator g = fGeometries.find(filename);
  if(g != fGeometries.end()) {
    return g->second;
  } else {
    if(gSystem->AccessPathName(exp_filename, kReadPermission))
      throw(eH + "file '" + exp_filename + "' not readable.");
    gGeoManager = 0;
    TGeoManager::Import(filename); 
    if(gGeoManager == 0)
      throw(eH + "GeoManager import failed.");
    gGeoManager->GetTopVolume()->VisibleDaughters(1);

    // Import colors exported by Gled, if they exist.
    {
      TFile f(exp_filename, "READ");
      TObjArray* collist = (TObjArray*) f.Get("ColorList");
      f.Close();
      if(collist != 0) {
	TSeqCollection* glist = gROOT->GetListOfColors();
	glist->Clear();
	glist->AddAll(collist);
      }
    }

    fGeometries[filename] = gGeoManager;
    return gGeoManager;
  }
}
Commit	Line	Data
5a5a1232	1	#include "RGTopFrame.h"
	2
	3	#include "RGBrowser.h"
	4	#include "RGEditor.h"
	5	#include "VSDSelector.h"
	6
	7	#include <Reve/RenderElement.h>
	8
	9	#include <TGMenu.h>
	10	#include <TGTab.h>
	11	#include <TGToolBar.h>
	12	#include <TGLabel.h>
	13	#include <TGTextEntry.h>
	14	#include <TGSplitter.h>
	15	#include <TRootEmbeddedCanvas.h>
3adb4b94	16	#include <TGMimeTypes.h>
5a5a1232	17
	18	#include <TGLSAViewer.h>
	19	#include <TH1F.h>
	20	#include <TView.h>
	21
	22	#include <TROOT.h>
	23	#include <TFile.h>
3adb4b94	24	#include <TMacro.h>
3adb4b94	25	#include <TFolder.h>
5a5a1232	26	#include <TStyle.h>
	27	#include <TPad.h>
	28	#include <TCanvas.h>
	29	#include <TSystem.h>
	30	#include <TRint.h>
	31	#include <TVirtualX.h>
	32	#include <TPolyLine3D.h>
	33	#include <TPolyMarker3D.h>
	34	#include <TEnv.h>
	35	#include <TStyle.h>
	36	#include <KeySymbols.h>
	37	#include "TVirtualGL.h"
	38	#include "TPluginManager.h"
	39
	40	#include <iostream>
	41
	42	using namespace Reve;
	43	using namespace Reve;
	44
	45	Reve::RGTopFrame* gReve = 0;
	46
	47	namespace {
	48
	49	enum RGBrowserMT {
	50	M_LAYOUT_1,
	51	M_LAYOUT_2,
	52	M_LAYOUT_3
	53	};
	54
	55	const char *xpm_names[] = {
	56	"lay1.xpm",
	57	"lay2.xpm",
	58	"lay3.xpm",
	59	0
	60	};
	61
	62	ToolBarData_t tb_data[] = {
	63	{ "", "Standard list layout", kFALSE, M_LAYOUT_1, NULL },
	64	{ "", "TParticle latout", kFALSE, M_LAYOUT_2, NULL },
	65	{ "", "TGeo layout", kFALSE, M_LAYOUT_3, NULL },
	66	{ NULL, NULL, 0, 0, NULL }
	67	};
	68
	69	} // unnamed namespace
	70
	71	/**************************************************************************/
	72
	73
	74	void RGTopFrame::Init(){
915dabe1	75	fCC = 0;
	76	fHistoCanvas = 0;
	77	fSelector = 0;
	78	fBrowser = 0;
	79	fStatusBar = 0;
	80	fVSDFile = "";
	81
3adb4b94	82	fMacroFolder = new TFolder("EVE", "Visualization macros");
	83	gROOT->GetListOfBrowsables()->Add(fMacroFolder);
	84
	85	fClient->GetMimeTypeList()->AddType("root/tmacro", "Reve::RMacro",
	86	"tmacro_s.xpm", "tmacro_t.xpm", "");
	87
915dabe1	88	fEditor = 0;
	89
	90	fCurrentEvent = 0;
	91	fCurrentEventLTI = 0;
	92	fGeometryLTI = 0;
5a5a1232	93
	94	fRedrawDisabled = false;
	95	fTimerActive = false;
	96	fRedrawTimer.Connect("Timeout()", "Reve::RGTopFrame", this, "DoRedraw3D()");
	97	}
	98
	99
	100	RGTopFrame::RGTopFrame(const TGWindow *p, UInt_t w, UInt_t h, LookType_e look)
	101	: TGMainFrame(p, w, h)
	102	{
	103	Init();
	104	TGLayoutHints *fL0 = new TGLayoutHints(kLHintsCenterX \|kLHintsCenterY \| kLHintsExpandY\| kLHintsExpandX);
	105	TGLayoutHints *fL1 = new TGLayoutHints(kLHintsCenterX \|kLHintsCenterY \| kLHintsExpandY\| kLHintsExpandX,2,0,2,2);
	106	TGLayoutHints* fL2 = new TGLayoutHints(kLHintsTop \| kLHintsLeft \| kLHintsExpandX \| kLHintsExpandY,
	107	2, 2, 2, 2);
	108	TGCompositeFrame* fMainFrame = new TGCompositeFrame(this, w, h,kHorizontalFrame \| kRaisedFrame);
	109	fMainFrame->SetCleanup(kDeepCleanup);
	110	TGVerticalFrame* fV2 = new TGVerticalFrame(fMainFrame, GetWidth()-40, GetHeight()-40, kSunkenFrame);
	111
	112	fMainFrame->AddFrame(fV2, fL1);
	113
	114	// ??? TGCanvas* fCanvasWindow = new TGCanvas(fV2,w,h);
	115	TGTab* fDisplayFrame = new TGTab(fV2, GetWidth(), GetHeight());
	116
	117	// browser tab
	118	TGCompositeFrame* tFrame1 = fDisplayFrame->AddTab("Object Browser");
	119	fBrowser = new RGBrowser(tFrame1, w, h);
	120	tFrame1->AddFrame(fBrowser, fL2);
	121
	122	// tree selection tab
	123	TGCompositeFrame* tFrame2 = fDisplayFrame->AddTab("Tree Selections");
	124	fSelector = new VSDSelector(fBrowser->GetListTree(), tFrame2);
	125
	126	// canvas
	127	Reve::PushPad();
	128	TGCompositeFrame* tFrame3 = fDisplayFrame->AddTab("Canvas");
	129	TRootEmbeddedCanvas* fEmbeddedCanvas3 = new TRootEmbeddedCanvas("fEmbeddedCanvas3", tFrame3, 580, 360);
	130	tFrame3->AddFrame(fEmbeddedCanvas3, fL2);
	131	fEmbeddedCanvas3->GetCanvas()->SetBorderMode(0);
	132	fCC = fEmbeddedCanvas3->GetCanvas();
	133	// fCC->SetFillColor(1);
5a5a1232	134	Reve::PopPad();
5a5a1232	135
5a5a1232	136	// histo canvas
	137	TGCompositeFrame* frame4 = fDisplayFrame->AddTab("HistoCanvas");
	138	TRootEmbeddedCanvas* ecanvas4 = new TRootEmbeddedCanvas("HistoCanvas", frame4, 580, 360);
	139	frame4->AddFrame(ecanvas4, fL2);
	140	fHistoCanvas = ecanvas4->GetCanvas();
	141	fHistoCanvas->SetBorderMode(0);
	142
5a5a1232	143	fV2->AddFrame(fDisplayFrame, fL0);
	144	AddFrame(fMainFrame, fL0);
	145
	146	// Create status bar
	147	Int_t parts[] = {45, 45, 10};
	148	fStatusBar = new TGStatusBar(this, 50, 10, kHorizontalFrame);
	149	fStatusBar->SetParts(parts, 3);
	150	TGLayoutHints* fL6 = new TGLayoutHints(kLHintsBottom\| kLHintsExpandX, 0, 0, 0, 0);
	151	AddFrame(fStatusBar, fL6);
	152	fStatusBar->SetText("GUI created", 0);
	153
	154	MapSubwindows();
	155
	156	/**************************************************************************/
	157	/**************************************************************************/
	158
	159	fEditor = new RGEditor(fCC);
	160	fEditor->GetCan()->ChangeOptions(0);
	161
	162	switch(look) {
	163	case LT_Classic: {
	164	fBrowser->SetupClassicLook();
	165	// Need push/pop pad around here? Not.
	166	fCC->GetViewer3D("ogl");
	167	break;
	168	}
	169
	170	case LT_Editor: {
	171	fBrowser->SetupEditorLook(fEditor);
	172	fCC->GetViewer3D("ogl");
	173	break;
	174	}
	175
	176	case LT_GLViewer: {
5a5a1232	177	fBrowser->SetupGLViewerLook(fEditor, fCC);
	178	printf("Crap1 %d %d\n", GetWidth(), GetHeight());
	179	break;
	180	}
	181
	182	default: {
	183	printf("RGTopFrame unknown look-type, ignoring.\n");
	184	break;
	185	}
	186	}
	187
	188	TGLViewer* glv = dynamic_cast<TGLViewer*>(fCC->GetViewer3D());
	189	if(glv) {
	190	glv->SetSmartRefresh(true);
	191	}
	192
	193	/**************************************************************************/
	194	/**************************************************************************/
	195
	196	fGeometryLTI = GetListTree()->AddItem(0, "Geometry");
	197	GetListTree()->OpenItem(fGeometryLTI);
	198
	199	Resize(GetDefaultSize()); // this is used here to init layout algorithm
	200	SetWindowName("Reve");
	201	MapWindow();
	202
	203	fEditor->DisplayObject(0);
	204
	205	gSystem->ProcessEvents();
	206	}
	207
	208	/**************************************************************************/
	209
	210	TGListTree* RGTopFrame::GetListTree()
	211	{
	212	return fBrowser->GetListTree();
	213	}
	214
	215	TGListTreeItem* RGTopFrame::GetEventTreeItem()
	216	{
	217	// return fBrowser->GetListTree()->FindItemByPathname("Event");
	218	return fCurrentEventLTI;
	219	}
	220
	221	TGListTreeItem* RGTopFrame::GetGlobalTreeItem()
	222	{
	223	return fGeometryLTI;
	224	}
	225
3adb4b94	226	/**************************************************************************/
	227	// Macro management
	228	/**************************************************************************/
	229
	230	TMacro* RGTopFrame::GetMacro(const Text_t* name) const
	231	{
	232	return dynamic_cast<TMacro*>(fMacroFolder->FindObject(name));
	233	}
	234
5a5a1232	235	/**************************************************************************/
	236	// Editor
	237	/**************************************************************************/
	238
	239	void RGTopFrame::EditRenderElement(RenderElement* rnr_element)
	240	{
	241	static const Exc_t eH("RGTopFrame::EditRenderElement ");
	242
	243	TObject* tobj = 0;
092578a7	244	if(rnr_element) tobj = rnr_element->GetObject();
5a5a1232	245	fEditor->DisplayObject(tobj);
	246	}
	247
	248	/**************************************************************************/
	249	// 3D Pad management
	250	/**************************************************************************/
	251
	252	void RGTopFrame::RegisterRedraw3D()
	253	{
	254	fRedrawTimer.Start(0, kTRUE);
	255	fTimerActive = true;
	256	}
	257
	258	void RGTopFrame::DoRedraw3D()
	259	{
	260	// printf("RGTopFrame::DoRedraw3D redraw triggered\n");
	261	fCC->Modified();
	262	fCC->Update();
	263	fTimerActive = false;
	264	}
	265
	266	/**************************************************************************/
	267
	268	int RGTopFrame::SpawnGuiAndRun(int argc, char **argv)
	269	{
	270	LookType_e revemode = LT_Editor;
2ef077e4	271	if(argc >= 3 && (strcmp(argv[1], "-revemode")==0 \|\| strcmp(argv[1], "-mode")==0)) {
5a5a1232	272	LookType_e m = LookType_e(atoi(argv[2]));
	273	if(m >= LT_Classic && m <= LT_GLViewer)
	274	revemode = m;
	275	printf("revemode = %d\n", revemode);
	276	}
	277
	278	TRint theApp("App", &argc, argv);
	279	Int_t w = 800;
	280	Int_t h = 600;
	281
	282	gReve = new RGTopFrame(gClient->GetRoot(), w, h, revemode);
	283	run_loop:
	284	try {
	285	theApp.Run();
	286	}
	287	catch(std::string exc) {
	288	gReve->GetStatusBar()->SetText(exc.c_str());
371dc0b2	289	fprintf(stderr, "Exception: %s\n", exc.c_str());
5a5a1232	290	goto run_loop;
	291	}
	292	return 0;
	293	}
	294
	295	/**************************************************************************/
	296	/**************************************************************************/
	297
	298	TGListTreeItem* RGTopFrame::AddEvent(TObject* event)
	299	{
092578a7	300	fCurrentEvent = event;
	301	RenderElementObjPtr* rnrEv = new RenderElementObjPtr(event);
	302	fCurrentEventLTI = rnrEv->AddIntoListTree(GetListTree(), 0);
5a5a1232	303	GetListTree()->OpenItem(fCurrentEventLTI);
	304	return fCurrentEventLTI;
	305	}
	306
	307	TGListTreeItem* RGTopFrame::AddRenderElement(RenderElement* rnr_element)
	308	{
092578a7	309	return AddRenderElement(GetEventTreeItem(), rnr_element);
5a5a1232	310	}
	311
	312	TGListTreeItem* RGTopFrame::AddRenderElement(TGListTreeItem* parent,
	313	RenderElement* rnr_element)
	314	{
	315	static const Exc_t eH("RGTopFrame::AddRenderElement ");
	316
	317	// Here could route rnr-element to several browsers/pads.
	318
	319	TGListTreeItem* newitem =
	320	rnr_element->AddIntoListTree(GetListTree(), parent);
	321	NotifyBrowser();
	322
	323	return newitem;
	324	}
	325
	326	TGListTreeItem* RGTopFrame::AddGlobalRenderElement(RenderElement* rnr_element)
	327	{
092578a7	328	return AddGlobalRenderElement(GetGlobalTreeItem(), rnr_element);
5a5a1232	329	}
5a5a1232	330
092578a7	331	TGListTreeItem* RGTopFrame::AddGlobalRenderElement(TGListTreeItem* parent,
5a5a1232	332	RenderElement* rnr_element)
	333	{
	334	static const Exc_t eH("RGTopFrame::AddGlobalRenderElement ");
	335
	336	// Here could route rnr-element to several browsers/pads.
	337
	338	TGListTreeItem* newitem =
092578a7	339	rnr_element->AddIntoListTree(GetListTree(), parent);
5a5a1232	340	NotifyBrowser();
	341
	342	return newitem;
	343	}
	344
	345	/**************************************************************************/
	346
	347	void RGTopFrame::DrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
	348	{
	349	if(pad == 0) pad = GetCC();
	350	{ Reve::PadHolder pHolder(false, pad);
	351	rnr_element->GetObject()->Draw();
	352	}
	353	Redraw3D();
	354	}
	355
5a34ca2d	356	void RGTopFrame::UndrawRenderElement(RenderElement* rnr_element, TVirtualPad* pad)
	357	{
	358	if(pad == 0) pad = GetCC();
	359	{ Reve::PadHolder pHolder(false, pad);
	360	pad->GetListOfPrimitives()->Remove(rnr_element->GetObject());
	361	}
	362	Redraw3D();
	363	}
	364
5a5a1232	365	/**************************************************************************/
	366
	367	void RGTopFrame::RenderElementChecked(TObject* obj, Bool_t state)
	368	{
092578a7	369	// Item's user-data is blindly casted into TObject.
	370	// We recast it blindly back into the render element.
	371
	372	RenderElement* rnrEl = (RenderElement*) obj;
	373	rnrEl->SetRnrElement(state);
5a5a1232	374	}
	375
	376	/**************************************************************************/
	377
	378	void RGTopFrame::NotifyBrowser(TGListTreeItem* parent)
	379	{
	380	TGListTree* l_tree = GetListTree();
	381	if(parent)
	382	l_tree->OpenItem(parent);
5a34ca2d	383	gClient->NeedRedraw(l_tree);
5a5a1232	384	}
	385
	386	/**************************************************************************/
	387	// GeoManager registration
	388	/**************************************************************************/
	389
	390	TGeoManager* RGTopFrame::GetGeometry(const TString& filename)
	391	{
	392	static const Exc_t eH("RGTopFrame::GetGeometry ");
	393
	394	TString exp_filename = filename;
	395	gSystem->ExpandPathName(exp_filename);
	396	printf("%s loading: '%s' -> '%s'.\n", eH.Data(),
	397	filename.Data(), exp_filename.Data());
	398
	399	std::map<TString, TGeoManager*>::iterator g = fGeometries.find(filename);
	400	if(g != fGeometries.end()) {
	401	return g->second;
	402	} else {
	403	if(gSystem->AccessPathName(exp_filename, kReadPermission))
	404	throw(eH + "file '" + exp_filename + "' not readable.");
	405	gGeoManager = 0;
	406	TGeoManager::Import(filename);
	407	if(gGeoManager == 0)
	408	throw(eH + "GeoManager import failed.");
	409	gGeoManager->GetTopVolume()->VisibleDaughters(1);
	410
	411	// Import colors exported by Gled, if they exist.
	412	{
	413	TFile f(exp_filename, "READ");
	414	TObjArray* collist = (TObjArray*) f.Get("ColorList");
	415	f.Close();
	416	if(collist != 0) {
	417	TSeqCollection* glist = gROOT->GetListOfColors();
	418	glist->Clear();
	419	glist->AddAll(collist);
	420	}
	421	}
	422
	423	fGeometries[filename] = gGeoManager;
	424	return gGeoManager;
	425	}
	426	}