threads.h

#ifndef BALL_VIEW_KERNEL_THREADS_H
#define BALL_VIEW_KERNEL_THREADS_H

#ifndef BALL_VIEW_KERNEL_COMMON_H_
#include <BALL/VIEW/KERNEL/common.h>
#endif

#ifndef BALL_SYSTEM_TCPTRANSFER
# include <BALL/SYSTEM/TCPTransfer.h>
#endif

#include <QtCore/QThread>
#include <QtCore/QEvent>

namespace BALL
{
  class EnergyMinimizer;
  class MolecularDynamics;
  class Composite;
  class DockingAlgorithm;
  class DCDFile;

namespace VIEW
{
  class MainControl;
  class FDPBDialog;
  class Message;
  class Representation;

  class BALL_VIEW_EXPORT MessageEvent
    : public QEvent
  {
    public:

    MessageEvent(Message* msg = 0)
    : QEvent((QEvent::Type)MESSAGE_EVENT),
      message_(msg)
    {}

    void setMessage(Message* msg) { message_ = msg; }

    Message* getMessage() { return message_; }

    protected:

    Message* message_;
  };


  class BALL_VIEW_EXPORT BALLThread
    : public virtual QThread
  {
    public:

      BALLThread();
      
      void setMainControl(MainControl* mf) {main_control_ = mf;}
      
      void setComposite(Composite* composite) {composite_ = composite;}

      Composite* getComposite() { return composite_;}
  
      virtual void run() {};
      
      protected:

      void sendMessage_(Message* msg);

      void updateStructure_();

      void output_(const String& string, bool important = false);

      void waitForUpdateOfRepresentations_();
  
      MainControl*  main_control_;
      Composite*    composite_;
    };

  
  class BALL_VIEW_EXPORT FetchHTMLThread
    : public BALLThread
  {
    public:
      FetchHTMLThread();

      void setURL(const String& text);

      virtual void run();

      virtual void abort() { tcp_.abort();}

      void setFilename(const String& file_name) { file_name_ = file_name;}

      const String& getFilename() const { return file_name_;}

      TCPTransfer& getTCPTransfer() { return tcp_;}

      std::stringstream& getStream() { return stream_;}

      protected:
      String url_;
      String file_name_;
      TCPTransfer tcp_;
      std::stringstream stream_;
  };
  
  class BALL_VIEW_EXPORT CalculateFDPBThread
    : public BALLThread
  {
    public:

      CalculateFDPBThread();

      virtual void run();

      void setFDPBDialog(FDPBDialog* dialog) {dialog_ = dialog;}

    protected:
      FDPBDialog* dialog_;
  };


  class BALL_VIEW_EXPORT UpdateRepresentationThread
    : public BALLThread
  {
    public:

      UpdateRepresentationThread();

      virtual void run();

      void setRepresentation(Representation& rep)
        { rep_ = &rep;}

      Representation* getRepresentation()
        { return rep_; }

    protected:

      Representation* rep_;
  };


  class BALL_VIEW_EXPORT SimulationThread
    : public BALLThread
  {
    public:

      SimulationThread();

      void setNumberOfStepsBetweenUpdates(Size steps)
        { steps_between_updates_ = steps;}

      void setDCDFile(DCDFile* file) {dcd_file_ = file;}

      DCDFile* getDCDFile() { return dcd_file_;}

      protected:
  
      void exportSceneToPNG_();

      void finish_();

      Size          steps_between_updates_;
      DCDFile*      dcd_file_;
    };


    class BALL_VIEW_EXPORT EnergyMinimizerThread
      : public SimulationThread
    {
      public:

        EnergyMinimizerThread();
        
        virtual ~EnergyMinimizerThread();
        
        virtual void run();

        void setEnergyMinimizer(EnergyMinimizer* minimizer);

      protected:
        EnergyMinimizer* minimizer_;
    };


    class BALL_VIEW_EXPORT MDSimulationThread
      : public SimulationThread
    {
      public:

        MDSimulationThread();
        
        virtual ~MDSimulationThread();
        
        virtual void run()
          throw(Exception::NullPointer);

        void setMolecularDynamics(MolecularDynamics* md);

        void setNumberOfSteps(Size steps) { steps_ = steps;}

        void setSaveImages(bool state) { save_images_ = state;}

      protected:
        MolecularDynamics* md_;
        Size steps_;
        bool save_images_;
    };


    class BALL_VIEW_EXPORT DockingThread
      : public BALLThread
    {
      public:
        DockingThread();
        
        DockingThread(const DockingThread& dock_thread);
          
        virtual ~DockingThread();
        
        const DockingThread& operator =(const DockingThread& dock_thread);
          
        void setDockingAlgorithm(DockingAlgorithm* dock_alg);
          
        virtual void run()
          throw(Exception::NullPointer);
          
      protected:
        DockingAlgorithm* dock_alg_;
    };
  
  }
}
#endif //BALL_VIEW_KERNEL_THREADS_H

---