REveManager.hxx

Go to the documentation of this file.

// @(#)root/eve7:$Id$
// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007, 2018

/*************************************************************************
 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT7_REveManager
#define ROOT7_REveManager

#include <ROOT/REveElement.hxx>

#include <ROOT/RWebDisplayArgs.hxx>

#include "TSysEvtHandler.h"
#include "TTimer.h"

#include <memory>
#include <unordered_map>

class TMap;
class TExMap;
class TMacro;
class TFolder;
class TGeoManager;

namespace ROOT {
namespace Experimental {

class REveSelection;
class REveViewer;
class REveViewerList;
class REveScene;
class REveSceneList;

class RWebWindow;
class REveGeomViewer;

class REveManager
{
   REveManager(const REveManager&);            // Not implemented
   REveManager& operator=(const REveManager&); // Not implemented

public:
   class RRedrawDisabler {
   private:
      RRedrawDisabler(const RRedrawDisabler &);            // Not implemented
      RRedrawDisabler &operator=(const RRedrawDisabler &); // Not implemented

      REveManager *fMgr{nullptr};

   public:
      RRedrawDisabler(REveManager *m) : fMgr(m)
      {
         if (fMgr)
            fMgr->DisableRedraw();
      }
      virtual ~RRedrawDisabler()
      {
         if (fMgr)
            fMgr->EnableRedraw();
      }
   };

   class RExceptionHandler : public TStdExceptionHandler {
   public:
      RExceptionHandler() : TStdExceptionHandler() { Add(); }
      virtual ~RExceptionHandler()                 { Remove(); }

      virtual EStatus  Handle(std::exception& exc);

      ClassDef(RExceptionHandler, 0);
   };

   struct Conn
   {
      unsigned fId{0};

      Conn() = default;
      Conn(unsigned int cId) : fId(cId) {}
   };

protected:
   RExceptionHandler        *fExcHandler{nullptr};   //!< exception handler

   TMap                     *fVizDB{nullptr};
   Bool_t                    fVizDBReplace{kFALSE};
   Bool_t                    fVizDBUpdate{kFALSE};

   TMap                     *fGeometries{nullptr};      //  TODO: use std::map<std::string, std::unique_ptr<TGeoManager>>
   TMap                     *fGeometryAliases{nullptr}; //  TODO: use std::map<std::string, std::string>

   TFolder                  *fMacroFolder{nullptr};

   REveScene                *fWorld{nullptr};

   REveViewerList           *fViewers{nullptr};
   REveSceneList            *fScenes{nullptr};

   REveScene                *fGlobalScene{nullptr};
   REveScene                *fEventScene{nullptr};

   Int_t                     fRedrawDisabled{0};
   Bool_t                    fFullRedraw{kFALSE};
   Bool_t                    fResetCameras{kFALSE};
   Bool_t                    fDropLogicals{kFALSE};
   Bool_t                    fKeepEmptyCont{kFALSE};
   Bool_t                    fTimerActive{kFALSE};
   TTimer                    fRedrawTimer;

   // ElementId management
   std::unordered_map<ElementId_t, REveElement*> fElementIdMap;
   ElementId_t                                   fLastElementId{0};
   ElementId_t                                   fNumElementIds{0};
   ElementId_t                                   fMaxElementIds{std::numeric_limits<ElementId_t>::max()};

   // Selection / highlight elements
   REveElement              *fSelectionList{nullptr};
   REveSelection            *fSelection{nullptr};
   REveSelection            *fHighlight{nullptr};

   std::shared_ptr<ROOT::Experimental::RWebWindow>  fWebWindow;
   std::vector<Conn>                                fConnList;

   void WindowConnect(unsigned connid);
   void WindowData(unsigned connid, const std::string &arg);
   void WindowDisconnect(unsigned connid);

public:
   REveManager(); // (Bool_t map_window=kTRUE, Option_t* opt="FI");
   virtual ~REveManager();

   RExceptionHandler *GetExcHandler() const { return fExcHandler; }

   REveSelection *GetSelection() const { return fSelection; }
   REveSelection *GetHighlight() const { return fHighlight; }

   REveSceneList *GetScenes() const { return fScenes; }
   REveViewerList *GetViewers() const { return fViewers; }

   REveScene *GetGlobalScene() const { return fGlobalScene; }
   REveScene *GetEventScene() const { return fEventScene; }

   REveScene *GetWorld() const { return fWorld; }

   REveViewer *SpawnNewViewer(const char *name, const char *title = "");
   REveScene *SpawnNewScene(const char *name, const char *title = "");

   TFolder *GetMacroFolder() const { return fMacroFolder; }
   TMacro *GetMacro(const char *name) const;

   void DisableRedraw() { ++fRedrawDisabled; }
   void EnableRedraw()  { --fRedrawDisabled; if (fRedrawDisabled <= 0) Redraw3D(); }

   void Redraw3D(Bool_t resetCameras = kFALSE, Bool_t dropLogicals = kFALSE)
   {
      if (fRedrawDisabled <= 0 && !fTimerActive) RegisterRedraw3D();
      if (resetCameras) fResetCameras = kTRUE;
      if (dropLogicals) fDropLogicals = kTRUE;
   }
   void RegisterRedraw3D();
   void DoRedraw3D();
   void FullRedraw3D(Bool_t resetCameras = kFALSE, Bool_t dropLogicals = kFALSE);

   void ClearAllSelections();

   Bool_t GetKeepEmptyCont() const   { return fKeepEmptyCont; }
   void   SetKeepEmptyCont(Bool_t k) { fKeepEmptyCont = k; }

   void AddElement(REveElement *element, REveElement* parent = nullptr);
   void AddGlobalElement(REveElement *element, REveElement* parent = nullptr);

   void RemoveElement(REveElement* element, REveElement* parent);

   REveElement* FindElementById (ElementId_t id) const;
   void         AssignElementId (REveElement* element);
   void         PreDeleteElement(REveElement* element);

   // VizDB - Visualization-parameter data-base.
   Bool_t       InsertVizDBEntry(const TString& tag, REveElement* model,
                                 Bool_t replace, Bool_t update);
   Bool_t       InsertVizDBEntry(const TString& tag, REveElement* model);
   REveElement* FindVizDBEntry  (const TString& tag);

   void         LoadVizDB(const TString& filename, Bool_t replace, Bool_t update);
   void         LoadVizDB(const TString& filename);
   void         SaveVizDB(const TString& filename);

   Bool_t GetVizDBReplace()   const { return fVizDBReplace; }
   Bool_t GetVizDBUpdate ()   const { return fVizDBUpdate;  }
   void   SetVizDBReplace(Bool_t r) { fVizDBReplace = r; }
   void   SetVizDBUpdate (Bool_t u) { fVizDBUpdate  = u; }


   // Geometry management.
   TGeoManager* GetGeometry(const TString& filename);
   TGeoManager* GetGeometryByAlias(const TString& alias);
   TGeoManager* GetDefaultGeometry();
   void         RegisterGeometryAlias(const TString& alias, const TString& filename);

   void ClearROOTClassSaved();

   void AddLocation(const std::string& name, const std::string& path);
   void SetDefaultHtmlPage(const std::string& path);
   void SetClientVersion(const std::string& version);
   
   static REveManager* Create();
   static void         Terminate();

   // Access to internals, needed for low-level control in advanced
   // applications.

   void EnforceTimerActive (Bool_t ta) { fTimerActive = ta; }

   // void Send(void* buff, unsigned connid);
   void Send(unsigned connid, const std::string &data);
   void SendBinary(unsigned connid, const void *data, std::size_t len);

   void DestroyElementsOf(REveElement::List_t &els);

   void BroadcastElementsOf(REveElement::List_t &els);

   void Show(const RWebDisplayArgs &args = "");

   std::shared_ptr<REveGeomViewer> ShowGeometry(const RWebDisplayArgs &args = "");
};

R__EXTERN REveManager* gEve;

}}

#endif