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