message.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_VIEW_KERNEL_MESSAGE_H
#define BALL_VIEW_KERNEL_MESSAGE_H

#ifndef BALL_VIEW_KERNEL_STAGE_H
# include <BALL/VIEW/KERNEL/stage.h>
#endif

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

#include <boost/any.hpp>

class QWidget;

namespace BALL
{
  class Composite;
  class ConformationSet;

  namespace VIEW
  {
    class Dataset;
    class ConnectionObject;
    class GeometricObject;


class BALL_VIEW_EXPORT Message
{
  public:


  Message();

  Message(const Message& message);

  virtual ~Message();



  void setSender(const ConnectionObject* sender);

  const ConnectionObject* getSender() const;

  void setDeletable(bool flag = true);

  bool isDeletable() const;

  boost::any& data() { return data_; }

  private:

  const ConnectionObject* connection_object_;

  bool deletable_;

  boost::any data_;
};


class DatasetMessage
  : public Message
{
  public:

    enum Type
    {
      UNDEFINED = -1,

      ADD = 0,

      REMOVE,

      UPDATE,

      SELECTED,

      VISUALIZE,

      VISUALIZE_END = 100
    };

    DatasetMessage(Dataset* set = 0, Type type = UNDEFINED);

    DatasetMessage(const DatasetMessage& msg);

    Type getType() const { return type_;}

    void setType(Type type) { type_ = type;}

    Dataset* getDataset() const { return dataset_;}

    void setDataset(Dataset* set) { dataset_ = set;}

    bool isValid() const;

    protected:

    Dataset* dataset_;
    Type     type_;
    String   dataset_type_;
};

        

class BALL_VIEW_EXPORT CompositeMessage
  : public Message
{
  public:

  enum CompositeMessageType
  {
    UNDEFINED = -1,

    NEW_COMPOSITE,
    
    REMOVED_COMPOSITE,
    
    CHANGED_COMPOSITE,
    
    CHANGED_COMPOSITE_HIERARCHY,
    
    SELECTED_COMPOSITE,
    
    DESELECTED_COMPOSITE,
    
    CENTER_CAMERA,

    NEW_MOLECULE
  };


  CompositeMessage();

  CompositeMessage(const Composite& composite, CompositeMessageType type, bool update_representations = true);

  CompositeMessage(const CompositeMessage& message);

  virtual ~CompositeMessage();


  
  void setComposite(const Composite& composite);

  Composite* getComposite() const;

  void setCompositeName(const String& name);

  const String& getCompositeName() const;

  void setType(CompositeMessageType type)
     { type_ = type;}

  CompositeMessageType getType() const
     { return type_;}

  void setUpdateRepresentations(bool state)
     { update_representations_ = state;}

  bool updateRepresentations() const
     { return update_representations_;}

  void setShowSelectionInfos(bool state)
     { show_selection_infos_ = state;}

  bool showSelectionInfos()
     { return show_selection_infos_;}


  protected:

  CompositeMessageType  type_;
  Composite*            composite_;
  String                composite_name_;
  bool                  update_representations_;
  bool                  show_selection_infos_;
};


class BALL_VIEW_EXPORT SceneMessage: public Message
{
  public:

  
  enum SceneMessageType
  {
    UNDEFINED = 0,

    REBUILD_DISPLAY_LISTS,
    
    REDRAW,

    UPDATE_CAMERA,
    
    REMOVE_COORDINATE_SYSTEM,

    EXPORT_PNG,

    EXPORT_POVRAY,

    ENTER_ROTATE_MODE,

    ENTER_PICKING_MODE,

    ENTER_MOVE_MODE,

    EXPORT_FINISHED
  };



  SceneMessage(SceneMessageType type = UNDEFINED);

  SceneMessage(const SceneMessage& message);

  virtual ~SceneMessage();


  
  void setType(SceneMessageType type);

  SceneMessageType getType() const
     { return type_;}

  void setStage(Stage stage) 
     { stage_ = stage;}
  
  Stage& getStage() 
     { return stage_;}

  const Stage& getStage() const
     { return stage_;}


  private:

  SceneMessageType  type_;
  Stage             stage_;
};


class BALL_VIEW_EXPORT GenericSelectionMessage: public Message
{
  public:


  GenericSelectionMessage();

  GenericSelectionMessage(const GenericSelectionMessage& message);

  virtual ~GenericSelectionMessage();
          


  void setSelection(const std::list<Composite*>& selection);

  const std::list<Composite*>& getSelection() const;

  std::list<Composite*>& getSelection();


  private:

  std::list<Composite*> selection_;
};


class BALL_VIEW_EXPORT ControlSelectionMessage: public GenericSelectionMessage
{
  public:
  ControlSelectionMessage();
};


class BALL_VIEW_EXPORT NewSelectionMessage: public Message
{
  public:
  NewSelectionMessage();

  bool openItems()
     { return open_;}

  void setOpenItems(bool state)
     { open_ = state;}

  protected:
   bool open_;
};

class BALL_VIEW_EXPORT GeometricObjectSelectionMessage: public Message
{
  public:


