representationManager.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: representationManager.h,v 1.1.4.2 2007/03/28 13:11:43 amoll Exp $
 
#ifndef  BALL_VIEW_KERNEL_REPRESENTATIONMANAGER_H
#define  BALL_VIEW_KERNEL_REPRESENTATIONMANAGER_H
 
#ifndef BALL_VIEW_KERNEL_REPRESENTATION_H
# include <BALL/VIEW/KERNEL/representation.h>
#endif
 
#ifndef BALL_SYSTEM_MUTEX_H
#include <BALL/SYSTEM/mutex.h>
#endif
 
#include <QtCore/QCoreApplication>
#include <QtCore/QWaitCondition>
 
#include <vector>
 
using std::vector;
 
namespace BALL
{
  class Composite;
  class INIFile;
 
  namespace VIEW
  {
    class MainControl;
    class UpdateRepresentationThread;
    class ClippingPlane;

    class BALL_VIEW_EXPORT RepresentationManager
      : public Object
    {
      friend class Representation;
      friend class UpdateRepresentationThread;
      friend class BALLThread;
      friend class MainControl;
 
      public:
 
      BALL_CREATE(RepresentationManager)
 
      

      typedef HashSet<Representation*> RepresentationSet;

      typedef RepresentationList::iterator RepresentationsIterator;

      typedef RepresentationList::const_iterator RepresentationsConstIterator;

  

      RepresentationManager(MainControl* mc = 0);

      RepresentationManager(const RepresentationManager& pm);

      virtual ~RepresentationManager();

  
      
      const RepresentationManager& operator = (const RepresentationManager& pm);

      bool operator == (const RepresentationManager& pm) const;
      
      void clear();

      bool remove(Representation& representation, bool send_message = true);

      bool insert(Representation& representation, bool send_message = true);

      const RepresentationList& getRepresentations() const
        { return representations_;}

      Size getNumberOfRepresentations() const
        { return representations_.size();}

      Representation* createRepresentation();

      bool has(const Representation& representation) const;
      
      void dump(std::ostream& s, Size depth = 0) const;

      RepresentationsIterator begin() 
        { return representations_.begin();}

      RepresentationsConstIterator begin() const
        { return representations_.begin();}
      
      RepresentationsIterator end() 
        { return representations_.end();}

      RepresentationsConstIterator end() const
        { return representations_.end();}

      RepresentationList removedComposite(const Composite& composite, bool update = true);

      RepresentationList getRepresentationsOf(const Composite& composite);

      void rebuildAllRepresentations();

      const vector<ClippingPlane*>& getClippingPlanes() const { return clipping_planes_;}

      bool removeClippingPlane(ClippingPlane* plane);

      void insertClippingPlane(ClippingPlane* plane);

      void storeRepresentations(INIFile& out);
      
      void restoreRepresentations(const INIFile& in, const vector<const Composite*>& new_systems);

      void focusRepresentation(const Representation& rep);
      
      bool willBeUpdated(const Representation& rep) const;

      bool updateRunning() const ;

      bool startRendering(Representation* rep);

      void finishedRendering(Representation* rep);
      
      bool isBeeingRendered(const Representation* rep) const;
 
      protected:
    
      Representation* popRepresentationToUpdate();
 
      void finishedUpdate_(Representation* rep);
 
      /*_ Called by Representation::update() to start a multithreaded
          Update of the Representation.
          (Only used in Multithreaded code.)
      */
      void update_(Representation& rep);
 
      //_ List with all representations
      RepresentationList representations_;
      
      HashSet<Representation*> beeing_rendered_;
      HashSet<Representation*> beeing_updated_;
      HashSet<Representation*> to_update_;
 
      vector<ClippingPlane*> clipping_planes_;
      
      // we need to ensure that the mutex is always created correctly before
      // the thread that tries to access it!
      mutable Mutex               update_mutex_;
 
      UpdateRepresentationThread* thread_;
      bool                        no_update_;
      bool                        still_to_notify_;
 
      MainControl*  main_control_;
    };
 
  } // namespace VIEW
} // namespace BALL
 
#endif // BALL_VIEW_KERNEL_REPRESENTATIONMANAGER_H