source: src/UIElements/Views/Qt4/QtInstanceInformationBoard.hpp@ 8d5fbf1

/*
 * QtInstanceInformationBoard.hpp
 *
 *  Created on: Oct 17, 2015
 *      Author: heber
 */


#ifndef QTINSTANCEINFORMATIONBOARD_HPP_
#define QTINSTANCEINFORMATIONBOARD_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <QtGui/QWidget>

#include <map>
#include <vector>

#include <boost/any.hpp>

#include "CodePatterns/Observer/Observer.hpp"
#include "CodePatterns/ObservedValue.hpp"

#include "types.hpp"

class GLWorldScene;
class GLMoleculeObject_atom;
class GLMoleculeObject_bond;
class GLMoleculeObject_molecule;

/** The QtInstanceInformationBoard is the central class for communicating instance
 * creation and destruction from MoleCuilder into the QtGui realm. It should be
 * thought of as an interface to allow for safe multi-threaded computing.
 *
 * The idea is as follows: As soon as a molecule is instantiated, all the QtGui
 * needs to access the instance (for displaying it) is wrapped up in a
 * ObservedValue. This ObservedValue separates the lifetime of the molecule object
 * from the information contained therein and thus makes the visual representation
 * independent of the life time. The Observer/Observable signal from the World,
 * i.e. World::MoleculeInserted, is caught (directly within the same thread) by
 * the QtInstanceInformationBoard. Here, we instantiate all ObservedValue's needed
 * for this specific molecule and store them in an internal map. Next, we emit
 * a Qt signal informing the QtGui part about the new molecule.
 * At some later stage, the QtGui will (probably in a different thread)
 * instantiate a GLMoleculeObject_molecule as a visual representation of the
 * molecule. It requests the ObservedValues from the QtInstanceInformationBoard
 * and uses these directly.
 * The QtInstanceInformationBoard also records all subjectKilled() signals from
 * each ObservedValue. Additionally, each class using the ObservedValues
 * additionally informs the QtInstanceInformationBoard when subjectKilled() was
 * called. If subjectKilled() for each ObservedValue of a molecule and from the
 * visual representation have been received, a removal Qt signal is emitted.
 *
 * The same holds for the atom
 */
class QtInstanceInformationBoard : public QWidget, public Observer
{
  Q_OBJECT

public:
  /** typedef for a vector of ObservedValue's (each is due to templating its
   * own type. Therefore, we need to use boost::any).
   */
  typedef std::vector<boost::any> ObservedValues_t;

  /** Cstor of QtInstanceInformationBoard.
   *
   */
  QtInstanceInformationBoard(QWidget * _parent=0);

  /** Dstor of QtInstanceInformationBoard.
   *
   */
  ~QtInstanceInformationBoard();

  // Observer functions
  void update(Observable *publisher);
  void subjectKilled(Observable *publisher);
  void recieveNotification(Observable *publisher, Notification_ptr notification);

  ObservedValues_t getAtomObservedValues(const atomId_t _id);
  ObservedValues_t getMoleculeObservedValues(const moleculeId_t _id);

  void returnAtomObservedValues(const atomId_t _id, ObservedValues_t &_observedvalues);
  void returnMoleculeObservedValues(const moleculeId_t _id, ObservedValues_t &_observedvalues);

signals:
  void atomInserted(const moleculeId_t _molid, const atomId_t _atomid);
  void atomRemoved(const moleculeId_t _molid, const atomId_t _atomid);
  void atomIndexChanged(const atomId_t _oldid, const atomId_t _newid);
  void moleculeInserted(const moleculeId_t _molid);
  void moleculeRemoved(const moleculeId_t _molid);
  void moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid);

private:
  friend class GLWorldScene;
  friend class GLMoleculeObject_atom;
  friend class GLMoleculeObject_bond;
  friend class GLMoleculeObject_molecule;

  //!> indicating whether we are still signedOn to World or not
  bool WorldSignedOn;

  typedef std::multiset<Observable *> SignedOn_t;
  //!> map indicating to which atom we are currently signed on
  SignedOn_t AtomSignedOn;
  //!> map indicating to which molecule we are currently signed on
  SignedOn_t MoleculeSignedOn;

  /** Counts how many atom's ObservedValues got subjectKilled.
   *
   * This is used to give removal signal only when each and every
   * ObservedValue (and the instance itself) has been subjectKilled by the
   * monitored Observable. Only then can we safely remove the instance.
   *
   * \param _atomid id of the atom
   */
  void atomcountsubjectKilled(const atomId_t _atomid);

  /** Counts how many molecule's ObservedValues got subjectKilled.
   *
   * This is used to give removal signal only when each and every
   * ObservedValue (and the instance itself) has been subjectKilled by the
   * monitored Observable. Only then can we safely remove the instance.
   *
   * \param _molid id of the molecule
   */
  void moleculecountsubjectKilled(const moleculeId_t _molid);

  //!> typedef for map with subjectKilledCounts for each atom
  typedef typename std::map<atomId_t, size_t> atomsubjectKilledCount_t;

  //!> typedef for map with subjectKilledCounts for each molecule
  typedef typename std::map<moleculeId_t, size_t> moleculesubjectKilledCount_t;

  //!> counts how many ObservedValues have already been subjectKilled()
  atomsubjectKilledCount_t atomsubjectKilledCount;

  //!> counts how many ObservedValues have already been subjectKilled()
  moleculesubjectKilledCount_t moleculesubjectKilledCount;

  //!> typedef for the map of id to each one's ObservedValues
  typedef typename std::map<atomId_t, ObservedValues_t> atomObservedValues_t;
  //!> map containing all ObservedValues for each atom, associated by id
  atomObservedValues_t atomObservedValues;

  //!> typedef for the map of id to each one's ObservedValues
  typedef typename std::map<moleculeId_t, ObservedValues_t> moleculeObservedValues_t;
  //!> map containing all ObservedValues for each molecule, associated by id
  moleculeObservedValues_t moleculeObservedValues;

  //!> stored callback function for notifying QtInstanceInformationBoard about subjectKilled in atom
  boost::function<void (atomId_t)> atomSubjectKilled;
  //!> stored callback function for notifying QtInstanceInformationBoard about subjectKilled in molecule
  boost::function<void (moleculeId_t)> moleculeSubjectKilled;

  //!> note down atom id of last removed atom to drop its ObservedValues
  atomId_t lastremovedatom;

  //!> note down atom id of last removed atom to drop its ObservedValues
  std::pair<moleculeId_t, atomId_t> lastremovedatomsmolecule;

  //!> note down molecule id of last removed molecule to drop its ObservedValues
  moleculeId_t lastremovedmolecule;

};

#endif /* QTINSTANCEINFORMATIONBOARD_HPP_ */