Changes in / [53059e:c0ed1e]


Ignore:
Location:
src
Files:
4 deleted
30 edited

Legend:

Unmodified
Added
Removed

  • src/Element/element.hpp

    r53059e rc0ed1e  
    9090    double CovalentRadius;  //!< covalent radius
    9191    double Electronegativity; //!< electronegativity in Pauling units
    92     double VanDerWaalsRadius;  //!< van-der-Waals radius
     92    double VanDerWaalsRadius;  //!< can-der-Waals radius
    9393    atomicNumber_t Z;          //!< atomic number
    9494    std::string period;    //!< period: n quantum number

  • src/UIElements/Makefile.am

    r53059e rc0ed1e  
    199199  UIElements/Views/Qt4/QtWorldView.cpp \
    200200  UIElements/Views/Qt4/QtMoleculeView.cpp \
    201   UIElements/Views/Qt4/QtElementList.cpp \
    202201  UIElements/Views/Qt4/QtStatusBar.cpp \
    203202  UIElements/Views/Qt4/Qt3D/GLWorldView.cpp \
    … …  
    205204        UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp \
    206205        UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp \
    207         UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp \
    208         UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp
     206        UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp
    209207#  UIElements/Views/Qt4/dialoglight.cpp
    210208             
    … …  
    232230  UIElements/Views/Qt4/QtWorldView.hpp \
    233231  UIElements/Views/Qt4/QtMoleculeView.hpp \
    234   UIElements/Views/Qt4/QtElementList.hpp \
    235232  UIElements/Views/Qt4/QtStatusBar.hpp \
    236233  UIElements/Views/Qt4/Qt3D/GLWorldView.hpp \
    … …  
    238235        UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp \
    239236        UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp \
    240         UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp \
    241         UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp
     237        UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp
    242238
    243239QTUIUI_UIFILES = \

  • src/UIElements/Qt4/Pipe/BooleanQtQueryPipe.cpp

    r53059e rc0ed1e  
    2525#include "CodePatterns/MemDebug.hpp"
    2626
    27 BooleanQtQueryPipe::BooleanQtQueryPipe(bool *_content, QtDialog *_dialog, QCheckBox *_booleanCheckBox) :
     27BooleanQtQueryPipe::BooleanQtQueryPipe(const bool *_content, QtDialog *_dialog, QComboBox *_booleanComboBox) :
    2828  content(_content),
    2929  dialog(_dialog),
    30   booleanCheckBox(_booleanCheckBox)
     30  booleanComboBox(_booleanComboBox)
    3131{}
    3232
    … …  
    3434{}
    3535
    36 void BooleanQtQueryPipe::update(int state) {
    37   (*content) = (state == Qt::Checked);
     36void BooleanQtQueryPipe::update() {
    3837  dialog->update();
    3938}

  • src/UIElements/Qt4/Pipe/BooleanQtQueryPipe.hpp

    r53059e rc0ed1e  
    1818
    1919class QtDialog;
    20 class QCheckBox;
     20class QComboBox;
    2121
    2222class BooleanQtQueryPipe : public QWidget {
    2323  Q_OBJECT
    2424public:
    25   BooleanQtQueryPipe(bool *_content, QtDialog *_dialog, QCheckBox *_booleanCheckBox);
     25  BooleanQtQueryPipe(const bool *_content, QtDialog *_dialog, QComboBox *_booleanComboBox);
    2626  virtual ~BooleanQtQueryPipe();
    2727
    2828public slots:
    29   void update(int state);
     29  void update();
    3030
    3131private:
    32   bool *content;
     32  const bool *content;
    3333  QtDialog *dialog;
    34   QCheckBox *booleanCheckBox;
     34  QComboBox *booleanComboBox;
    3535};
    3636

  • src/UIElements/Qt4/Pipe/BoxQtQueryPipe.cpp

    r53059e rc0ed1e  
    3434{
    3535  tmpM = new RealSpaceMatrix();
    36   tmpM->setIdentity();
     36  tmpM->setZero();
    3737}
    3838

  • src/UIElements/Qt4/Pipe/VectorQtQueryPipe.cpp

    r53059e rc0ed1e  
    3535{}
    3636
    37 void VectorQtQueryPipe::updateX(double newDouble) {
    38   (*content)[0] = newDouble;
     37void VectorQtQueryPipe::update() {
    3938  dialog->update();
    4039}
    4140
    42 void VectorQtQueryPipe::updateY(double newDouble) {
    43   (*content)[1] = newDouble;
    44   dialog->update();
    45 }
    46 
    47 void VectorQtQueryPipe::updateZ(double newDouble) {
    48   (*content)[2] = newDouble;
    49   dialog->update();
    50 }
    51 

  • src/UIElements/Qt4/Pipe/VectorQtQueryPipe.hpp

    r53059e rc0ed1e  
    2929
    3030public slots:
    31   void updateX(double);
    32   void updateY(double);
    33   void updateZ(double);
     31  void update();
    3432
    3533private:

  • src/UIElements/Qt4/QtMainWindow.cpp

    r53059e rc0ed1e  
    3333#include "Menu/Qt4/QtMenu.hpp"
    3434#include "Views/Qt4/QtWorldView.hpp"
    35 #include "Views/Qt4/QtElementList.hpp"
    3635#include "Views/Qt4/QtMoleculeView.hpp"
    3736#include "Views/Qt4/QtStatusBar.hpp"
    … …  
    5251  QSplitter *splitter1 = new QSplitter (Qt::Horizontal, this );
    5352  QSplitter *splitter2 = new QSplitter (Qt::Vertical, splitter1 );
    54   QTabWidget *worldTab = new QTabWidget(splitter2);
    5553
    56   worldDisplay = new QtWorldView(worldTab);
    57   elementList = new QtElementList(worldTab);
     54  worldDisplay = new QtWorldView(splitter2);
    5855
    5956  moleculeDisplay = new QtMoleculeView();
    … …  
    7168  splitter1->addWidget(moleculeDisplay);
    7269  splitter2->addWidget(molecule3dDisplay);
    73   splitter2->addWidget(worldTab);
    74   worldTab->addTab(worldDisplay, "Molecules");
    75   worldTab->addTab(elementList, "All Elements");
     70  splitter2->addWidget(worldDisplay);
    7671
    7772  statusBar = new QtStatusBar(this);

  • src/UIElements/Qt4/QtMainWindow.hpp

    r53059e rc0ed1e  
    2424
    2525class QtWorldView;
    26 class QtElementList;
    2726class StringView;
    2827class GLWorldView;
    … …  
    4544  QApplication *theApp;
    4645  QtWorldView *worldDisplay;
    47   QtElementList *elementList;
    4846  GLWorldView *molecule3dDisplay;
    4947  QtMoleculeView *moleculeDisplay;

  • src/UIElements/Qt4/Query/BooleanQtQuery.cpp

    r53059e rc0ed1e  
    1919
    2020#include <Qt/qboxlayout.h>
    21 #include <Qt/qcheckbox.h>
     21#include <Qt/qcombobox.h>
    2222#include <Qt/qlabel.h>
    2323
    … …  
    3232    parent(_parent)
    3333{
    34   thisLayout = new QHBoxLayout();
    3534  titleLabel = new QLabel(QString(getTitle().c_str()),_dialog);
    36   booleanCheckBox = new QCheckBox(QString(getTitle().c_str()), _dialog);
     35  booleanComboBox = new QComboBox(_dialog);
     36  booleanComboBox->insertItem(1, QString("true"));
     37  booleanComboBox->insertItem(0, QString("false"));
    3738
    3839  parent->addLayout(thisLayout);
    3940  thisLayout->addWidget(titleLabel);
    40   thisLayout->addWidget(booleanCheckBox);
     41  thisLayout->addWidget(booleanComboBox);
    4142
    42   pipe = new BooleanQtQueryPipe(&tmp,_dialog,booleanCheckBox);
    43   connect(booleanCheckBox, SIGNAL(stateChanged(int)), pipe, SLOT(update(int)));
     43  pipe = new BooleanQtQueryPipe(&tmp,_dialog,booleanComboBox);
     44  connect(booleanComboBox, SIGNAL(currentIndexChanged()), pipe, SLOT(update()));
    4445}
    4546

  • src/UIElements/Qt4/Query/QtQuery.hpp

    r53059e rc0ed1e  
    2929class QTextEdit;
    3030class QComboBox;
    31 class QCheckBox;
    3231
    3332// Forward declarations for plumbing
    … …  
    9291  QBoxLayout *thisLayout;
    9392  QLabel *titleLabel;
    94   QCheckBox *booleanCheckBox;
     93  QComboBox *booleanComboBox;
    9594
    9695  BooleanQtQueryPipe *pipe;
    … …  
    326325  QBoxLayout *coordLayout;
    327326  QLabel *coordLabel;
    328   QDoubleSpinBox *coordInputX;
    329   QDoubleSpinBox *coordInputY;
    330   QDoubleSpinBox *coordInputZ;
     327  QDoubleSpinBox *coordInput;
    331328
    332329  VectorQtQueryPipe *pipe;

  • src/UIElements/Qt4/Query/VectorQtQuery.cpp

    r53059e rc0ed1e  
    4343  coordLabel = new QLabel(QString("x,y,z"));
    4444  coordLayout->addWidget(coordLabel);
    45   coordInputX = new QDoubleSpinBox();
    46   coordInputX->setRange(-std::numeric_limits<double>::max(),std::numeric_limits<double>::max());
    47 //  coordInputX->setRange(0,M.at(i,i));
    48   coordInputX->setDecimals(3);
    49   coordLayout->addWidget(coordInputX);
    50   coordInputY = new QDoubleSpinBox();
    51   coordInputY->setRange(-std::numeric_limits<double>::max(),std::numeric_limits<double>::max());
    52 //  coordInputY->setRange(0,M.at(i,i));
    53   coordInputY->setDecimals(3);
    54   coordLayout->addWidget(coordInputY);
    55   coordInputZ = new QDoubleSpinBox();
    56   coordInputZ->setRange(-std::numeric_limits<double>::max(),std::numeric_limits<double>::max());
    57 //  coordInputZ->setRange(0,M.at(i,i));
    58   coordInputZ->setDecimals(3);
    59   coordLayout->addWidget(coordInputZ);
     45  coordInput = new QDoubleSpinBox();
     46//  coordInput->setRange(0,M.at(i,i));
     47  coordInput->setDecimals(3);
     48  coordLayout->addWidget(coordInput);
    6049  pipe = new VectorQtQueryPipe(&(tmp),_dialog,inputBox);
    6150  //pipe->update(coordInput->value());
    62   connect(coordInputX,SIGNAL(valueChanged(double)),pipe,SLOT(updateX(double)));
    63   connect(coordInputY,SIGNAL(valueChanged(double)),pipe,SLOT(updateY(double)));
    64   connect(coordInputZ,SIGNAL(valueChanged(double)),pipe,SLOT(updateZ(double)));
     51  connect(coordInput,SIGNAL(valueChanged(double)),pipe,SLOT(update(double)));
    6552  parent->addLayout(mainLayout);
    6653}

  • src/UIElements/Query/BooleanQuery.cpp

    r53059e rc0ed1e  
    2525// Bool Queries
    2626Dialog::BooleanQuery::BooleanQuery(std::string title,std::string description) :
    27     Query(title, description),
    28     tmp(false)
     27    Query(title, description)
    2928{}
    3029

  • src/UIElements/Query/DoubleQuery.cpp

    r53059e rc0ed1e  
    2525// Double Queries
    2626Dialog::DoubleQuery::DoubleQuery(std::string title, std::string _description) :
    27     Query(title, _description),
    28     tmp(0)
     27    Query(title, _description)
    2928{}
    3029

  • src/UIElements/Query/IntQuery.cpp

    r53059e rc0ed1e  
    2525// Int Queries
    2626Dialog::IntQuery::IntQuery(std::string title, std::string description) :
    27     Query(title, description),
    28     tmp(0)
     27    Query(title, description)
    2928{}
    3029

  • src/UIElements/Query/UnsignedIntQuery.cpp

    r53059e rc0ed1e  
    2525// UnsignedInt Queries
    2626Dialog::UnsignedIntQuery::UnsignedIntQuery(std::string title, std::string description) :
    27     Query(title, description),
    28     tmp(0)
     27    Query(title, description)
    2928{}
    3029

  • src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.cpp

    r53059e rc0ed1e  
    4242#include "CodePatterns/MemDebug.hpp"
    4343
    44 QGLMaterial *GLMoleculeObject::m_hoverMaterial = NULL;
    45 QGLMaterial *GLMoleculeObject::m_selectionMaterial = NULL;
    46 QGLMaterial *GLMoleculeObject::m_selectionBoxMaterial = NULL;
    47 
    4844
    4945GLMoleculeObject::GLMoleculeObject(QGLSceneNode *GLMoleculeObject, QObject *parent)
    5046   : QObject(parent)
    5147{
    52    m_mesh = GLMoleculeObject;
     48   m_mesh = 0;
     49   m_GLMoleculeObject = GLMoleculeObject;
    5350   m_scale = 1.0f;
    54    m_scaleZ = 1.0f;
    5551   m_rotationAngle = 0.0f;
    5652   m_effect = 0;
    5753   m_objectId = -1;
    5854   m_hovering = false;
    59    m_selected = false;
    6055   m_material = 0;
    61    initStaticMaterials();
     56   m_hoverMaterial = 0;
    6257}
    6358
    … …  
    6661{
    6762   scene->setParent(this);
    68    m_mesh = scene->mainNode();
     63   m_mesh = 0;
     64   m_GLMoleculeObject = scene->mainNode();
    6965   m_scale = 1.0f;
    70    m_scaleZ = 1.0f;
    7166   m_rotationAngle = 0.0f;
    7267   m_effect = 0;
    7368   m_objectId = -1;
    7469   m_hovering = false;
    75    m_selected = false;
    7670   m_material = 0;
    77    initStaticMaterials();
     71   m_hoverMaterial = 0;
    7872}
    7973
    8074GLMoleculeObject::~GLMoleculeObject()
    8175{
     76   delete m_mesh;
    8277}
    8378
    … …  
    8782   if (m_objectId != -1)
    8883       view->registerObject(m_objectId, this);
    89 }
    90 
    91 
    92 /** Draws a box around the mesh.
    93  *
    94  */
    95 void GLMoleculeObject::drawSelectionBox(QGLPainter *painter)
    96 {
    97   painter->setFaceMaterial(QGL::AllFaces, m_selectionBoxMaterial);
    98   QVector3DArray array;
    99   qreal radius = 1.0;
    100   array.append(-radius, -radius, -radius); array.append( radius, -radius, -radius);
    101   array.append( radius, -radius, -radius); array.append( radius,  radius, -radius);
    102   array.append( radius,  radius, -radius); array.append(-radius,  radius, -radius);
    103   array.append(-radius,  radius, -radius); array.append(-radius, -radius, -radius);
    104 
    105   array.append(-radius, -radius,  radius); array.append( radius, -radius,  radius);
    106   array.append( radius, -radius,  radius); array.append( radius,  radius,  radius);
    107   array.append( radius,  radius,  radius); array.append(-radius,  radius,  radius);
    108   array.append(-radius,  radius,  radius); array.append(-radius, -radius,  radius);
    109 
    110   array.append(-radius, -radius, -radius); array.append(-radius, -radius,  radius);
    111   array.append( radius, -radius, -radius); array.append( radius, -radius,  radius);
    112   array.append(-radius,  radius, -radius); array.append(-radius,  radius,  radius);
    113   array.append( radius,  radius, -radius); array.append( radius,  radius,  radius);
    114   painter->clearAttributes();
    115   painter->setVertexAttribute(QGL::Position, array);
    116   painter->draw(QGL::Lines, 24);
    11784}
    11885
    … …  
    12693   if (m_rotationAngle != 0.0f)
    12794       painter->modelViewMatrix().rotate(m_rotationAngle, m_rotationVector);
    128    if (m_scaleZ != 1.0f)
    129        painter->modelViewMatrix().scale(1.0f, 1.0f, m_scaleZ);
    13095
    13196   // Apply the material and effect to the painter.
    … …  
    13398   if (m_hovering)
    13499       material = m_hoverMaterial;
    135    else if (m_selected)
    136        material = m_selectionMaterial;
    137100   else
    138101       material = m_material;
    139 
    140    ASSERT(material, "GLMoleculeObject::draw: chosen material is NULL");
    141 
    142102   painter->setColor(material->diffuseColor());
    143103   painter->setFaceMaterial(QGL::AllFaces, material);
    … …  
    153113
    154114   // Draw the geometry mesh.
    155    m_mesh->draw(painter);
    156 
    157    // Draw a box around the mesh, if selected.
    158    if (m_selected)
    159      drawSelectionBox(painter);
     115   if (m_GLMoleculeObject)
     116       m_GLMoleculeObject->draw(painter);
     117   else
     118       m_mesh->draw(painter);
    160119
    161120   // Turn off the user effect, if present.
    … …  
    205164QGLMaterial* GLMoleculeObject::getMaterial(size_t no)
    206165{
    207   ASSERT( (no > 0) && (no < MAX_ELEMENTS),
     166  ASSERT( (no >= 0) && (no < MAX_ELEMENTS),
    208167      "GLMoleculeView::getMaterial() - Element no "+toString(no)+" is invalid.");
    209168  if (ElementNoMaterialMap.find(no) != ElementNoMaterialMap.end()){
    … …  
    215174    QGLMaterial *newmaterial = new QGLMaterial(NULL);
    216175
    217     // create material for element
    218     periodentafel *periode = World::getInstance().getPeriode();
    219     const element *desiredelement = periode->FindElement(no);
    220     ASSERT(desiredelement != NULL,
    221         "GLMoleculeView::getMaterial() - desired element "+toString(no)+" not present in periodentafel.");
    222     const unsigned char* color = desiredelement->getColor();
    223     LOG(1, "Creating new material with color " << (int)color[0] << "," << (int)color[1] << "," << (int)color[2] << ".");
    224     newmaterial->setAmbientColor( QColor((int)color[0], (int)color[1], (int)color[2]) );
     176    if (no == 0) { // create hover material
     177      newmaterial->setAmbientColor( QColor(0, 128, 128) );
     178    } else { // create material for element
     179      periodentafel *periode = World::getInstance().getPeriode();
     180      const element *desiredelement = periode->FindElement(no);
     181      ASSERT(desiredelement != NULL,
     182          "GLMoleculeView::getMaterial() - desired element "+toString(no)+" not present in periodentafel.");
     183      const unsigned char* color = desiredelement->getColor();
     184      LOG(1, "Creating new material with color " << (int)color[0] << "," << (int)color[1] << "," << (int)color[2] << ".");
     185      newmaterial->setAmbientColor( QColor((int)color[0], (int)color[1], (int)color[2]) );
     186    }
    225187    newmaterial->setSpecularColor( QColor(60, 60, 60) );
    226188    newmaterial->setShininess( 128 );
    … …  
    228190
    229191    return newmaterial;
    230   }
    231 }
    232 
    233 /** Create the 3 materials shared by all objects.
    234  *
    235  */
    236 void GLMoleculeObject::initStaticMaterials()
    237 {
    238   if (!m_hoverMaterial){
    239     m_hoverMaterial = new QGLMaterial(NULL);
    240     m_hoverMaterial->setAmbientColor( QColor(0, 128, 128) );
    241     m_hoverMaterial->setSpecularColor( QColor(60, 60, 60) );
    242     m_hoverMaterial->setShininess( 128 );
    243   }
    244   if (!m_selectionMaterial){
    245     m_selectionMaterial = new QGLMaterial(NULL);
    246     m_selectionMaterial->setAmbientColor( QColor(255, 50, 50) );
    247     m_selectionMaterial->setSpecularColor( QColor(60, 60, 60) );
    248     m_selectionMaterial->setShininess( 128 );
    249   }
    250   if (!m_selectionBoxMaterial){
    251     m_selectionBoxMaterial = new QGLMaterial(NULL);
    252     m_selectionBoxMaterial->setAmbientColor( QColor(0, 0, 0) );
    253     m_selectionBoxMaterial->setDiffuseColor( QColor(0, 0, 0) );
    254     m_selectionBoxMaterial->setEmittedLight( QColor(155, 50, 50) );
    255192  }
    256193}
    … …  
    268205  }
    269206}
    270 
    271 
    272 void GLMoleculeObject::setSelected(bool value)
    273 {
    274   if (value != m_selected){
    275     m_selected = value;
    276     emit selectionChanged();
    277   }
    278 }

  • src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject.hpp

    r53059e rc0ed1e  
    4747   void setScale(qreal value) { m_scale = value; }
    4848
    49    qreal scaleZ() const { return m_scaleZ; }
    50    void setScaleZ(qreal value) { m_scaleZ = value; }
    51 
    5249   qreal rotationAngle() const { return m_rotationAngle; }
    5350   void setRotationAngle(qreal value) { m_rotationAngle = value; }
    … …  
    5754
    5855   QGLMaterial *material() const { return m_material; }
    59    void setMaterial(QGLMaterial *value) { m_material = value; }
     56   void setMaterial(QGLMaterial *value)
     57       { m_material = value; m_hoverMaterial = value; }
     58
     59   QGLMaterial *hoverMaterial() const { return m_hoverMaterial; }
     60   void setHoverMaterial(QGLMaterial *value) { m_hoverMaterial = value; }
    6061
    6162   QGLAbstractEffect *effect() const { return m_effect; }
    … …  
    6566   void setObjectId(int id) { m_objectId = id; }
    6667
    67    bool selected() const { return m_selected; }
    68    void setSelected(bool value);
    69 
    70    void initStaticMaterials();
    7168   void initialize(QGLView *view, QGLPainter *painter);
    7269   void draw(QGLPainter *painter);
    73    void drawSelectionBox(QGLPainter *painter);
    7470
    7571signals:
    … …  
    7975   void doubleClicked();
    8076   void hoverChanged();
    81    void selectionChanged();
    82    void changed();
    8377
    8478protected:
    … …  
    9488
    9589   QGLSceneNode *m_mesh;
     90   QGLSceneNode *m_GLMoleculeObject;
    9691   QGLAbstractScene *m_scene;
    9792   QVector3D m_position;
    9893   qreal m_scale;
    99    qreal m_scaleZ;
    10094   qreal m_rotationAngle;
    10195   QVector3D m_rotationVector;
    10296   QGLMaterial *m_material;
    103    static QGLMaterial *m_hoverMaterial;
    104    static QGLMaterial *m_selectionMaterial;
    105    static QGLMaterial *m_selectionBoxMaterial;
     97   QGLMaterial *m_hoverMaterial;
    10698   QGLAbstractEffect *m_effect;
    10799   int m_objectId;
    108100   bool m_hovering;
    109    bool m_selected;
    110101};
    111102

  • src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp

    r53059e rc0ed1e  
    4141{
    4242  QGLBuilder builder;
    43   builder << QGLSphere(2.0);
     43  builder << QGLSphere(0.5);
    4444  QGLSceneNode *n = builder.finalizedSceneNode();
    4545  n->setParent(parent);
    … …  
    5757  atomref->signOn(this, AtomObservable::ElementChanged);
    5858  atomref->signOn(this, AtomObservable::BondsAdded);
    59   World::getInstance().signOn(this, World::SelectionChanged);
    6059
    6160  // set the object's id
    … …  
    7372  _atom->signOff(this, AtomObservable::ElementChanged);
    7473  _atom->signOff(this, AtomObservable::BondsAdded);
    75   World::getInstance().signOff(this, World::SelectionChanged);
    7674}
    7775
    … …  
    106104      "GLMoleculeObject_atom::GLMoleculeObject_atom() - QGLMaterial ref from getter function is NULL.");
    107105  setMaterial(elementmaterial);
     106  QGLMaterial *hovermaterial = getMaterial(0); // 0 is the hover material
     107  ASSERT(hovermaterial != NULL,
     108      "GLMoleculeObject_atom::GLMoleculeObject_atom() - QGLMaterial ref from getter function for hover is NULL.");
     109  setHoverMaterial(hovermaterial);
    108110
    109111  // set scale
    … …  
    114116    radius = 0.5;
    115117  }
    116   setScale( radius / 4. );
     118  setScale( radius );
    117119}
    118120
    … …  
    134136  // set the object's id
    135137  resetIndex();
    136 
    137   // selected?
    138   setSelected(World::getInstance().isSelected(_atom));
    139138}
    140139
    … …  
    144143void GLMoleculeObject_atom::recieveNotification(Observable *publisher, Notification_ptr notification)
    145144{
    146   if (publisher == dynamic_cast<const Observable*>(_atom)){
    147     // notofication from atom
    148145#ifdef LOG_OBSERVER
    149     observerLog().addMessage() << "++ Update of Observer "<< observerLog().getName(this)
    150           << " received notification from atom " << _atom->getId() << " for channel "
    151           << notification->getChannelNo() << ".";
     146  observerLog().addMessage() << "++ Update of Observer "<< observerLog().getName(this)
     147      << " received notification from atom " << _atom->getId() << " for channel "
     148      << notification->getChannelNo() << ".";
    152149#endif
    153     switch (notification->getChannelNo()) {
    154       case AtomObservable::ElementChanged:
    155         resetElement();
    156         emit changed();
     150  switch (notification->getChannelNo()) {
     151    case AtomObservable::ElementChanged:
     152      resetElement();
     153      break;
     154    case AtomObservable::IndexChanged:
     155      resetIndex();
     156      break;
     157    case AtomObservable::PositionChanged:
     158      resetPosition();
     159      break;
     160    case AtomObservable::BondsAdded:
     161      {
     162        ASSERT(!_atom->getListOfBonds().empty(),
     163            "GLMoleculeObject_atom::recieveNotification() - received BondsAdded but ListOfBonds is empty.");
     164        const bond * _bond = *(_atom->getListOfBonds().rbegin());
     165        const GLMoleculeObject_bond::SideOfBond side = (_bond->leftatom == _atom) ?
     166            GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
     167        emit BondsInserted(_bond, side);
    157168        break;
    158       case AtomObservable::IndexChanged:
    159         resetIndex();
    160         break;
    161       case AtomObservable::PositionChanged:
    162         resetPosition();
    163         emit changed();
    164         break;
    165       case AtomObservable::BondsAdded:
    166       {
    167           ASSERT(!_atom->getListOfBonds().empty(),
    168               "GLMoleculeObject_atom::recieveNotification() - received BondsAdded but ListOfBonds is empty.");
    169           const bond * _bond = *(_atom->getListOfBonds().rbegin());
    170           const GLMoleculeObject_bond::SideOfBond side = (_bond->leftatom == _atom) ?
    171               GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
    172           emit BondsInserted(_bond, side);
    173           break;
    174         }
    175       default:
    176         //setProperties();
    177         break;
    178     }
    179   }else{
    180     // notification from world
    181 #ifdef LOG_OBSERVER
    182     observerLog().addMessage() << "++ Update of Observer "<< observerLog().getName(this)
    183           << " received notification from world for channel "
    184           << notification->getChannelNo() << ".";
    185 #endif
    186     switch (notification->getChannelNo()) {
    187       case World::SelectionChanged:
    188         setSelected(World::getInstance().isSelected(_atom));
    189         break;
    190       default:
    191         break;
    192     }
     169      }
     170    default:
     171      //setProperties();
     172      break;
    193173  }
    194174}

  • src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp

    r53059e rc0ed1e  
    3939#include "LinearAlgebra/Vector.hpp"
    4040
    41 static QGLSceneNode *createBond(QObject *parent)
     41static QGLSceneNode *createBond(QObject *parent, double distance)
    4242{
    4343   QGLBuilder builder;
    44    QGLCylinder cylinder(.25,.25,1.0,16);
     44   QGLCylinder cylinder(.25,.25,.25);
     45   cylinder.setHeight(distance);
    4546   builder << cylinder;
    4647   QGLSceneNode *n = builder.finalizedSceneNode();
    … …  
    4950}
    5051
    51 GLMoleculeObject_bond::GLMoleculeObject_bond(QObject *parent, const bond *bondref, const enum SideOfBond side) :
    52   GLMoleculeObject(createBond(parent), parent),
     52GLMoleculeObject_bond::GLMoleculeObject_bond(QObject *parent, const bond *bondref, const double distance, const enum SideOfBond side) :
     53  GLMoleculeObject(createBond(parent, distance), parent),
    5354  Observer(std::string("GLMoleculeObject_bond")
    5455      +toString(bondref->leftatom->getId())
    … …  
    6061  // sign on as observer (obtain non-const instance before)
    6162  _bond->signOn(this, BondObservable::BondRemoved);
    62   _bond->leftatom->signOn(this, AtomObservable::PositionChanged);
    63   _bond->rightatom->signOn(this, AtomObservable::PositionChanged);
    6463
     64  Vector Position;
     65  Vector OtherPosition;
    6566  size_t elementno = 0;
    6667  switch (BondSide) {
    6768    case left:
     69      Position = _bond->leftatom->getPosition();
     70      OtherPosition = _bond->rightatom->getPosition();
    6871      if (_bond->leftatom->getType() != NULL) {
    6972        elementno = _bond->leftatom->getType()->getAtomicNumber();
    … …  
    7376      break;
    7477    case right:
     78      Position = _bond->rightatom->getPosition();
     79      OtherPosition = _bond->leftatom->getPosition();
    7580      if (_bond->rightatom->getType() != NULL) {
    7681        elementno = _bond->rightatom->getType()->getAtomicNumber();
    … …  
    8994  setMaterial(elementmaterial);
    9095
    91   resetPosition();
     96  // calculate position
     97  Vector Z(0.,0.,1.);
     98  Vector zeroVec(0.,0.,0.);
     99  Vector a,b;
     100  Vector OtherAxis;
     101  double alpha;
     102  a = Position - OtherPosition;
     103  // construct rotation axis
     104  b = a;
     105  b.VectorProduct(Z);
     106  Line axis(zeroVec, b);
     107  // calculate rotation angle
     108  alpha = a.Angle(Z);
     109  // construct other axis to check right-hand rule
     110  OtherAxis = b;
     111  OtherAxis.VectorProduct(Z);
     112  // assure right-hand rule for the rotation
     113  if (a.ScalarProduct(OtherAxis) < MYEPSILON)
     114    alpha = M_PI-alpha;
     115  // check
     116  Vector a_rotated = axis.rotateVector(a, alpha);
     117  LOG(3, "INFO: Created cylinder from "// << Position << " to " << OtherPosition
     118      << a << " to " << a_rotated << " around " << b << " by " << alpha/M_PI*180. << ", respectively.");
     119
     120  // set position
     121  setPosition(QVector3D(Position[0], Position[1], Position[2]));
     122  setRotationVector(QVector3D(b[0], b[1], b[2]));
     123  setRotationAngle(alpha/M_PI*180.);
    92124}
    93125
    … …  
    96128  // sign on as observer (obtain non-const instance before)
    97129  _bond->signOff(this, BondObservable::BondRemoved);
    98   _bond->leftatom->signOff(this, AtomObservable::PositionChanged);
    99   _bond->rightatom->signOff(this, AtomObservable::PositionChanged);
    100130
    101131  LOG(2, "INFO: Destroying  GLMoleculeObject_bond to bond " << *_bond << " and side " << BondSide << ".");
    … …  
    134164      << notification->getChannelNo() << ".";
    135165#endif
    136   if (publisher == dynamic_cast<const Observable*>(_bond)){
    137     // from the bond
    138     switch (notification->getChannelNo()) {
    139       case BondObservable::BondRemoved:
    140         LOG(2, "INFO: Received notification of BondRemoved from " << *_bond << ".");
    141         switch (BondSide) {
    142           case left:
    143             emit BondRemoved(_bond->leftatom->getId(), _bond->rightatom->getId());
    144             break;
    145           case right:
    146             emit BondRemoved(_bond->rightatom->getId(), _bond->leftatom->getId());
    147             break;
    148           default:
    149             ASSERT(0,
    150                 "GLMoleculeObject_bond::recieveNotification() - side is not a valid argument: "+toString(BondSide)+".");
    151             break;
    152         }
    153         delete this;
    154         break;
    155           default:
    156             break;
    157     }
    158   }else{
    159     // from an atom
    160     switch (notification->getChannelNo()) {
    161       case AtomObservable::PositionChanged:
    162         LOG(2, "INFO: Received notification of PositionChanged.");
    163         resetPosition();
    164         emit changed();
    165     }
     166  switch (notification->getChannelNo()) {
     167    case BondObservable::BondRemoved:
     168      LOG(2, "INFO: Received notification of BondRemoved from " << *_bond << ".");
     169      switch (BondSide) {
     170        case left:
     171          emit BondRemoved(_bond->leftatom->getId(), _bond->rightatom->getId());
     172          break;
     173        case right:
     174          emit BondRemoved(_bond->rightatom->getId(), _bond->leftatom->getId());
     175          break;
     176        default:
     177          ASSERT(0,
     178              "GLMoleculeObject_bond::recieveNotification() - side is not a valid argument: "+toString(BondSide)+".");
     179          break;
     180      }
     181      delete this;
     182      break;
     183    default:
     184      break;
    166185  }
    167186}
    168 
    169 void GLMoleculeObject_bond::resetPosition()
    170 {
    171   Vector Position;
    172   Vector OtherPosition;
    173   switch (BondSide) {
    174     case left:
    175       Position = _bond->leftatom->getPosition();
    176       OtherPosition = _bond->rightatom->getPosition();
    177       break;
    178     case right:
    179       Position = _bond->rightatom->getPosition();
    180       OtherPosition = _bond->leftatom->getPosition();
    181       break;
    182     default:
    183       ASSERT(0,
    184           "GLMoleculeObject_bond::resetPosition() - side is not a valid argument: "+toString(BondSide)+".");
    185       break;
    186   }
    187   const double distance =
    188       Position.distance(OtherPosition)/2.;
    189   setScaleZ(distance);
    190 
    191   // calculate position
    192   Vector Z(0.,0.,1.);
    193   Vector zeroVec(0.,0.,0.);
    194   Vector a,b;
    195   Vector OtherAxis;
    196   double alpha;
    197   a = Position - OtherPosition;
    198   // construct rotation axis
    199   b = a;
    200   b.VectorProduct(Z);
    201   Line axis(zeroVec, b);
    202   // calculate rotation angle
    203   alpha = a.Angle(Z);
    204   // construct other axis to check right-hand rule
    205   OtherAxis = b;
    206   OtherAxis.VectorProduct(Z);
    207   // assure right-hand rule for the rotation
    208   if (a.ScalarProduct(OtherAxis) < MYEPSILON)
    209     alpha = M_PI-alpha;
    210   // check
    211   Vector a_rotated = axis.rotateVector(a, alpha);
    212   LOG(3, "INFO: Created cylinder from "// << Position << " to " << OtherPosition
    213       << a << " to " << a_rotated << " around " << b << " by " << alpha/M_PI*180. << ", respectively.");
    214 
    215   // set position
    216   setPosition(QVector3D(Position[0], Position[1], Position[2]));
    217   setRotationVector(QVector3D(b[0], b[1], b[2]));
    218   setRotationAngle(alpha/M_PI*180.);
    219 }

  • src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp

    r53059e rc0ed1e  
    2828  enum SideOfBond { left, right };
    2929
    30   GLMoleculeObject_bond(QObject *parent, const bond *bondref, const enum SideOfBond side);
     30  GLMoleculeObject_bond(QObject *parent, const bond *bondref, const double distance, const enum SideOfBond side);
    3131  virtual ~GLMoleculeObject_bond();
    3232
    … …  
    4040
    4141private:
    42   void resetPosition();
    4342  const bond *_bond;
    4443  const enum SideOfBond BondSide;

  • src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp

    r53059e rc0ed1e  
    2525#include "GLMoleculeObject_atom.hpp"
    2626#include "GLMoleculeObject_bond.hpp"
    27 #include "GLMoleculeObject_molecule.hpp"
    2827
    2928#include "CodePatterns/MemDebug.hpp"
    … …  
    7574        Runner != molecules.end();
    7675        Runner++) {
    77 
     76      // create molecule
    7877      for (molecule::const_iterator atomiter = (*Runner)->begin();
    7978          atomiter != (*Runner)->end();
    … …  
    110109  AtomsinSceneMap.insert( make_pair(_atom->getId(), atomObject) );
    111110  connect (atomObject, SIGNAL(clicked(atomId_t)), this, SLOT(atomClicked(atomId_t)));
    112   connect (atomObject, SIGNAL(changed()), this, SIGNAL(changed()));
    113111  connect (atomObject, SIGNAL(hoverChanged()), this, SIGNAL(changed()));
    114   connect (atomObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
    115112  connect (atomObject, SIGNAL(BondsInserted(const bond *, const GLMoleculeObject_bond::SideOfBond)), this, SLOT(bondInserted(const bond *, const GLMoleculeObject_bond::SideOfBond)));
    116113  //bondsChanged(_atom);
    … …  
    137134}
    138135
    139 /** ....
    140  *
    141  */
    142 void GLWorldScene::worldSelectionChanged()
    143 {
    144   LOG(3, "INFO: GLWorldScene: Received signal selectionChanged.");
    145 
    146   const std::vector<molecule*> &molecules = World::getInstance().getAllMolecules();
    147 
    148   if (molecules.size() > 0) {
    149     for (std::vector<molecule*>::const_iterator Runner = molecules.begin();
    150         Runner != molecules.end();
    151         Runner++) {
    152 
    153       MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find((*Runner)->getId());
    154       bool isSelected = World::getInstance().isSelected(*Runner);
    155 
    156       // molecule selected but not in scene?
    157       if (isSelected && (iter == MoleculesinSceneMap.end())){
    158         // -> create new mesh
    159         GLMoleculeObject_molecule *molObject = new GLMoleculeObject_molecule(this, *Runner);
    160         MoleculesinSceneMap.insert( make_pair((*Runner)->getId(), molObject) );
    161         connect (molObject, SIGNAL(changed()), this, SIGNAL(changed()));
    162         connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
    163         connect (molObject, SIGNAL(selectionChanged()), this, SIGNAL(changed()));
    164         emit changed();
    165         emit changeOccured();
    166       }
    167 
    168       // molecule not selected but in scene?
    169       if (!isSelected && (iter != MoleculesinSceneMap.end())){
    170         // -> remove from scene
    171         moleculeRemoved(*Runner);
    172       }
    173 
    174     }
    175   }
    176 }
    177 
    178 /** Removes a molecule from the scene.
    179  *
    180  * @param _molecule molecule to remove
    181  */
    182 void GLWorldScene::moleculeRemoved(const molecule *_molecule)
    183 {
    184   LOG(3, "INFO: GLWorldScene: Received signal moleculeRemoved for molecule "+toString(_molecule->getId())+".");
    185   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molecule->getId());
    186 
    187   // only remove if the molecule is in the scene
    188   //  (= is selected)
    189   if (iter != MoleculesinSceneMap.end()){
    190     GLMoleculeObject_molecule *molObject = iter->second;
    191     molObject->disconnect();
    192     MoleculesinSceneMap.erase(iter);
    193     delete molObject;
    194     emit changed();
    195     emit changeOccured();
    196   }
    197 }
    198 
    199136/** Adds a bond to the scene.
    200137 *
    … …  
    206143  LOG(3, "INFO: GLWorldScene::bondInserted() - Adding bond "+toString(*_bond)+".");
    207144  //LOG(4, "INFO: Currently present bonds " << BondsinSceneMap << ".");
     145  const double distance =
     146      _bond->leftatom->getPosition().distance(_bond->rightatom->getPosition())/2.;
    208147
    209148  BondIds ids;
    … …  
    222161#endif
    223162  GLMoleculeObject_bond *bondObject =
    224       new GLMoleculeObject_bond(this, _bond, side);
     163      new GLMoleculeObject_bond(this, _bond, distance, side);
    225164  connect (
    226165      bondObject, SIGNAL(BondRemoved(const atomId_t, const atomId_t)),
    227166      this, SLOT(bondRemoved(const atomId_t, const atomId_t)));
    228   connect (bondObject, SIGNAL(changed()), this, SIGNAL(changed()));
    229167  BondsinSceneMap.insert( make_pair(ids, bondObject) );
    230168//    BondIdsinSceneMap.insert( Leftids );

  • src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp

    r53059e rc0ed1e  
    2323
    2424#include "GLMoleculeObject_bond.hpp"
    25 #include "GLMoleculeObject_molecule.hpp"
    2625
    2726class atom;
    28 class molecule;
    2927
    3028class QGLPainter;
    … …  
    3432class GLMoleculeObject;
    3533class GLMoleculeObject_atom;
    36 class GLMoleculeObject_molecule;
    3734
    3835/** This class contains a list of all molecules in the world.
    … …  
    5249  void changeMaterials(bool perPixel);
    5350  QGLSceneNode* getAtom(size_t);
    54   QGLSceneNode* getMolecule(size_t);
    5551  QGLSceneNode* getBond(size_t, size_t);
    5652
    … …  
    7268  void atomInserted(const atom *_atom);
    7369  void atomRemoved(const atom *_atom);
    74   void moleculeRemoved(const molecule *_molecule);
    75   void worldSelectionChanged();
    7670  void bondInserted(const bond *_bond, const GLMoleculeObject_bond::SideOfBond side);
    7771  void bondRemoved(const atomId_t leftnr, const atomId_t rightnr);
    … …  
    8680  typedef std::map< atomId_t, GLMoleculeObject_atom* > AtomNodeMap;
    8781  typedef std::map< BondIds , GLMoleculeObject_bond* > BondNodeMap;
    88   typedef std::map< moleculeId_t , GLMoleculeObject_molecule* > MoleculeNodeMap;
    8982  AtomNodeMap AtomsinSceneMap;
    9083  BondNodeMap BondsinSceneMap;
    91   MoleculeNodeMap MoleculesinSceneMap;
    9284};
    9385

  • src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp

    r53059e rc0ed1e  
    2626#include "CodePatterns/MemDebug.hpp"
    2727
    28 #include "Atom/AtomObserver.hpp"
    29 #include "Atom/atom_observable.hpp"
    3028#include "CodePatterns/Log.hpp"
    3129#include "CodePatterns/Observer/Notification.hpp"
    … …  
    4442  connect(this, SIGNAL(atomInserted(const atom *)), worldscene, SLOT(atomInserted(const atom *)));
    4543  connect(this, SIGNAL(atomRemoved(const atom *)), worldscene, SLOT(atomRemoved(const atom *)));
    46   connect(this, SIGNAL(worldSelectionChanged()), worldscene, SLOT(worldSelectionChanged()));
    47   connect(this, SIGNAL(moleculeRemoved(const molecule *)), worldscene, SLOT(moleculeRemoved(const molecule *)));
    4844  connect(this, SIGNAL(changed()), this, SLOT(updateGL()));
    4945
    … …  
    5248  World::getInstance().signOn(this, World::AtomInserted);
    5349  World::getInstance().signOn(this, World::AtomRemoved);
    54   World::getInstance().signOn(this, World::MoleculeInserted);
    55   World::getInstance().signOn(this, World::MoleculeRemoved);
    56   World::getInstance().signOn(this, World::SelectionChanged);
    57   AtomObserver::getInstance().signOn(this, AtomObservable::PositionChanged);
    5850}
    5951
    … …  
    6355  World::getInstance().signOff(this, World::AtomInserted);
    6456  World::getInstance().signOff(this, World::AtomRemoved);
    65   World::getInstance().signOff(this, World::MoleculeInserted);
    66   World::getInstance().signOff(this, World::MoleculeRemoved);
    67   World::getInstance().signOff(this, World::SelectionChanged);
    68   AtomObserver::getInstance().signOff(this, AtomObservable::PositionChanged);
    6957  delete worldscene;
    7058}
    … …  
    9179void GLWorldView::recieveNotification(Observable *publisher, Notification_ptr notification)
    9280{
    93   if (static_cast<World *>(publisher) == World::getPointer()) {
    94     switch (notification->getChannelNo()) {
    95       case World::AtomInserted:
    96       {
    97         const atom *_atom = World::getInstance().lastChanged<atom>();
    98   #ifdef LOG_OBSERVER
    99         observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that atom "+toString(_atom->getId())+" has been inserted.";
    100   #endif
    101         emit atomInserted(_atom);
    102         break;
    103       }
    104       case World::AtomRemoved:
    105       {
    106         const atom *_atom = World::getInstance().lastChanged<atom>();
    107   #ifdef LOG_OBSERVER
    108         observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that atom "+toString(_atom->getId())+" has been removed.";
    109   #endif
    110         emit atomRemoved(_atom);
    111         break;
    112       }
    113       case World::SelectionChanged:
    114       {
    115   #ifdef LOG_OBSERVER
    116         observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that selection has changed.";
    117   #endif
    118         emit worldSelectionChanged();
    119         break;
    120       }
    121       case World::MoleculeInserted:
    122       {
    123         const molecule *_molecule = World::getInstance().lastChanged<molecule>();
    124   #ifdef LOG_OBSERVER
    125         observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that molecule "+toString(_molecule->getId())+" has been removed.";
    126   #endif
    127         emit moleculeInserted(_molecule);
    128         break;
    129       }
    130       case World::MoleculeRemoved:
    131       {
    132         const molecule *_molecule = World::getInstance().lastChanged<molecule>();
    133   #ifdef LOG_OBSERVER
    134         observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that molecule "+toString(_molecule->getId())+" has been removed.";
    135   #endif
    136         emit moleculeRemoved(_molecule);
    137         break;
    138       }
    139       default:
    140         ASSERT(0, "GLWorldView::recieveNotification() - we cannot get here.");
    141         break;
     81  switch (notification->getChannelNo()) {
     82    case World::AtomInserted:
     83    {
     84      const atom *_atom = World::getInstance().lastChanged<atom>();
     85#ifdef LOG_OBSERVER
     86      observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that atom "+toString(_atom->getId())+" has been inserted.";
     87#endif
     88      emit atomInserted(_atom);
     89      break;
    14290    }
    143   } else if (dynamic_cast<AtomObservable *>(publisher) != NULL) {
    144     switch (notification->getChannelNo()) {
    145       case AtomObservable::PositionChanged:
    146       {
    147         const atom *_atom = dynamic_cast<const atom *>(publisher);
    148     #ifdef LOG_OBSERVER
    149         observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that atom "+toString(_atom->getId())+" has changed its position.";
    150     #endif
    151         emit changed();
    152         break;
    153       }
    154       default:
    155         ASSERT(0, "GLWorldView::recieveNotification() - we cannot get here.");
    156         break;
     91    case World::AtomRemoved:
     92    {
     93      const atom *_atom = World::getInstance().lastChanged<atom>();
     94#ifdef LOG_OBSERVER
     95      observerLog().addMessage() << "++ Observer " << observerLog().getName(this) << " received notification that atom "+toString(_atom->getId())+" has been removed.";
     96#endif
     97      emit atomRemoved(_atom);
     98      break;
    15799    }
    158   } else
    159     ASSERT(0, "GLWorldView::recieveNotification() - received notification from unknown source.");
     100    default:
     101      ASSERT(0, "GLWorldView::recieveNotification() - we cannot get here.");
     102      break;
     103  }
    160104}
    161105

  • src/UIElements/Views/Qt4/Qt3D/GLWorldView.hpp

    r53059e rc0ed1e  
    4747  void atomInserted(const atom *_atom);
    4848  void atomRemoved(const atom *_atom);
    49   void moleculeInserted(const molecule *_molecule);
    50   void moleculeRemoved(const molecule *_molecule);
    51   void worldSelectionChanged();
    5249
    5350protected:
    … …  
    6057
    6158  bool changesPresent;
    62   bool processingSelectionChanged; // workaround to prevent a loop in (atom_iterator <-> observer)
    6359};
    6460

  • src/UIElements/Views/Qt4/QtWorldView.cpp

    r53059e rc0ed1e  
    2828#include "molecule.hpp"
    2929#include "MoleculeListClass.hpp"
    30 #include "Actions/SelectionAction/Molecules/MoleculeByIdAction.hpp"
    31 #include "Actions/SelectionAction/Molecules/NotMoleculeByIdAction.hpp"
    3230
    3331using namespace std;
    … …  
    3836// these attributes are skiped so far
    3937const int QtWorldView::COLUMNCOUNT = COLUMNTYPES_MAX;
    40 const char *QtWorldView::COLUMNNAMES[QtWorldView::COLUMNCOUNT]={"Name","Atoms","Formula","Occurrence"/*,"Size"*/};
     38const char *QtWorldView::COLUMNNAMES[QtWorldView::COLUMNCOUNT]={"Name","Atoms","Formula"/*,"Size"*/};
    4139
    4240QtWorldView::QtWorldView(QWidget * _parent) :
    43   QTreeWidget (_parent),
     41  QTableWidget (_parent),
    4442  Observer("QtWorldView")
    4543{
     44  setRowCount(0);
    4645  setColumnCount(COLUMNCOUNT);
    47   setSelectionMode(QAbstractItemView::MultiSelection);
    4846
    49   QStringList header;
    50   for(int i=0; i<COLUMNCOUNT;++i)
    51     header << COLUMNNAMES[i];
    52   setHeaderLabels(header);
     47  for(int i=0; i<COLUMNCOUNT;++i) {
     48    QTableWidgetItem *heading = new QTableWidgetItem();
     49    std::cout << "Creating heading item " << heading << "." << std::endl;
     50    heading->setText(QString(COLUMNNAMES[i]));
     51    setHorizontalHeaderItem(i,heading);
     52  }
    5353
    5454  molecules = World::getInstance().getMolecules();
    5555  molecules->signOn(this);
     56  update(molecules);
    5657
    57   dirty = true;
    58   refill();
    59 
    60   //connect(this,SIGNAL(cellChanged(int,int)),this,SLOT(moleculeChanged(int,int)));
    61   connect(this,SIGNAL(itemSelectionChanged()),this,SLOT(rowSelected()));
     58  connect(this,SIGNAL(cellChanged(int,int)),this,SLOT(moleculeChanged(int,int)));
     59  connect(this,SIGNAL(cellClicked(int,int)),this,SLOT(cellSelected(int,int)));
    6260
    6361}
    … …  
    6967
    7068void QtWorldView::update(Observable *publisher) {
    71 
    72   dirty = true;
    73 
    74   // force an update from Qt...
    75   clear();
    76 }
    77 
    78 void QtWorldView::refill() {
    7969  int numMolecules = molecules->ListOfMolecules.size();
    80   clear();
     70  setRowCount(numMolecules);
    8171  molSelection.resize(numMolecules);
    82 
    83   // list of (unique) formulas in the world
    84   std::vector<Formula> formula;
    85 
    8672  int i;
    8773  MoleculeList::iterator iter;
    … …  
    9076      ++i,++iter) {
    9177
    92     // find group if already in list
    93     QTreeWidgetItem *groupItem = NULL;
    94     for (unsigned int j=0;j<formula.size();j++)
    95       if ((*iter)->getFormula() == formula[j]){
    96         groupItem = topLevelItem(j);
    97         break;
    98       }
     78    const int index = (*iter)->IndexNr;
     79    QTableWidgetItem *indexWidget = new QTableWidgetItem();
     80    //std::cout << "Creating index item " << indexWidget << "." << std::endl;
     81    indexWidget->setText(QString::number(index));
     82    indexWidget->setData(Qt::UserRole,QVariant(index));
     83    setVerticalHeaderItem(i,indexWidget);
    9984
    100     // new molecule type -> create new group
    101     if (!groupItem){
    102       formula.push_back((*iter)->getFormula());
    103       groupItem = new QTreeWidgetItem(this);
    104       groupItem->setText(0, QString((*iter)->getName().c_str()));
    105       groupItem->setText(1, QString::number((*iter)->getAtomCount()));
    106       groupItem->setText(2, QString((*iter)->getFormula().toString().c_str()));
    107       groupItem->setText(3, "0");
    108     }
     85    const string name = (*iter)->getName();
     86    QTableWidgetItem *nameWidget = new QTableWidgetItem();
     87    //std::cout << "Creating name item " << nameWidget << " at " << i << "," << NAME << "." << std::endl;
     88    nameWidget->setText(QString(name.c_str()));
     89    setItem(i,NAME,nameWidget);
    10990
    110     // add molecule
    111     QTreeWidgetItem *molItem = new QTreeWidgetItem(groupItem);
    112     molItem->setText(0, QString((*iter)->getName().c_str()));
    113     molItem->setText(1, QString::number((*iter)->getAtomCount()));
    114     molItem->setText(2, QString((*iter)->getFormula().toString().c_str()));
    115     const int index = (*iter)->IndexNr;
    116     molItem->setData(0, Qt::UserRole, QVariant(index));
    117     molItem->setSelected(World::getInstance().isSelected(*iter));
     91    const int atomCount = (*iter)->getAtomCount();
     92    QTableWidgetItem *countWidget= new QTableWidgetItem();
     93    //std::cout << "Creating count item " << countWidget << " at " << i << "," << ATOMCOUNT << "." << std::endl;
     94    countWidget->setText(QString::number(atomCount));
     95    countWidget->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
     96    setItem(i,ATOMCOUNT,countWidget);
    11897
     98    const Formula formula = (*iter)->getFormula();
     99    QTableWidgetItem *formulaWidget= new QTableWidgetItem();
     100    //std::cout << "Creating formula item " << formulaWidget << " at " << i << "," << FORMULA << "." << std::endl;
     101    formulaWidget->setText(QString(formula.toString().c_str()));
     102    formulaWidget->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
     103    setItem(i,FORMULA,formulaWidget);
    119104
    120     // increase group occurrence
    121     int count = groupItem->text(3).toInt() + 1;
    122     groupItem->setText(3, QString::number(count));
    123 
    124     //molSelection[i]=nameWidget->isSelected();
     105    molSelection[i]=nameWidget->isSelected();
    125106  }
    126   dirty = false;
    127 }
    128 
    129 void QtWorldView::paintEvent(QPaintEvent * event)
    130 {
    131   if (dirty)
    132     refill();
    133   QTreeWidget::paintEvent(event);
    134107}
    135108
    … …  
    137110}
    138111
    139 void QtWorldView::moleculeChanged() {
    140   /*int idx = verticalHeaderItem(row)->data(Qt::UserRole).toInt();
     112void QtWorldView::moleculeChanged(int row, int column) {
     113  int idx = verticalHeaderItem(row)->data(Qt::UserRole).toInt();
    141114  molecule *mol = molecules->ReturnIndex(idx);
    142115  string cellValue = item(row,NAME)->text().toStdString();
    … …  
    146119  else if(cellValue==""){
    147120    item(row,NAME)->setText(QString(mol->getName().c_str()));
    148   }*/
     121  }
    149122}
    150123
    151124
    152 void QtWorldView::rowSelected(){
    153 
    154   // lookup all molecules in the treeWidget
    155   for (int i=0;i<topLevelItemCount();i++){
    156     QTreeWidgetItem *top = topLevelItem(i);
    157     for (int j=0;j<top->childCount();j++){
    158 
    159       // molecules are 1 level below the top
    160       QTreeWidgetItem *molItem = top->child(j);
    161 
    162       // molecule index stored as user data
    163       int index = molItem->data(0, Qt::UserRole).toInt();
    164       molecule *mol = molecules->ReturnIndex(index);
    165       ASSERT(mol, "QtWorldView::rowSelected()");
    166 
    167       // selection changed by user?
    168       bool molSelectedWorld = World::getInstance().isSelected(mol);
    169       bool molSelectedList = molItem->isSelected();
    170       //std::cout << molSelectedWorld << " " << molSelectedList << std::endl;
    171 
    172       if (molSelectedWorld != molSelectedList){
    173 
    174         // apply new selection state
    175         if (molSelectedList){
    176           //std::cout << "select molecule" << std::endl;
    177           MoleCuilder::SelectionMoleculeById(mol->getId());
    178         }else{
    179           //std::cout << "unselect molecule" << std::endl;
    180           MoleCuilder::SelectionNotMoleculeById(mol->getId());
    181         }
     125void QtWorldView::cellSelected(int row, int column){
     126  //std::cout << "Selection in (" << row << "," << column << "): " << item(row,column) << std::endl;
     127  bool state = item(row,column)->isSelected();
     128  for(int i = 0; i<COLUMNCOUNT; i++){
     129    //std::cout << "Setting " << i << "-th item " << item(row,i) << " in row " << row << " to state selected." << std::endl;
     130    item(row,i)->setSelected(state);
     131  }
     132  // figure out which rows have changed
     133  for(int i=0; i<rowCount();++i){
     134    state = item(i,0)->isSelected();
     135    if(molSelection[i]!=state){
     136      int idx = verticalHeaderItem(i)->data(Qt::UserRole).toInt();
     137      molecule *mol = molecules->ReturnIndex(idx);
     138      if(state){
     139        emit moleculeSelected(mol);
    182140      }
     141      else{
     142        emit moleculeUnSelected(mol);
     143      }
     144      molSelection[i]=state;
    183145    }
    184146  }

  • src/UIElements/Views/Qt4/QtWorldView.hpp

    r53059e rc0ed1e  
    1515
    1616
    17 #include <QtGui/QTreeWidget>
     17#include <QtGui/QTableWidget>
    1818#include "CodePatterns/Observer/Observer.hpp"
    1919
    … …  
    2121class MoleculeListClass;
    2222
    23 class QtWorldView : public QTreeWidget, public Observer
     23class QtWorldView : public QTableWidget, public Observer
    2424{
    2525  Q_OBJECT
    … …  
    3232  virtual void update(Observable *publisher);
    3333  virtual void subjectKilled(Observable *publisher);
    34   virtual void paintEvent(QPaintEvent * event);
    35   void refill();
    3634
    3735  static const int COLUMNCOUNT;
    38   enum {NAME,ATOMCOUNT,FORMULA,OCCURRENCE,COLUMNTYPES_MAX} COLUMNTYPES;
     36  enum {NAME,ATOMCOUNT,FORMULA,COLUMNTYPES_MAX} COLUMNTYPES;
    3937  static const char *COLUMNNAMES[];
    4038
    4139private slots:
    42   void moleculeChanged();
     40  void moleculeChanged(int row, int column);
    4341
    44   void rowSelected();
     42  void cellSelected(int row, int column);
    4543
    4644signals:
    … …  
    5149  std::vector<bool> molSelection; //!< needed to determine when a selection changes
    5250  MoleculeListClass *molecules;
    53   bool dirty;
    5451};
    5552

  • src/World.cpp

    r53059e rc0ed1e  
    414414
    415415void World::clearAtomSelection(){
    416   OBSERVE;
    417   NOTIFY(SelectionChanged);
    418416  selectedAtoms.clear();
    419417}
    … …  
    435433
    436434void World::selectAtom(const atom *_atom){
    437   OBSERVE;
    438   NOTIFY(SelectionChanged);
    439435  // atom * is unchanged in this function, but we do store entity as changeable
    440436  ASSERT(_atom,"Invalid pointer in selection of atom");
    … …  
    443439
    444440void World::selectAtom(const atomId_t id){
    445   OBSERVE;
    446   NOTIFY(SelectionChanged);
    447441  ASSERT(atoms.count(id),"Atom Id selected that was not in the world");
    448442  selectedAtoms[id]=atoms[id];
    … …  
    450444
    451445void World::selectAllAtoms(AtomDescriptor descr){
    452   OBSERVE;
    453   NOTIFY(SelectionChanged);
    454446  internal_AtomIterator begin = getAtomIter_internal(descr);
    455447  internal_AtomIterator end = atomEnd_internal();
    … …  
    459451
    460452void World::selectAtomsOfMolecule(const molecule *_mol){
    461   OBSERVE;
    462   NOTIFY(SelectionChanged);
    463453  ASSERT(_mol,"Invalid pointer to molecule in selection of Atoms of Molecule");
    464454  // need to make it const to get the fast iterators
    … …  
    469459
    470460void World::selectAtomsOfMolecule(const moleculeId_t id){
    471   OBSERVE;
    472   NOTIFY(SelectionChanged);
    473461  ASSERT(molecules.count(id),"No molecule with the given id upon Selection of atoms from molecule");
    474462  selectAtomsOfMolecule(molecules[id]);
    … …  
    476464
    477465void World::unselectAtom(const atom *_atom){
    478   OBSERVE;
    479   NOTIFY(SelectionChanged);
    480466  ASSERT(_atom,"Invalid pointer in unselection of atom");
    481467  unselectAtom(_atom->getId());
    … …  
    483469
    484470void World::unselectAtom(const atomId_t id){
    485   OBSERVE;
    486   NOTIFY(SelectionChanged);
    487471  ASSERT(atoms.count(id),"Atom Id unselected that was not in the world");
    488472  selectedAtoms.erase(id);
    … …  
    490474
    491475void World::unselectAllAtoms(AtomDescriptor descr){
    492   OBSERVE;
    493   NOTIFY(SelectionChanged);
    494476  internal_AtomIterator begin = getAtomIter_internal(descr);
    495477  internal_AtomIterator end = atomEnd_internal();
    … …  
    499481
    500482void World::unselectAtomsOfMolecule(const molecule *_mol){
    501   OBSERVE;
    502   NOTIFY(SelectionChanged);
    503483  ASSERT(_mol,"Invalid pointer to molecule in selection of Atoms of Molecule");
    504484  // need to make it const to get the fast iterators
    … …  
    509489
    510490void World::unselectAtomsOfMolecule(const moleculeId_t id){
    511   OBSERVE;
    512   NOTIFY(SelectionChanged);
    513491  ASSERT(molecules.count(id),"No molecule with the given id upon Selection of atoms from molecule");
    514492  unselectAtomsOfMolecule(molecules[id]);
    … …  
    543521
    544522void World::clearMoleculeSelection(){
    545   OBSERVE;
    546   NOTIFY(SelectionChanged);
    547523  selectedMolecules.clear();
    548524}
    … …  
    565541
    566542void World::selectMolecule(const molecule *_mol){
    567   OBSERVE;
    568   NOTIFY(SelectionChanged);
    569543  // molecule * is unchanged in this function, but we do store entity as changeable
    570544  ASSERT(_mol,"Invalid pointer to molecule in selection");
    … …  
    573547
    574548void World::selectMolecule(const moleculeId_t id){
    575   OBSERVE;
    576   NOTIFY(SelectionChanged);
    577549  ASSERT(molecules.count(id),"Molecule Id selected that was not in the world");
    578550  selectedMolecules[id]=molecules[id];
    … …  
    580552
    581553void World::selectAllMolecules(MoleculeDescriptor descr){
    582   OBSERVE;
    583   NOTIFY(SelectionChanged);
    584554  internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
    585555  internal_MoleculeIterator end = moleculeEnd_internal();
    … …  
    589559
    590560void World::selectMoleculeOfAtom(const atom *_atom){
    591   OBSERVE;
    592   NOTIFY(SelectionChanged);
    593561  ASSERT(_atom,"Invalid atom pointer in selection of MoleculeOfAtom");
    594562  molecule *mol=_atom->getMolecule();
    … …  
    600568
    601569void World::selectMoleculeOfAtom(const atomId_t id){
    602   OBSERVE;
    603   NOTIFY(SelectionChanged);
    604570  ASSERT(atoms.count(id),"No such atom with given ID in selection of Molecules of Atom");\
    605571  selectMoleculeOfAtom(atoms[id]);
    … …  
    607573
    608574void World::unselectMolecule(const molecule *_mol){
    609   OBSERVE;
    610   NOTIFY(SelectionChanged);
    611575  ASSERT(_mol,"invalid pointer in unselection of molecule");
    612576  unselectMolecule(_mol->getId());
    … …  
    614578
    615579void World::unselectMolecule(const moleculeId_t id){
    616   OBSERVE;
    617   NOTIFY(SelectionChanged);
    618580  ASSERT(molecules.count(id),"No such molecule with ID in unselection");
    619581  selectedMolecules.erase(id);
    … …  
    621583
    622584void World::unselectAllMolecules(MoleculeDescriptor descr){
    623   OBSERVE;
    624   NOTIFY(SelectionChanged);
    625585  internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
    626586  internal_MoleculeIterator end = moleculeEnd_internal();
    … …  
    630590
    631591void World::unselectMoleculeOfAtom(const atom *_atom){
    632   OBSERVE;
    633   NOTIFY(SelectionChanged);
    634592  ASSERT(_atom,"Invalid atom pointer in selection of MoleculeOfAtom");
    635593  molecule *mol=_atom->getMolecule();
    … …  
    641599
    642600void World::unselectMoleculeOfAtom(const atomId_t id){
    643   OBSERVE;
    644   NOTIFY(SelectionChanged);
    645601  ASSERT(atoms.count(id),"No such atom with given ID in selection of Molecules of Atom");\
    646602  unselectMoleculeOfAtom(atoms[id]);

  • src/World.hpp

    r53059e rc0ed1e  
    115115    MoleculeInserted,
    116116    MoleculeRemoved,
    117     SelectionChanged,
    118117    NotificationType_MAX
    119118  };

  • src/molecule.cpp

    r53059e rc0ed1e  
    729729void molecule::SetNameFromFilename(const char *filename)
    730730{
    731   OBSERVE;
    732731  int length = 0;
    733732  const char *molname = strrchr(filename, '/');
Note: See TracChangeset for help on using the changeset viewer.