  GeometricObjectSelectionMessage();

  virtual ~GeometricObjectSelectionMessage();


  
  void setSelection(const std::list<GeometricObject*>& selection)
     { selection_ = selection;}

  const std::list<GeometricObject*>& getSelection() const
     { return selection_;}

  void setSelected(bool state)
     { state_ = state;}

  bool isSelected() const
     { return state_;}


  private:

  std::list<GeometricObject*> selection_;

  bool state_;
};


class Representation;

class BALL_VIEW_EXPORT RepresentationMessage: public Message
{
  public:

  enum RepresentationMessageType
  {
    UNDEFINED = -1,

    ADD = 0,

    REMOVE,

    UPDATE,

    SELECTED,

    STARTED_UPDATE,

    FINISHED_UPDATE,

    ADD_TO_GEOMETRIC_CONTROL
  };

  RepresentationMessage();
  
  virtual ~RepresentationMessage();

  RepresentationMessage(Representation& rep, RepresentationMessageType type);

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

  Representation* getRepresentation() 
     {return representation_;}

  void setType(RepresentationMessageType type);

  RepresentationMessageType getType() const
     { return type_;}
  
  private:

  Representation*           representation_;
  RepresentationMessageType type_;
};
  

class BALL_VIEW_EXPORT MolecularTaskMessage
  : public Message
{
  public:

  enum MolecularTaskMessageType
  {
    UNDEFINED = -1,
    BUILD_BONDS,
    CHECK_RESIDUE,
    ADD_HYDROGENS,
    CREATE_DISTANCE_GRID
  };

  MolecularTaskMessage(MolecularTaskMessageType type = UNDEFINED);

  void setType(MolecularTaskMessageType type);

  MolecularTaskMessageType getType() const
     {return type_;}

  protected:
  
  MolecularTaskMessageType type_;
};


class BALL_VIEW_EXPORT ShowDisplayPropertiesMessage
  :public Message
{
  public:
    ShowDisplayPropertiesMessage()
      : Message(){};
};

class BALL_VIEW_EXPORT CreateRepresentationMessage
  :public Message
{
  public:
    CreateRepresentationMessage();

    CreateRepresentationMessage(const std::list<Composite*>& composites,
                                ModelType model_type, 
                                ColoringMethod coloring_method)
      ;   

    const std::list<Composite*>& getComposites() const
       { return composites_;}

    ModelType getModelType() const
       { return model_type_;}
    
    ColoringMethod getColoringMethod() const
       { return coloring_method_;} 
  
    private: 
    std::list<Composite*>   composites_;
    ModelType         model_type_;
    ColoringMethod    coloring_method_;
};
  

class BALL_VIEW_EXPORT DeselectControlsMessage
  : public Message
{
  public:
    DeselectControlsMessage()
      : Message() {};
};


class BALL_VIEW_EXPORT TransformationMessage
  : public Message
{
  public:

  TransformationMessage();

  TransformationMessage(const Matrix4x4& m);

  void setMatrix(const Matrix4x4& m)
     { matrix_ = m;}

  const Matrix4x4& getMatrix() const
     { return matrix_;}

  private:

  Matrix4x4 matrix_;
};


class BALL_VIEW_EXPORT FinishedSimulationMessage
  : public Message
{
  public:

  FinishedSimulationMessage();
};
  

class BALL_VIEW_EXPORT SyncClippingPlanesMessage
  : public Message
{
  public:

  SyncClippingPlanesMessage(){};
};


class BALL_VIEW_EXPORT ShowHelpMessage
  : public Message
{
  public:

  ShowHelpMessage(String url = "", String project = "BALLView", String entry = "");

  String getURL() const { return url_;}

  String getProject() const { return project_;}

  String getEntry() const { return entry_;}

  protected:

  String url_;
  String project_;
  String entry_;
};


class BALL_VIEW_EXPORT RegisterHelpSystemMessage
  : public Message
{
  public:

  RegisterHelpSystemMessage();

  void setObject(const QObject* object) { object_ = object;}

  void setURL(const String& url) { url_ = url;}

  void setRegisterMode(bool state) { register_ = state;}

  const QObject* getObject() const { return object_;}

  const String& getURL() const { return url_;}

  bool isRegister() const { return register_;}

  protected:

  const QObject* object_;
  Index    menu_entry_;
  String   url_;
  bool     register_;
};



class BALL_VIEW_EXPORT DockingFinishedMessage
  :public Message
{
  public:
    DockingFinishedMessage();

    DockingFinishedMessage(bool abort);
       
    virtual ~DockingFinishedMessage();
      
    void setConformationSet(const ConformationSet* conformation_set)
    {
      conformation_set_ = conformation_set;
    }
    
    //
    const ConformationSet* getConformationSet() const { return conformation_set_; }
    
    bool wasAborted() { return abort_; }

  protected:

    const ConformationSet* conformation_set_;
    bool abort_;
};


# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/VIEW/KERNEL/message.iC>
# endif
        
} } // namespaces

#endif // BALL_VIEW_KERNEL_MESSAGE_H