REveScene.hxx

Go to the documentation of this file.

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

/*************************************************************************
 * 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_REveScene
#define ROOT7_REveScene

#include <ROOT/REveElement.hxx>

#include "TClass.h"

#include <vector>
#include <memory>

namespace ROOT {
namespace Experimental {

class REveClient;
class REveManager;

/******************************************************************************/
// REveScene
// REve representation of TGLScene.
/******************************************************************************/

class REveScene : public REveElement
{
   friend class REveManager;

private:
   REveScene(const REveScene &);            // Not implemented
   REveScene &operator=(const REveScene &); // Not implemented

protected:
   struct SceneCommand
   {
      std::string fName;
      std::string fIcon;
      std::string fElementClass;
      std::string fAction;
      ElementId_t fElementId;

      SceneCommand(const std::string& name, const std::string& icon,
                   const REveElement* element, const std::string& action) :
         fName(name),
         fIcon(icon),
         fElementClass(element->IsA()->GetName()),
         fAction(action),
         fElementId(element->GetElementId())
      {}
   };

   Bool_t fSmartRefresh{kTRUE};            ///<!
   Bool_t fHierarchical{kFALSE};           ///<!

   Bool_t fAcceptingChanges{kFALSE};       ///<!
   Bool_t fChanged{kFALSE};                ///<!
   // Changed or/and added.
   // XXXX can change to vector (element checks if already registered now).
   List_t  fChangedElements;               ///<!
   // For the following two have to re-think how the hierarchy will be handled.
   // If I remove a parent, i have to remove all the children.
   // So this has to be done right on both sides (on eve element and here).
   // I might need a set, so i can easily check if parent is in the removed / added list already.
   std::vector<ElementId_t> fRemovedElements; ///<!

   std::vector<std::unique_ptr<REveClient>> fSubscribers; ///<!

   List_t fElsWithBinaryData;
   std::string fOutputJson;               ///<!
   std::vector<char> fOutputBinary;       ///<!
   Int_t fTotalBinarySize;                ///<!

   std::vector<SceneCommand> fCommands;   ///<!

   // void RetransHierarchicallyRecurse(REveElement* el, const REveTrans& tp);

public:
   REveScene(const std::string &n = "REveScene", const std::string &t = "");
   virtual ~REveScene();

   Bool_t SingleRnrState() const override { return kTRUE; }

   void   SetHierarchical(Bool_t h) { fHierarchical = h; }
   Bool_t GetHierarchical() const { return fHierarchical; }

   void   Changed() { fChanged = kTRUE; } // AMT ??? depricated
   Bool_t IsChanged() const;

   Bool_t IsAcceptingChanges() const { return fAcceptingChanges; }
   void BeginAcceptingChanges();
   void SceneElementChanged(REveElement *element);
   void SceneElementRemoved(ElementId_t id);
   void EndAcceptingChanges();
   void ProcessChanges();

   void StreamElements();
   void StreamJsonRecurse(REveElement *el, nlohmann::json &jobj);

   // void   Repaint(Bool_t dropLogicals=kFALSE);
   // void   RetransHierarchically();

   // virtual void Paint(Option_t* option = "");

   // void DestroyElementRenderers(REveElement* element);
   // void DestroyElementRenderers(TObject* rnrObj);
   void StreamRepresentationChanges();
   void SendChangesToSubscribers();

   Bool_t HasSubscribers() const { return !fSubscribers.empty(); }
   void AddSubscriber(std::unique_ptr<REveClient> &&sub);
   void RemoveSubscriber(unsigned int);

   void AddCommand(const std::string &name, const std::string &icon, const REveElement *element, const std::string &action)
   { fCommands.emplace_back(name, icon, element, action); }
};

/******************************************************************************/
// REveSceneList
// List of Scenes providing common operations on REveScene collections.
/******************************************************************************/

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

protected:
public:
   REveSceneList(const std::string& n = "REveSceneList", const std::string& t = "");
   virtual ~REveSceneList() {}

   void DestroyScenes();

   // void RepaintChangedScenes(Bool_t dropLogicals);
   // void RepaintAllScenes(Bool_t dropLogicals);

   // void DestroyElementRenderers(REveElement* element);
   void AcceptChanges(bool);

   void ProcessSceneChanges();
};

} // namespace Experimental
} // namespace ROOT

#endif