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

#include "ReveManager.h"

#include <Reve/Viewer.h>
#include <Reve/Scene.h>
#include <Reve/Pad.h>
#include <Reve/EventBase.h>

#include <Reve/RGBrowser.h>
#include <Reve/RGEditor.h>

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

#include <TGStatusBar.h>

#include <TGLSAViewer.h>

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

#include <iostream>

using namespace Reve;
using namespace Reve;

Reve::ReveManager* gReve = 0;

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

ReveManager::ReveManager(UInt_t w, UInt_t h) :
  fBrowser     (0),
  fEditor      (0),
  fStatusBar   (0),

  fMacroFolder (0),

  fViewers        (0),
  fScenes         (0),
  fViewer         (0),
  fGlobalScene    (0),
  fEventScene     (0),
  fCurrentEvent   (0),

  fRedrawDisabled (0),
  fResetCameras   (kFALSE),
  fDropLogicals   (kFALSE),
  fKeepEmptyCont  (kFALSE),
  fTimerActive    (kFALSE),
  fRedrawTimer    (),

  fGeometries     ()
{
  // Constructor.

  static const Exc_t eH("ReveManager::ReveManager ");

  if (gReve != 0)
    throw(eH + "There can be only one!");

  gReve = this;

  fRedrawTimer.Connect("Timeout()", "Reve::ReveManager", this, "DoRedraw3D()");
  fMacroFolder = new TFolder("EVE", "Visualization macros");
  gROOT->GetListOfBrowsables()->Add(fMacroFolder);


  // Build GUI
  fBrowser   = new RGBrowser(w, h);
  fStatusBar = fBrowser->GetStatusBar();

  // ListTreeEditor
  fBrowser->StartEmbedding(0);
  fLTEFrame = new RGLTEFrame("REVE");
  fBrowser->StopEmbedding();
  fBrowser->SetTabTitle("Reve", 0);
  fEditor   = fLTEFrame->fEditor;

  // GL viewer
  fBrowser->StartEmbedding(1);
  TGLSAViewer* glv = new TGLSAViewer(gClient->GetRoot(), 0, fEditor);
  //glv->GetFrame()->SetCleanup(kNoCleanup);
  glv->ToggleEditObject();
  fBrowser->StopEmbedding();
  fBrowser->SetTabTitle("GLViewer", 1);

  // Finalize it
  fBrowser->InitPlugins();
  fBrowser->MapWindow();

  // --------------------------------

  fViewers = new ViewerList("Viewers");
  fViewers->IncDenyDestroy();
  AddToListTree(fViewers, kTRUE);

  fViewer  = new Viewer("GL-One");
  fViewer->SetGLViewer(glv);
  fViewer->IncDenyDestroy();
  AddRenderElement(fViewer, fViewers);

  fScenes  = new SceneList ("Scenes");
  fScenes->IncDenyDestroy();
  AddToListTree(fScenes, kTRUE);

  fGlobalScene = new Scene("Geometry scene");
  fGlobalScene->IncDenyDestroy();
  AddRenderElement(fGlobalScene, fScenes);

  fEventScene = new Scene("Event scene");
  fEventScene->IncDenyDestroy();
  AddRenderElement(fEventScene, fScenes);

  fViewer->AddScene(fGlobalScene);
  fViewer->AddScene(fEventScene);

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

  fEditor->DisplayObject(GetGLViewer());

  gSystem->ProcessEvents();
}

ReveManager::~ReveManager()
{
  // Destructor.
}

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

TCanvas* ReveManager::AddCanvasTab(const char* name)
{
  // Add a new canvas tab.

  fBrowser->StartEmbedding(1, -1);
  TCanvas* c = new TCanvas;
  fBrowser->StopEmbedding();
  fBrowser->SetTabTitle(name, 1, -1);

  return c;
}

TGWindow* ReveManager::GetMainWindow() const
{
  // Get the main window, i.e. the first created reve-browser.

  return fBrowser;
}

TGLViewer* ReveManager::GetGLViewer() const
{
  // Get default TGLViewer.

  return fViewer->GetGLViewer();
}

