EVE/Reve/ReveManager.cxx

   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 {
  74   // Constructor.
  75
  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()
 146 {
 147   // Destructor.
 148 }
 149
 150 /**************************************************************************/
 151
 152 TCanvas* ReveManager::AddCanvasTab(const char* name)
 153 {
 154   // Add a new canvas tab.
 155
 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 {
 166   // Get the main window, i.e. the first created reve-browser.
 167
 168   return fBrowser;
 169 }
 170
 171 TGLViewer* ReveManager::GetGLViewer() const
 172 {
 173   // Get default TGLViewer.
 174
 175   return fViewer->GetGLViewer();
 176 }
 177
 178 Viewer* ReveManager::SpawnNewViewer(const Text_t* name, const Text_t* title,
 179                                     Bool_t embed)
 180 {
 181   // Create a new GL viewer.
 182
 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 {
 195   // Create a new scene.
 196
 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 {
 228   // Register a request for 3D redraw.
 229
 230   fRedrawTimer.Start(0, kTRUE);
 231   fTimerActive = true;
 232 }
 233
 234 void ReveManager::DoRedraw3D()
 235 {
 236   // Perform 3D redraw of scenes and viewers whose contents has
 237   // changed.
 238
 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 {
 252   // Perform 3D redraw of all scenes and viewers.
 253
 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 {
 352   if (parent == 0) {
 353     if (fCurrentEvent == 0)
 354       AddEvent(new EventBase("Event", "Auto-created event directory"));
 355     parent = fCurrentEvent;
 356   }
 357
 358   return parent->AddElement(rnr_element);
 359 }
 360
 361 TGListTreeItem* ReveManager::AddGlobalRenderElement(RenderElement* rnr_element,
 362                                                     RenderElement* parent)
 363 {
 364   if (parent == 0)
 365     parent = fGlobalScene;
 366
 367   return parent->AddElement(rnr_element);
 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
 403   if (fEditor->GetModel() == rnrEl->GetEditorObject())
 404     fEditor->DisplayRenderElement(rnrEl);
 405
 406   rnrEl->ElementChanged();
 407 }
 408
 409 /**************************************************************************/
 410
 411 void ReveManager::NotifyBrowser(TGListTreeItem* parent_lti)
 412 {
 413   TGListTree* lt = GetListTree();
 414   if (parent_lti)
 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);
 439   if (g != fGeometries.end()) {
 440     return g->second;
 441   } else {
 442     if (gSystem->AccessPathName(exp_filename, kReadPermission))
 443       throw(eH + "file '" + exp_filename + "' not readable.");
 444     gGeoManager = 0;
 445     TGeoManager::Import(filename);
 446     if (gGeoManager == 0)
 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();
 455       if (collist != 0) {
 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 }