Viewer* ReveManager::SpawnNewViewer(const Text_t* name, const Text_t* title,
				    Bool_t embed)
{
  // Create a new GL viewer.

  Viewer* v = new Viewer(name, title);

  if (embed)  fBrowser->StartEmbedding(1);
  v->SpawnGLViewer(gClient->GetRoot(), embed ? fEditor : 0);
  v->IncDenyDestroy();
  if (embed)  fBrowser->StopEmbedding(), fBrowser->SetTabTitle(name, 1);
  AddRenderElement(v, fViewers);
  return v;
}

Scene* ReveManager::SpawnNewScene(const Text_t* name, const Text_t* title)
{
  // Create a new scene.

  Scene* s = new Scene(name, title);
  AddRenderElement(s, fScenes);
  return s;
}

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

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

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

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

  fEditor->DisplayRenderElement(rnr_element);
}

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

void ReveManager::RegisterRedraw3D()
{
  // Register a request for 3D redraw.

  fRedrawTimer.Start(0, kTRUE);
  fTimerActive = true;
}

void ReveManager::DoRedraw3D()
{
  // Perform 3D redraw of scenes and viewers whose contents has
  // changed.

  // printf("ReveManager::DoRedraw3D redraw triggered\n");

  fScenes ->RepaintChangedScenes();
  fViewers->RepaintChangedViewers(fResetCameras, fDropLogicals);

  fResetCameras = kFALSE;
  fDropLogicals = kFALSE;

  fTimerActive = kFALSE;
}

void ReveManager::FullRedraw3D(Bool_t resetCameras, Bool_t dropLogicals)
{
  // Perform 3D redraw of all scenes and viewers.

  fScenes ->RepaintAllScenes();
  fViewers->RepaintAllViewers(resetCameras, dropLogicals);
}

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

void ReveManager::RenderElementChanged(RenderElement* rnr_element)
{
  std::list<RenderElement*> scenes;
  rnr_element->CollectSceneParents(scenes);
  ScenesChanged(scenes);
}

void ReveManager::ScenesChanged(std::list<RenderElement*>& scenes)
{
  for (RenderElement::List_i s=scenes.begin(); s!=scenes.end(); ++s)
    ((Scene*)*s)->Changed();
}

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

int ReveManager::SpawnGuiAndRun(int argc, char **argv)
{
  Int_t w = 1024;
  Int_t h =  768;

  TRint theApp("App", &argc, argv);

  Reve::SetupGUI();
  /* gReve = */ new ReveManager(w, h);

 run_loop:
  try {
    theApp.Run();
  }
  catch(Exc_t& exc) {
    gReve->SetStatusLine(exc.Data());
    fprintf(stderr, "Exception: %s\n", exc.Data());
    goto run_loop;
  }
  return 0;
}

void ReveManager::SpawnGui()
{
  Int_t w = 1024;
  Int_t h =  768;

  Reve::SetupGUI();
  /* gReve = */ new ReveManager(w, h);
}

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

TGListTree* ReveManager::GetListTree() const
{
  return fLTEFrame->fListTree;
}

TGListTreeItem*
ReveManager::AddToListTree(RenderElement* re, Bool_t open, TGListTree* lt)
{
  // Add rnr-el as a top-level to a list-tree.
  // Please add a single copy of a render-element as a top level
  // or we will have to check for that, too.

  if (lt == 0) lt = GetListTree();
  TGListTreeItem* lti = re->AddIntoListTree(lt, (TGListTreeItem*)0);
  if (open) lt->OpenItem(lti);
  return lti;
}

void ReveManager::RemoveFromListTree(RenderElement* re, TGListTree* lt, TGListTreeItem* lti)
{
  // Remove top-level rnr-el from list-tree with specified tree-item.

  static const Exc_t eH("ReveManager::RemoveFromListTree ");

  if (lti->GetParent())
    throw(eH + "not a top-level item.");

  re->RemoveFromListTree(lt, 0);
}

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

TGListTreeItem* ReveManager::AddEvent(EventBase* event)
{
  fCurrentEvent = event;
  fCurrentEvent->IncDenyDestroy();
  AddRenderElement(fCurrentEvent, fEventScene);
  return AddToListTree(event, kTRUE);
}

TGListTreeItem* ReveManager::AddRenderElement(RenderElement* rnr_element,
					     RenderElement* parent)
{
  if (parent == 0) {
    if (fCurrentEvent == 0)
      AddEvent(new EventBase("Event", "Auto-created event directory"));
    parent = fCurrentEvent;
  }

  return parent->AddElement(rnr_element);
}

TGListTreeItem* ReveManager::AddGlobalRenderElement(RenderElement* rnr_element,
                                                    RenderElement* parent)
{
  if (parent == 0)
    parent = fGlobalScene;

  return parent->AddElement(rnr_element);
}

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

void ReveManager::RemoveRenderElement(RenderElement* rnr_element,
				     RenderElement* parent)
{
  parent->RemoveElement(rnr_element);
}

void ReveManager::PreDeleteRenderElement(RenderElement* rnr_element)
{
  if (fEditor->GetRnrElement() == rnr_element)
    fEditor->DisplayObject(0);
}

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

void ReveManager::RenderElementSelect(RenderElement* rnr_element)
{
  EditRenderElement(rnr_element);
}

Bool_t ReveManager::RenderElementPaste(RenderElement* rnr_element)
{
  RenderElement* src = fEditor->GetRnrElement();
  if (src)
    return rnr_element->HandleElementPaste(src);
  return kFALSE;
}

void ReveManager::RenderElementChecked(RenderElement* rnrEl, Bool_t state)
{
  rnrEl->SetRnrState(state);

  if (fEditor->GetModel() == rnrEl->GetEditorObject())
    fEditor->DisplayRenderElement(rnrEl);

  rnrEl->ElementChanged();
}

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

void ReveManager::NotifyBrowser(TGListTreeItem* parent_lti)
{
  TGListTree* lt = GetListTree();
  if (parent_lti)
    lt->OpenItem(parent_lti);
  lt->ClearViewPort();
}

void ReveManager::NotifyBrowser(RenderElement* parent)
{
  TGListTreeItem* parent_lti = parent ? parent->FindListTreeItem(GetListTree()) : 0;
  NotifyBrowser(parent_lti);
}

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

TGeoManager* ReveManager::GetGeometry(const TString& filename)
{
  static const Exc_t eH("ReveManager::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) {
	TIter next(gGeoManager->GetListOfVolumes());
	TGeoVolume* vol;
	while ((vol = (TGeoVolume*) next()) != 0)
	{
          Int_t oldID = vol->GetLineColor();
          TColor* col = (TColor*)collist->At(oldID);
          Float_t r, g, b;
	  col->GetRGB(r, g, b);
          Int_t  newID = TColor::GetColor(r,g,b);
          vol->SetLineColor(newID);
	} 
      }
    }

    fGeometries[filename] = gGeoManager;
    return gGeoManager;
  }
}

/**************************************************************************/
// Testing exceptions
/**************************************************************************/

void ReveManager::SetStatusLine(const char* text)
{
  fStatusBar->SetText(text);
}

void ReveManager::ThrowException(const char* text)
{
  static const Exc_t eH("ReveManager::ThrowException ");

  throw(eH + text);
}
Commit	Line	Data
32e219c2	1	#include "ReveManager.h"
	2
	3	#include <Reve/Viewer.h>
	4	#include <Reve/Scene.h>
	5	#include <Reve/Pad.h>
	6	#include <Reve/EventBase.h>
	7
	8	#include <Reve/RGBrowser.h>
	9	#include <Reve/RGEditor.h>
	10
	11	#include <TGMenu.h>
	12	#include <TGTab.h>
	13	#include <TGToolBar.h>
	14	#include <TGLabel.h>
	15	#include <TGTextEntry.h>
	16	#include <TGSplitter.h>
	17	#include <TRootEmbeddedCanvas.h>
	18
	19	#include <TGStatusBar.h>
	20
	21	#include <TGLSAViewer.h>
	22
	23	#include <TROOT.h>
	24	#include <TFile.h>
	25	#include <TMacro.h>
	26	#include <TFolder.h>
	27	#include <TStyle.h>
	28	#include <TBrowser.h>
	29	#include <TPad.h>
	30	#include <TCanvas.h>
	31	#include <TSystem.h>
	32	#include <TRint.h>
	33	#include <TVirtualX.h>
	34	#include <TEnv.h>
	35	#include <TStyle.h>
	36	#include <TColor.h>
	37	#include <TGeoShape.h>
	38	#include <KeySymbols.h>
	39	#include "TVirtualGL.h"
	40	#include "TPluginManager.h"
	41
	42	#include <iostream>
	43
	44	using namespace Reve;
	45	using namespace Reve;
	46
	47	Reve::ReveManager* gReve = 0;
	48
	49	/**************************************************************************/
	50
	51	ReveManager::ReveManager(UInt_t w, UInt_t h) :
	52	fBrowser (0),
	53	fEditor (0),
	54	fStatusBar (0),
	55
	56	fMacroFolder (0),
	57
	58	fViewers (0),
	59	fScenes (0),
	60	fViewer (0),
	61	fGlobalScene (0),
	62	fEventScene (0),
	63	fCurrentEvent (0),
	64
65	fRedrawDisabled (0),
66	fResetCameras (kFALSE),
67	fDropLogicals (kFALSE),
68	fKeepEmptyCont (kFALSE),
69	fTimerActive (kFALSE),
70	fRedrawTimer (),
71
72	fGeometries ()
73	{
e9ef1a49	74	// Constructor.
e9ef1a49	75
32e219c2	76	static const Exc_t eH("ReveManager::ReveManager ");
	77
	78	if (gReve != 0)
	79	throw(eH + "There can be only one!");
	80
	81	gReve = this;
	82
	83	fRedrawTimer.Connect("Timeout()", "Reve::ReveManager", this, "DoRedraw3D()");
	84	fMacroFolder = new TFolder("EVE", "Visualization macros");
	85	gROOT->GetListOfBrowsables()->Add(fMacroFolder);
	86
	87
	88	// Build GUI
	89	fBrowser = new RGBrowser(w, h);
	90	fStatusBar = fBrowser->GetStatusBar();
	91
	92	// ListTreeEditor
	93	fBrowser->StartEmbedding(0);
	94	fLTEFrame = new RGLTEFrame("REVE");
	95	fBrowser->StopEmbedding();
	96	fBrowser->SetTabTitle("Reve", 0);
	97	fEditor = fLTEFrame->fEditor;
	98
	99	// GL viewer
	100	fBrowser->StartEmbedding(1);
	101	TGLSAViewer* glv = new TGLSAViewer(gClient->GetRoot(), 0, fEditor);
	102	//glv->GetFrame()->SetCleanup(kNoCleanup);
	103	glv->ToggleEditObject();
	104	fBrowser->StopEmbedding();
	105	fBrowser->SetTabTitle("GLViewer", 1);
	106
	107	// Finalize it
	108	fBrowser->InitPlugins();
	109	fBrowser->MapWindow();
	110
	111	// --------------------------------
	112
	113	fViewers = new ViewerList("Viewers");
	114	fViewers->IncDenyDestroy();
	115	AddToListTree(fViewers, kTRUE);
	116
	117	fViewer = new Viewer("GL-One");
	118	fViewer->SetGLViewer(glv);
	119	fViewer->IncDenyDestroy();
	120	AddRenderElement(fViewer, fViewers);
	121
	122	fScenes = new SceneList ("Scenes");
	123	fScenes->IncDenyDestroy();
	124	AddToListTree(fScenes, kTRUE);
	125
	126	fGlobalScene = new Scene("Geometry scene");
	127	fGlobalScene->IncDenyDestroy();
	128	AddRenderElement(fGlobalScene, fScenes);
	129
	130	fEventScene = new Scene("Event scene");
	131	fEventScene->IncDenyDestroy();
	132	AddRenderElement(fEventScene, fScenes);
	133
	134	fViewer->AddScene(fGlobalScene);
	135	fViewer->AddScene(fEventScene);
	136
	137	/**************************************************************************/
	138	/**************************************************************************/
	139
140	fEditor->DisplayObject(GetGLViewer());
141
142	gSystem->ProcessEvents();
143	}
144
145	ReveManager::~ReveManager()
e9ef1a49	146	{
	147	// Destructor.
	148	}
32e219c2	149
	150	/**************************************************************************/
	151
	152	TCanvas* ReveManager::AddCanvasTab(const char* name)
	153	{
e9ef1a49	154	// Add a new canvas tab.
e9ef1a49	155
32e219c2	156	fBrowser->StartEmbedding(1, -1);
	157	TCanvas* c = new TCanvas;
	158	fBrowser->StopEmbedding();
	159	fBrowser->SetTabTitle(name, 1, -1);
	160
	161	return c;
	162	}
	163
	164	TGWindow* ReveManager::GetMainWindow() const
	165	{
e9ef1a49	166	// Get the main window, i.e. the first created reve-browser.
e9ef1a49	167
32e219c2	168	return fBrowser;
	169	}
	170
	171	TGLViewer* ReveManager::GetGLViewer() const
	172	{
e9ef1a49	173	// Get default TGLViewer.
e9ef1a49	174
32e219c2	175	return fViewer->GetGLViewer();
	176	}
	177
e9ef1a49	178	Viewer* ReveManager::SpawnNewViewer(const Text_t* name, const Text_t* title,
e9ef1a49	179	Bool_t embed)
32e219c2	180	{
e9ef1a49	181	// Create a new GL viewer.
e9ef1a49	182
32e219c2	183	Viewer* v = new Viewer(name, title);
	184
	185	if (embed) fBrowser->StartEmbedding(1);
	186	v->SpawnGLViewer(gClient->GetRoot(), embed ? fEditor : 0);
	187	v->IncDenyDestroy();
	188	if (embed) fBrowser->StopEmbedding(), fBrowser->SetTabTitle(name, 1);
	189	AddRenderElement(v, fViewers);
	190	return v;
	191	}
	192
	193	Scene* ReveManager::SpawnNewScene(const Text_t* name, const Text_t* title)
	194	{
e9ef1a49	195	// Create a new scene.
e9ef1a49	196
32e219c2	197	Scene* s = new Scene(name, title);
	198	AddRenderElement(s, fScenes);
	199	return s;
	200	}
	201
	202	/**************************************************************************/
	203	// Macro management
	204	/**************************************************************************/
	205
	206	TMacro* ReveManager::GetMacro(const Text_t* name) const
	207	{
	208	return dynamic_cast<TMacro*>(fMacroFolder->FindObject(name));
	209	}
	210
	211	/**************************************************************************/
	212	// Editor
	213	/**************************************************************************/
	214
	215	void ReveManager::EditRenderElement(RenderElement* rnr_element)
	216	{
	217	static const Exc_t eH("ReveManager::EditRenderElement ");
	218
	219	fEditor->DisplayRenderElement(rnr_element);
	220	}
	221
	222	/**************************************************************************/
	223	// 3D Pad management
	224	/**************************************************************************/
	225
	226	void ReveManager::RegisterRedraw3D()
	227	{
e9ef1a49	228	// Register a request for 3D redraw.
e9ef1a49	229
32e219c2	230	fRedrawTimer.Start(0, kTRUE);
	231	fTimerActive = true;
	232	}
	233
	234	void ReveManager::DoRedraw3D()
	235	{
e9ef1a49	236	// Perform 3D redraw of scenes and viewers whose contents has
	237	// changed.
	238
32e219c2	239	// printf("ReveManager::DoRedraw3D redraw triggered\n");
	240
	241	fScenes ->RepaintChangedScenes();
	242	fViewers->RepaintChangedViewers(fResetCameras, fDropLogicals);
	243
	244	fResetCameras = kFALSE;
	245	fDropLogicals = kFALSE;
	246
	247	fTimerActive = kFALSE;
	248	}
	249
	250	void ReveManager::FullRedraw3D(Bool_t resetCameras, Bool_t dropLogicals)
	251	{
e9ef1a49	252	// Perform 3D redraw of all scenes and viewers.
e9ef1a49	253
32e219c2	254	fScenes ->RepaintAllScenes();
	255	fViewers->RepaintAllViewers(resetCameras, dropLogicals);
	256	}
	257
	258	/**************************************************************************/
	259
	260	void ReveManager::RenderElementChanged(RenderElement* rnr_element)
	261	{
	262	std::list<RenderElement*> scenes;
	263	rnr_element->CollectSceneParents(scenes);
	264	ScenesChanged(scenes);
	265	}
	266
	267	void ReveManager::ScenesChanged(std::list<RenderElement*>& scenes)
	268	{
	269	for (RenderElement::List_i s=scenes.begin(); s!=scenes.end(); ++s)
	270	((Scene)s)->Changed();
	271	}
	272
	273	/**************************************************************************/
	274
	275	int ReveManager::SpawnGuiAndRun(int argc, char **argv)
	276	{
	277	Int_t w = 1024;
	278	Int_t h = 768;
	279
	280	TRint theApp("App", &argc, argv);
	281
	282	Reve::SetupGUI();
	283	/* gReve = */ new ReveManager(w, h);
	284
	285	run_loop:
	286	try {
	287	theApp.Run();
	288	}
	289	catch(Exc_t& exc) {
	290	gReve->SetStatusLine(exc.Data());
	291	fprintf(stderr, "Exception: %s\n", exc.Data());
	292	goto run_loop;
	293	}
	294	return 0;
	295	}
	296
	297	void ReveManager::SpawnGui()
	298	{
	299	Int_t w = 1024;
	300	Int_t h = 768;
	301
	302	Reve::SetupGUI();
	303	/* gReve = */ new ReveManager(w, h);
	304	}
	305
	306	/**************************************************************************/
	307	/**************************************************************************/
	308
	309	TGListTree* ReveManager::GetListTree() const
	310	{
	311	return fLTEFrame->fListTree;
	312	}
	313
	314	TGListTreeItem*
	315	ReveManager::AddToListTree(RenderElement* re, Bool_t open, TGListTree* lt)
	316	{
	317	// Add rnr-el as a top-level to a list-tree.
318	// Please add a single copy of a render-element as a top level
319	// or we will have to check for that, too.
320
321	if (lt == 0) lt = GetListTree();
322	TGListTreeItem* lti = re->AddIntoListTree(lt, (TGListTreeItem*)0);
323	if (open) lt->OpenItem(lti);
324	return lti;
325	}
326
327	void ReveManager::RemoveFromListTree(RenderElement* re, TGListTree* lt, TGListTreeItem* lti)
328	{
329	// Remove top-level rnr-el from list-tree with specified tree-item.
330
331	static const Exc_t eH("ReveManager::RemoveFromListTree ");
332
333	if (lti->GetParent())
334	throw(eH + "not a top-level item.");
335
336	re->RemoveFromListTree(lt, 0);
337	}
338
339	/**************************************************************************/
340
341	TGListTreeItem* ReveManager::AddEvent(EventBase* event)
342	{
343	fCurrentEvent = event;
344	fCurrentEvent->IncDenyDestroy();
345	AddRenderElement(fCurrentEvent, fEventScene);
346	return AddToListTree(event, kTRUE);
347	}
348
349	TGListTreeItem* ReveManager::AddRenderElement(RenderElement* rnr_element,
350	RenderElement* parent)
351	{
32e219c2	352	if (parent == 0) {
	353	if (fCurrentEvent == 0)
	354	AddEvent(new EventBase("Event", "Auto-created event directory"));
	355	parent = fCurrentEvent;
	356	}
	357
e9ef1a49	358	return parent->AddElement(rnr_element);
32e219c2	359	}
	360
	361	TGListTreeItem* ReveManager::AddGlobalRenderElement(RenderElement* rnr_element,
e9ef1a49	362	RenderElement* parent)
32e219c2	363	{
32e219c2	364	if (parent == 0)
	365	parent = fGlobalScene;
	366
e9ef1a49	367	return parent->AddElement(rnr_element);
32e219c2	368	}
	369
	370	/**************************************************************************/
	371
	372	void ReveManager::RemoveRenderElement(RenderElement* rnr_element,
	373	RenderElement* parent)
	374	{
	375	parent->RemoveElement(rnr_element);
	376	}
	377
	378	void ReveManager::PreDeleteRenderElement(RenderElement* rnr_element)
	379	{
	380	if (fEditor->GetRnrElement() == rnr_element)
	381	fEditor->DisplayObject(0);
	382	}
	383
	384	/**************************************************************************/
	385
	386	void ReveManager::RenderElementSelect(RenderElement* rnr_element)
	387	{
	388	EditRenderElement(rnr_element);
	389	}
	390
	391	Bool_t ReveManager::RenderElementPaste(RenderElement* rnr_element)
	392	{
	393	RenderElement* src = fEditor->GetRnrElement();
	394	if (src)
	395	return rnr_element->HandleElementPaste(src);
	396	return kFALSE;
	397	}
	398
	399	void ReveManager::RenderElementChecked(RenderElement* rnrEl, Bool_t state)
	400	{
	401	rnrEl->SetRnrState(state);
	402
e9ef1a49	403	if (fEditor->GetModel() == rnrEl->GetEditorObject())
32e219c2	404	fEditor->DisplayRenderElement(rnrEl);
32e219c2	405
	406	rnrEl->ElementChanged();
	407	}
	408
	409	/**************************************************************************/
	410
	411	void ReveManager::NotifyBrowser(TGListTreeItem* parent_lti)
	412	{
	413	TGListTree* lt = GetListTree();
e9ef1a49	414	if (parent_lti)
32e219c2	415	lt->OpenItem(parent_lti);
	416	lt->ClearViewPort();
	417	}
	418
	419	void ReveManager::NotifyBrowser(RenderElement* parent)
	420	{
	421	TGListTreeItem* parent_lti = parent ? parent->FindListTreeItem(GetListTree()) : 0;
	422	NotifyBrowser(parent_lti);
	423	}
	424
	425	/**************************************************************************/
	426	// GeoManager registration
	427	/**************************************************************************/
	428
	429	TGeoManager* ReveManager::GetGeometry(const TString& filename)
	430	{
	431	static const Exc_t eH("ReveManager::GetGeometry ");
	432
	433	TString exp_filename = filename;
	434	gSystem->ExpandPathName(exp_filename);
	435	printf("%s loading: '%s' -> '%s'.\n", eH.Data(),
	436	filename.Data(), exp_filename.Data());
	437
	438	std::map<TString, TGeoManager*>::iterator g = fGeometries.find(filename);
e9ef1a49	439	if (g != fGeometries.end()) {
32e219c2	440	return g->second;
32e219c2	441	} else {
e9ef1a49	442	if (gSystem->AccessPathName(exp_filename, kReadPermission))
32e219c2	443	throw(eH + "file '" + exp_filename + "' not readable.");
	444	gGeoManager = 0;
	445	TGeoManager::Import(filename);
e9ef1a49	446	if (gGeoManager == 0)
32e219c2	447	throw(eH + "GeoManager import failed.");
	448	gGeoManager->GetTopVolume()->VisibleDaughters(1);
	449
	450	// Import colors exported by Gled, if they exist.
	451	{
	452	TFile f(exp_filename, "READ");
	453	TObjArray* collist = (TObjArray*) f.Get("ColorList");
	454	f.Close();
e9ef1a49	455	if (collist != 0) {
32e219c2	456	TIter next(gGeoManager->GetListOfVolumes());
	457	TGeoVolume* vol;
	458	while ((vol = (TGeoVolume*) next()) != 0)
	459	{
	460	Int_t oldID = vol->GetLineColor();
	461	TColor* col = (TColor*)collist->At(oldID);
	462	Float_t r, g, b;
	463	col->GetRGB(r, g, b);
	464	Int_t newID = TColor::GetColor(r,g,b);
	465	vol->SetLineColor(newID);
	466	}
	467	}
	468	}
	469
	470	fGeometries[filename] = gGeoManager;
	471	return gGeoManager;
	472	}
	473	}
	474
	475	/**************************************************************************/
	476	// Testing exceptions
	477	/**************************************************************************/
	478
	479	void ReveManager::SetStatusLine(const char* text)
	480	{
	481	fStatusBar->SetText(text);
	482	}
	483
	484	void ReveManager::ThrowException(const char* text)
	485	{
	486	static const Exc_t eH("ReveManager::ThrowException ");
	487
	488	throw(eH + text);
	489	}