Changeset 29daad for src

Timestamp:

Oct 6, 2011, 12:08:27 PM (13 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

b40b9d

Parents:

064178

git-author:

Frederik Heber <heber@…> (08/11/11 15:14:05)

git-committer:

Frederik Heber <heber@…> (10/06/11 12:08:27)

Message:

Added rudimentarily working GlMoleculeView (class was empty before).

• We took over the code from (ancient) branch MolecuilderGUI and adapated it to the current standards. Atoms are drawn, bonds in some so far wrong direction as well.
• Note that the guz has trouble showing dialogs for all Actions. This should be some minor bug.

Location:

src/UIElements

Files:

• Makefile.am (modified) (3 diffs)
• Qt4/QtMainWindow.cpp (modified) (1 diff)
• Views/Qt4/GLMoleculeView.cpp (modified) (2 diffs)
• Views/Qt4/GLMoleculeView.hpp (modified) (2 diffs)
• Views/Qt4/changeposition.ui (added)
• Views/Qt4/changetypes.hpp (added)
• Views/Qt4/dialoglight.ui (added)
• Views/Qt4/dialoglight.ui.h (added)

src/UIElements/Makefile.am

@@ -192 +192 @@
   UIElements/Views/Qt4/QtMoleculeView.cpp \
   UIElements/Views/Qt4/QtStatusBar.cpp
+#  UIElements/Views/Qt4/dialoglight.cpp
              
 QTUIMOC_HEADER = \
@@ -217 +218 @@
   UIElements/Views/Qt4/QtMoleculeView.hpp \
   UIElements/Views/Qt4/QtStatusBar.hpp
+
+#QTUIUI_HEADER = \
+#  UIElements/Views/Qt4/dialoglight.ui.h
+
+#QTUIUI_SOURCE = \
+#  UIElements/Views/Qt4/dialoglight.ui
                                   
 QTUIHEADER = \
@@ -302 +309 @@
 #pkgconfig_DATA = $(top_builddir)/MoleCuilder.pc
 
+# This is the old stuff from branch molecuilderGUI which does not work
+#%.h: %.ui
+#       $(UIC) -o $@ $<
+#       
+#%.cpp: %.ui
+#       $(UIC) -o $@ -impl $*.h $<
+
+BUILT_SOURCES = ui_dialoglight.h ui_changeposition.h
+
+#noinst_HEADERS = dialoglight.h changeposition.h
+
+nodist_libMolecuilderQtUI_la_SOURCES += moc_dialoglight.cpp moc_changeposition.cpp
+
+#libMolecuilderQtUI_la_SOURCES += dialoglight.cpp changeposition.cpp
+
+ui_dialoglight.h: UIElements/Views/Qt4/dialoglight.ui
+        @UIC@ -o $@ $<
+
+ui_changeposition.h: UIElements/Views/Qt4/changeposition.ui
+        @UIC@ -o $@ $<
+
+moc_dialoglight.cpp: ui_dialoglight.h
+        @MOC@ -o $@ $<
+
+moc_changeposition.cpp: ui_changeposition.h
+        @MOC@ -o $@ $<
+
 #Rules needed for Qt4
 # UI-Files are scattered throughout several subdirectories

src/UIElements/Qt4/QtMainWindow.cpp

@@ -54 +54 @@
 
   moleculeDisplay = new QtMoleculeView();
-  molecule3dDisplay = new GLMoleculeView();
+  molecule3dDisplay = new GLMoleculeView(this);
 
   MainMenu = new QtMenu<QMenuBar>(menuBar(), "");

src/UIElements/Views/Qt4/GLMoleculeView.cpp

@@ -9 +9 @@
  * GLMoleculeView.cpp
  *
- *  Created on: Jan 26, 2010
- *      Author: crueger
+ *  Created on: Aug 1, 2010
+ *      Author: heber
  */
 
@@ -19 +19 @@
 
 #include "GLMoleculeView.hpp"
+#include <GL/glu.h>
+#include <QtGui/qslider.h>
+#include <QtGui/qevent.h>
+
+#include "ui_dialoglight.h"
 
 #include "CodePatterns/MemDebug.hpp"
 
+#include <iostream>
+
+#include "LinearAlgebra/Line.hpp"
+#include "atom.hpp"
+#include "Bond/bond.hpp"
+#include "element.hpp"
+#include "molecule.hpp"
+#include "periodentafel.hpp"
+#include "World.hpp"
+
+#if defined(Q_CC_MSVC)
+#pragma warning(disable:4305) // init: truncation from const double to float
+#endif
+
+
 GLMoleculeView::GLMoleculeView(QWidget *parent) :
-  QGLWidget(parent)
-{}
-
+  QGLWidget(parent), Observer("GLMoleculeView"), X(Vector(1,0,0)), Y(Vector(0,1,0)), Z(Vector(0,0,1))
+{
+    xRot = yRot = zRot = 0.0;    // default object rotation
+    scale = 5.;      // default object scale
+    object = 0;
+    LightPosition[0] = 0.0f;
+    LightPosition[1] = 2.0f;
+    LightPosition[2] = 2.0f;
+    LightPosition[3] = 0.0f;
+    LightDiffuse[0] = 0.5f;
+    LightDiffuse[1] = 0.5f;
+    LightDiffuse[2] = 0.5f;
+    LightDiffuse[3] = 0.0f;
+    LightAmbient[0] = 0.0f;
+    LightAmbient[1] = 0.0f;
+    LightAmbient[2] = 0.0f;
+    LightAmbient[3] = 0.0f;
+
+    SelectionColor[0] = 0;
+    SelectionColor[1] = 128;
+    SelectionColor[2] = 128;
+
+    MultiViewEnabled = true;
+
+    isSignaller = false;
+
+    World::getInstance().signOn(this);
+}
+
+/** Destructor of GLMoleculeView.
+ * Free's the CallList.
+ */
 GLMoleculeView::~GLMoleculeView()
-{}
+{
+    makeCurrent();
+    glDeleteLists( object, 1 );
+
+    World::getInstance().signOff(this);
+}
+
+/** Paints the conents of the OpenGL window.
+ * Clears the GL buffers, enables lighting and depth.
+ * Window is either quartered (if GLMoleculeView::MultiViewEnabled) and xy, xz, yz planar views
+ * are added. Uses the CallList, constructed during InitializeGL().
+ */
+void GLMoleculeView::paintGL()
+{
+  Vector spot;
+
+  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glShadeModel(GL_SMOOTH);            // Enable Smooth Shading
+  glEnable(GL_LIGHTING);              // Enable Light One
+  glEnable(GL_DEPTH_TEST);            // Enables Depth Testing
+  glDepthFunc(GL_LEQUAL);              // The Type Of Depth Testing To Do
+  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);      // Really Nice Perspective Calculations
+
+  // 3d viewport
+  if (MultiViewEnabled)
+    glViewport( 0, 0, (GLint)width/2, (GLint)height/2 );
+  else
+    glViewport( 0, 0, (GLint)width, (GLint)height );
+  glMatrixMode( GL_PROJECTION );
+  glLoadIdentity();
+  glFrustum( -1.0, 1.0, -1.0, 1.0, 1.0, 50.0 );
+  glMatrixMode( GL_MODELVIEW );
+  glLoadIdentity();
+
+  // calculate point of view and direction
+  glTranslated(position[0],position[1],position[2]);
+  glTranslated(0.0, 0.0, -scale);
+  glRotated(xRot, 1.0, 0.0, 0.0);
+  glRotated(yRot, 0.0, 1.0, 0.0);
+  glRotated(zRot, 0.0, 0.0, 1.0);
+
+  // render scene
+  glCallList(object);
+
+  // enable light
+  glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);       // Setup The Ambient Light
+  glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);       // Setup The Diffuse Light
+  glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);      // Position The Light
+  glEnable(GL_LIGHT1);              // Enable Light One
+
+  if (MultiViewEnabled) {
+    // xy view port
+    glViewport( (GLint)width/2, 0, (GLint)width/2, (GLint)height/2 );
+    glMatrixMode( GL_PROJECTION );
+    glLoadIdentity();
+    glScalef(1./scale, 1./scale,1./scale);
+    glOrtho(0, width/2, 0, height/2, 0,0);
+    glMatrixMode( GL_MODELVIEW );
+    glLoadIdentity();
+
+    // calculate point of view and direction
+    view = position;
+    spot = Vector(0.,0.,scale);
+    top = Vector(0.,1.,0.);
+    gluLookAt(
+        spot[0], spot[1], spot[2],
+        view[0], view[1], view[2],
+        top[0], top[1], top[2]);
+
+    // enable light
+    glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);       // Setup The Ambient Light
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);       // Setup The Diffuse Light
+    glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);      // Position The Light
+    glEnable(GL_LIGHT1);              // Enable Light One
+
+    // render scene
+    glCallList(object);
+
+    // xz viewport
+    glViewport( 0, (GLint)height/2, (GLint)width/2, (GLint)height/2 );
+    glMatrixMode( GL_PROJECTION );
+    glLoadIdentity();
+    glScalef(1./scale, 1./scale,1./scale);
+    glOrtho(0, width/2, 0, height/2, 0,0);
+    glMatrixMode( GL_MODELVIEW );
+    glLoadIdentity();
+
+    // calculate point of view and direction
+    view = position;
+    spot = Vector(0.,scale,0.);
+    top = Vector(1.,0.,0.);
+    gluLookAt(
+        spot[0], spot[1], spot[2],
+        view[0], view[1], view[2],
+        top[0], top[1], top[2]);
+
+    // enable light
+    glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);       // Setup The Ambient Light
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);       // Setup The Diffuse Light
+    glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);      // Position The Light
+    glEnable(GL_LIGHT1);              // Enable Light One
+
+    // render scene
+    glCallList(object);
+
+    //yz viewport
+    glViewport( (GLint)width/2, (GLint)height/2, (GLint)width/2, (GLint)height/2 );
+    glMatrixMode( GL_PROJECTION );
+    glLoadIdentity();
+    glScalef(1./scale, 1./scale,1./scale);
+    glOrtho(0, width/2, 0, height/2, 0,0);
+    glMatrixMode( GL_MODELVIEW );
+    glLoadIdentity();
+
+    // calculate point of view and direction
+    view= position;
+    spot = Vector(scale,0.,0.);
+    top = Vector(0.,1.,0.);
+    gluLookAt(
+        spot[0], spot[1], spot[2],
+        view[0], view[1], view[2],
+        top[0], top[1], top[2]);
+
+    // enable light
+    glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);       // Setup The Ambient Light
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);       // Setup The Diffuse Light
+    glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);      // Position The Light
+    glEnable(GL_LIGHT1);              // Enable Light One
+
+    // render scene
+    glCallList(object);
+  }
+  //CoordinatesBar->setText( QString ("X: %1, Y: %2, Z: %3").arg(position[0]).arg(position[1]).arg(position[2]) );
+}
+
+//void polarView{GLdouble distance, GLdouble twist,
+//   GLdouble elevation, GLdouble azimuth)
+//{
+//      glTranslated(0.0, 0.0, -distance);
+//      glRotated(-twist, 0.0, 0.0, 1.0);
+//      glRotated(-elevation, 1.0, 0.0, 0.0);
+//      glRotated(azimuth, 0.0, 0.0, 1.0);
+//}
+
+/** Make a sphere.
+ * \param x position
+ * \param radius radius
+ * \param color[3] color rgb values
+ */
+void GLMoleculeView::makeSphere(const Vector &x, double radius, const unsigned char color[3])
+{
+  float blueMaterial[] = { 255./(float)color[0], 255./(float)color[1], 255./(float)color[2], 1 };  // need to recast from [0,255] with integers into [0,1] with floats
+  GLUquadricObj* q = gluNewQuadric ();
+
+  std::cout << "Setting sphere at " << x << " with color r"
+      << (int)color[0] << ",g" << (int)color[1] << ",b" << (int)color[2] << "." << endl;
+
+  glPushMatrix();
+  glTranslatef( x[0], x[1], x[2]);
+//  glRotatef( xRot, 1.0, 0.0, 0.0);
+//  glRotatef( yRot, 0.0, 1.0, 0.0);
+//  glRotatef( zRot, 0.0, 0.0, 1.0);
+  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, blueMaterial);
+  gluSphere (q, (GLdouble)radius, 10, 10);
+  glPopMatrix();
+}
+
+/** Make a cylinder.
+ * \param x origin
+ * \param y direction
+ * \param radius thickness
+ * \param height length
+ * \color[3] color rgb values
+ */
+void GLMoleculeView::makeCylinder(const Vector &x, const Vector &y, double radius, double height, const unsigned char color[3])
+{
+  float blueMaterial[] = { 255./(float)color[0], 255./(float)color[1], 255./(float)color[2], 1 };
+  GLUquadricObj* q = gluNewQuadric ();
+  Vector a,b;
+  double alpha;
+  a = x - b;
+  b.GetOneNormalVector(a);
+  b.MakeNormalTo(Z);
+  alpha = a.Angle(Z);
+  if (fabs(a[2]) > MYEPSILON)   // I have no idea why I need to check this, but this fixes the sign problem of the rotation angle
+    alpha = M_PI-alpha;
+  Line axis(zeroVec, b);
+  a = axis.rotateVector(a, alpha);
+  std::cout << "Setting cylinder from " << x << " to " << a << " with color r"
+      << (int)color[0] << ",g" << (int)color[1] << ",b" << (int)color[2] << "." << endl;
+
+  glPushMatrix();
+  glTranslatef( x[0], x[1], x[2]);
+  glRotatef( alpha/M_PI*180., b[0], b[1], b[2]);
+  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, blueMaterial);
+  gluCylinder (q, (GLdouble)radius, (GLdouble)radius, (GLdouble)height, 10, 10);
+  glPopMatrix();
+}
+
+/** Defines the display CallList.
+ * Goes through all molecules and their atoms and adds spheres for atoms and cylinders
+ * for bonds. Heeds GLMoleculeView::SelectedAtom and GLMoleculeView::SelectedMolecule.
+ */
+void GLMoleculeView::initializeGL()
+{
+  double x[3] = {-1, 0, -10};
+  unsigned char white[3] = {255,255,255};
+  Vector Position, OtherPosition;
+  QSize window = size();
+  width = window.width();
+  height = window.height();
+  std::cout << "Setting width to " << width << " and height to " << height << std::endl;
+  GLfloat shininess[] = { 0.0 };
+  GLfloat specular[] = { 0, 0, 0, 1 };
+  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);     // Let OpenGL clear to black
+  object = glGenLists(1);
+  glNewList( object, GL_COMPILE );
+  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
+  glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
+
+  const std::vector<molecule*> &molecules = World::getInstance().getAllMolecules();
+
+  if (molecules.size() > 0) {
+    for (std::vector<molecule*>::const_iterator Runner = molecules.begin();
+        Runner != molecules.end();
+        Runner++) {
+      for (molecule::const_iterator atomiter = (*Runner)->begin();
+          atomiter != (*Runner)->end();
+          ++atomiter) {
+        // create atom
+        const element *ptr = (*atomiter)->getType();
+        molecule::const_iterator moliter = (*Runner)->begin();
+        Position = (*atomiter)->getPosition() - (*moliter)->getPosition();
+        const unsigned char* color = NULL;
+        if ((World::getInstance().isSelected(*atomiter)) || (World::getInstance().isSelected((*Runner))))
+          color = SelectionColor;
+        else
+          color = ptr->getColor();
+        makeSphere(Position, ptr->getVanDerWaalsRadius()*0.25, color);
+
+        // create bonds
+        const BondList &bonds = (*atomiter)->getListOfBonds();
+        for (BondList::const_iterator bonditer = bonds.begin();
+            bonditer != bonds.end();
+            ++bonditer) {
+          if ((*bonditer)->leftatom->getId() == (*atomiter)->getId()) {
+            Position = (*bonditer)->leftatom->getPosition() - (*moliter)->getPosition();
+            OtherPosition = (*bonditer)->rightatom->getPosition() - (*moliter)->getPosition();
+            const double distance = sqrt(Position.DistanceSquared(OtherPosition))/2.;
+            const unsigned char *color1 = (*bonditer)->leftatom->getType()->getColor();
+            const unsigned char *color2 = (*bonditer)->rightatom->getType()->getColor();
+            makeCylinder(Position, OtherPosition, 0.1, distance, color1);
+            makeCylinder(OtherPosition, Position, 0.1, distance, color2);
+          }
+        }
+      }
+    }
+  } else {
+    makeSphere( x,1, white);
+  }
+  glEndList();
+}
+
+
+/* ================================== SLOTS ============================== */
+
+/** Initializes some public variables.
+ * \param *ptr pointer to QLabel statusbar
+ */
+void GLMoleculeView::init(QLabel *ptr)
+{
+  StatusBar = ptr;
+}
+
+/** Initializes the viewport statusbar.
+ * \param *ptr pointer to QLabel for showing view pointcoordinates.
+ */
+void GLMoleculeView::initCoordinates(QLabel *ptr)
+{
+  CoordinatesBar = ptr;
+}
+
+/** Slot to be called when to initialize GLMoleculeView::MolData.
+ */
+void GLMoleculeView::createView( )
+{
+  initializeGL();
+  updateGL();
+}
+
+/** Slot of window is resized.
+ * Copies new width and height to GLMoleculeView::width and GLMoleculeView::height and calls updateGL().
+ * \param w new width of window
+ * \param h new height of window
+ */
+void GLMoleculeView::resizeGL( int w, int h )
+{
+  width = w;
+  height = h;
+  updateGL();
+}
+
+/** Sets x rotation angle.
+ * sets GLMoleculeView::xRot and calls updateGL().
+ * \param degrees new rotation angle in degrees
+ */
+void GLMoleculeView::setXRotation( int degrees )
+{
+  xRot = (GLfloat)(degrees % 360);
+  updateGL();
+}
+
+
+/** Sets y rotation angle.
+ * sets GLMoleculeView::yRot and calls updateGL().
+ * \param degrees new rotation angle in degrees
+ */
+void GLMoleculeView::setYRotation( int degrees )
+{
+  yRot = (GLfloat)(degrees % 360);
+  updateGL();
+}
+
+
+/** Sets z rotation angle.
+ * sets GLMoleculeView::zRot and calls updateGL().
+ * \param degrees new rotation angle in degrees
+ */
+void GLMoleculeView::setZRotation( int degrees )
+{
+  zRot = (GLfloat)(degrees % 360);
+  updateGL();
+}
+
+/** Sets the scale of the scene.
+ * sets GLMoleculeView::scale and calls updateGL().
+ * \param distance distance divided by 100 is the new scale
+ */
+void GLMoleculeView::setScale( int distance )
+{
+  scale = (GLfloat)(distance / 100.);
+  updateGL();
+}
+
+/** Update the ambient light.
+ * \param light[4] light strength per axis and position (w)
+ */
+void GLMoleculeView::setLightAmbient( int *light )
+{
+  for(int i=0;i<4;i++)
+    LightAmbient[i] = light[i];
+  updateGL();
+}
+
+/** Update the diffuse light.
+ * \param light[4] light strength per axis and position (w)
+ */
+void GLMoleculeView::setLightDiffuse( int *light )
+{
+  for(int i=0;i<4;i++)
+    LightDiffuse[i] = light[i];
+  updateGL();
+}
+
+/** Update the position of light.
+ * \param light[4] light strength per axis and position (w)
+ */
+void GLMoleculeView::setLightPosition( int *light )
+{
+  for(int i=0;i<4;i++)
+    LightPosition[i] = light[i];
+  updateGL();
+}
+
+/** Toggles the boolean GLMoleculeView::MultiViewEnabled.
+ * Flips the boolean and calls updateGL().
+ */
+void GLMoleculeView::toggleMultiViewEnabled ( )
+{
+  MultiViewEnabled = !MultiViewEnabled;
+  cout << "Setting MultiView to " << MultiViewEnabled << "." << endl;
+  updateGL();
+}
+
+/** Launch a dialog to configure the lights.
+ */
+void GLMoleculeView::createDialogLight()
+{
+//  Ui_DialogLight *Lights = new Ui_DialogLight();
+//  if (Lights == NULL)
+//    return;
+//  // Set up the dynamic dialog here
+//  QLineEdit *Field = NULL;
+//  Field = Lights->findChild<QLineEdit *>("LightPositionX");
+//  if (Field) Field->setText( QString("%1").arg(LightPosition[0]) );
+//  Field = Lights->findChild<QLineEdit *>("LightPositionY");
+//  if (Field) Field->setText( QString("%1").arg(LightPosition[1]) );
+//  Field = Lights->findChild<QLineEdit *>("LightPositionZ");
+//  if (Field) Field->setText( QString("%1").arg(LightPosition[2]) );
+//  Field = Lights->findChild<QLineEdit *>("LightPositionW");
+//  if (Field) Field->setText( QString("%1").arg(LightPosition[3]) );
+//
+//  Field = Lights->findChild<QLineEdit *>("LightDiffuseX");
+//  if (Field) Field->setText( QString("%1").arg(LightDiffuse[0]) );
+//  Field = Lights->findChild<QLineEdit *>("LightDiffuseY");
+//  if (Field) Field->setText( QString("%1").arg(LightDiffuse[1]) );
+//  Field = Lights->findChild<QLineEdit *>("LightDiffuseZ");
+//  if (Field) Field->setText( QString("%1").arg(LightDiffuse[2]) );
+//  Field = Lights->findChild<QLineEdit *>("LightDiffuseW");
+//  if (Field) Field->setText( QString("%1").arg(LightDiffuse[3]) );
+//
+//  Field = Lights->findChild<QLineEdit *>("LightAmbientX");
+//  if (Field) Field->setText( QString("%1").arg(LightAmbient[0]) );
+//  Field = Lights->findChild<QLineEdit *>("LightAmbientY");
+//  if (Field) Field->setText( QString("%1").arg(LightAmbient[1]) );
+//  Field = Lights->findChild<QLineEdit *>("LightAmbientZ");
+//  if (Field) Field->setText( QString("%1").arg(LightAmbient[2]) );
+//  Field = Lights->findChild<QLineEdit *>("LightAmbientW");
+//  if (Field) Field->setText( QString("%1").arg(LightAmbient[3]) );
+//
+//  if ( Lights->exec() ) {
+//    //cout << "User accepted.\n";
+//    // The user accepted, act accordingly
+//    Field = Lights->findChild<QLineEdit *>("LightPositionX");
+//    if (Field) LightPosition[0] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightPositionY");
+//    if (Field) LightPosition[1] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightPositionZ");
+//    if (Field) LightPosition[2] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightPositionW");
+//    if (Field) LightPosition[3] = Field->text().toDouble();
+//
+//    Field = Lights->findChild<QLineEdit *>("LightDiffuseX");
+//    if (Field) LightDiffuse[0] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightDiffuseY");
+//    if (Field) LightDiffuse[1] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightDiffuseZ");
+//    if (Field) LightDiffuse[2] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightDiffuseW");
+//    if (Field) LightDiffuse[3] = Field->text().toDouble();
+//
+//    Field = Lights->findChild<QLineEdit *>("LightAmbientX");
+//    if (Field) LightAmbient[0] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightAmbientY");
+//    if (Field) LightAmbient[1] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightAmbientZ");
+//    if (Field) LightAmbient[2] = Field->text().toDouble();
+//    Field = Lights->findChild<QLineEdit *>("LightAmbientW");
+//    if (Field) LightAmbient[3] = Field->text().toDouble();
+//    updateGL();
+//  } else {
+//    //cout << "User reclined.\n";
+//  }
+//  delete(Lights);
+}
+
+/** Slot for event of pressed mouse button.
+ * Switch discerns between buttons and stores position of event in GLMoleculeView::LeftButtonPos,
+ * GLMoleculeView::MiddleButtonPos or GLMoleculeView::RightButtonPos.
+ * \param *event structure containing information of the event
+ */
+void GLMoleculeView::mousePressEvent(QMouseEvent *event)
+{
+  std::cout << "MousePressEvent." << endl;
+  QPoint *pos = NULL;
+  switch (event->button()) {  // get the right array
+    case Qt::LeftButton:
+      pos = &LeftButtonPos;
+      std::cout << "Left Button" << endl;
+      break;
+    case Qt::MidButton:
+      pos = &MiddleButtonPos;
+      std::cout << "Middle Button" << endl;
+      break;
+    case Qt::RightButton:
+      pos = &RightButtonPos;
+      std::cout << "Right Button" << endl;
+      break;
+    default:
+      break;
+  }
+  if (pos) {    // store the position
+    pos->setX(event->pos().x());
+    pos->setY(event->pos().y());
+    std::cout << "Stored src position is (" << pos->x() << "," << pos->y() << ")." << endl;
+  } else {
+    std::cout << "pos is NULL." << endl;
+  }
+}
+
+/** Slot for event of pressed mouse button.
+ * Switch discerns between buttons:
+ * -# Left Button: Rotates the view of the GLMoleculeView, relative to GLMoleculeView::LeftButtonPos.
+ * -# Middle Button: nothing
+ * -# Right Button: Shifts the selected molecule or atom, relative to GLMoleculeView::RightButtonPos.
+ * \param *event structure containing information of the event
+ */
+void GLMoleculeView::mouseReleaseEvent(QMouseEvent *event)
+{
+  std::cout << "MouseReleaseEvent." << endl;
+  QPoint *srcpos = NULL;
+  QPoint destpos = event->pos();
+  int Width = (MultiViewEnabled) ? width/2 : width;
+  int Height = (MultiViewEnabled) ? height/2 : height;
+  std::cout << "Received dest position is (" << destpos.x() << "," << destpos.y() << ")." << endl;
+  switch (event->button()) {  // get the right array
+    case Qt::LeftButton:  // LeftButton rotates the view
+      srcpos = &LeftButtonPos;
+      std::cout << "Left Button" << endl;
+      if (srcpos) {    // subtract the position and act
+        std::cout << "Stored src position is (" << srcpos->x() << "," << srcpos->y() << ")." << endl;
+        destpos -= *srcpos;
+        std::cout << "Resulting diff position is (" << destpos.x() << "," << destpos.y() << ")." << endl;
+        std::cout << "Width and Height are " << Width << "," << Height << "." << endl;
+
+        int pos = (int)floor((double)srcpos->x()/(double)Width) + ((int)floor((double)srcpos->y()/(double)Height))*2;
+        if ((MultiViewEnabled) && (pos != 2)) { // means four regions, and we are in a shifting one
+          // switch between three regions
+          // decide into which of the four screens the initial click has been made
+          std::cout << "Position is " << pos << "." << endl;
+          switch(pos) {
+            case 0:  // lower left = xz
+              position[0] += -destpos.y()/100.;
+              position[2] += destpos.x()/100.;
+              break;
+            case 1: // lower right = yz
+              position[1] += -destpos.y()/100.;
+              position[2] += -destpos.x()/100.;
+              break;
+            case 2:  // upper left = projected
+              std::cout << "This is impossible: Shifting in the projected region, we should rotate!." << endl;
+              break;
+            case 3:  // upper right = xy
+              position[0] += destpos.x()/100.;
+              position[1] += -destpos.y()/100.;
+              break;
+            default:
+              std::cout << "click was not in any of the four regions." << endl;
+              break;
+          }
+          updateGL();
+        } else { // we are in rotation region
+          QWidget *Parent = parentWidget();
+          QSlider *sliderX = Parent->findChild<QSlider *>("sliderX");
+          QSlider *sliderY = Parent->findChild<QSlider *>("sliderY");
+          std::cout << sliderX << " and " << sliderY << endl;
+          if (sliderX) {
+            int xrange = sliderX->maximum() - sliderX->minimum();
+            double xValue = ((destpos.x() + Width) % Width);
+            xValue *= (double)xrange/(double)Width;
+            xValue += sliderX->value();
+            int xvalue = (int) xValue % xrange;
+            std::cout << "Setting x to " << xvalue << " within range " << xrange << "." << endl;
+            setXRotation(xvalue);
+            sliderX->setValue(xvalue);
+          } else {
+            std::cout << "sliderX is NULL." << endl;
+          }
+          if (sliderY) {
+            int yrange = sliderY->maximum() - sliderY->minimum();
+            double yValue = ((destpos.y() + Height) % Height);
+            yValue *= (double)yrange/(double)Height;
+            yValue += sliderY->value();
+            int yvalue = (int) yValue % yrange;
+            std::cout << "Setting y to " << yvalue << " within range " << yrange << "." << endl;
+            setYRotation(yvalue);
+            sliderY->setValue(yvalue);
+          } else {
+            std::cout << "sliderY is NULL." << endl;
+          }
+        }
+      } else {
+        std::cout << "srcpos is NULL." << endl;
+      }
+      break;
+
+    case Qt::MidButton: // MiddleButton has no function so far
+      srcpos = &MiddleButtonPos;
+      std::cout << "Middle Button" << endl;
+      if (srcpos) {    // subtract the position and act
+        QWidget *Parent = parentWidget();
+        QSlider *sliderZ = Parent->findChild<QSlider *>("sliderZ");
+        QSlider *sliderScale = Parent->findChild<QSlider *>("sliderScale");
+        std::cout << sliderZ << " and " << sliderScale << endl;
+        std::cout << "Stored src position is (" << srcpos->x() << "," << srcpos->y() << ")." << endl;
+        destpos -= *srcpos;
+        std::cout << "Resulting diff position is (" << destpos.x() << "," << destpos.y() << ")." << endl;
+        std::cout << "Width and Height are " << Width << "," << Height << "." << endl;
+        if (sliderZ) {
+          int xrange = sliderZ->maximum() - sliderZ->minimum();
+          double xValue = ((destpos.x() + Width) % Width);
+          xValue *= (double)xrange/(double)Width;
+          xValue += sliderZ->value();
+          int xvalue = (int) xValue % xrange;
+          std::cout << "Setting x to " << xvalue << " within range " << xrange << "." << endl;
+          setZRotation(xvalue);
+          sliderZ->setValue(xvalue);
+        } else {
+          std::cout << "sliderZ is NULL." << endl;
+        }
+        if (sliderScale) {
+          int yrange = sliderScale->maximum() - sliderScale->minimum();
+          double yValue = ((destpos.y() + Height) % Height);
+          yValue *= (double)yrange/(double)Height;
+          yValue += sliderScale->value();
+          int yvalue = (int) yValue % yrange;
+          std::cout << "Setting y to " << yvalue << " within range " << yrange << "." << endl;
+          setScale(yvalue);
+          sliderScale->setValue(yvalue);
+        } else {
+          std::cout << "sliderScale is NULL." << endl;
+        }
+      } else {
+        std::cout << "srcpos is NULL." << endl;
+      }
+      break;
+      break;
+
+    case Qt::RightButton:  // RightButton moves eitstdher the selected molecule or atom
+      srcpos = &RightButtonPos;
+      std::cout << "Right Button" << endl;
+      if (srcpos) {    // subtract the position and act
+        std::cout << "Stored src position is (" << srcpos->x() << "," << srcpos->y() << ")." << endl;
+        destpos -= *srcpos;
+        std::cout << "Resulting diff position is (" << destpos.x() << "," << destpos.y() << ")." << endl;
+        std::cout << "Width and Height are " << Width << "," << Height << "." << endl;
+        if (MultiViewEnabled) {
+          // which vector to change
+          Vector SelectedPosition;
+          const std::vector<atom*> &SelectedAtoms = World::getInstance().getSelectedAtoms();
+          const std::vector<molecule*> &SelectedMolecules = World::getInstance().getSelectedMolecules();
+          if (SelectedMolecules.size()) {
+            if (SelectedAtoms.size())
+              SelectedPosition = (*SelectedAtoms.begin())->getPosition();
+            else
+              SelectedPosition = (*(*SelectedMolecules.begin())->begin())->getPosition();
+          }
+          // decide into which of the four screens the initial click has been made
+          int pos = (int)floor((double)srcpos->x()/(double)Width) + ((int)floor((double)srcpos->y()/(double)Height))*2;
+          if (!SelectedPosition.IsZero()) {
+            std::cout << "Position is " << pos << "." << endl;
+            switch(pos) {
+              case 0:  // lower left = xz
+                SelectedPosition[0] += -destpos.y()/100.;
+                SelectedPosition[2] += destpos.x()/100.;
+                break;
+              case 1: // lower right = yz
+                SelectedPosition[1] += -destpos.y()/100.;
+                SelectedPosition[2] += -destpos.x()/100.;
+                break;
+              case 2:  // upper left = projected
+                SelectedPosition[0] += destpos.x()/100.;
+                SelectedPosition[1] += destpos.y()/100.;
+                SelectedPosition[2] += destpos.y()/100.;
+                break;
+              case 3:  // upper right = xy
+                SelectedPosition[0] += destpos.x()/100.;
+                SelectedPosition[1] += -destpos.y()/100.;
+                break;
+              default:
+                std::cout << "click was not in any of the four regions." << endl;
+                break;
+            }
+          } else {
+            std::cout << "Nothing selected." << endl;
+          }
+          // update Tables
+          if (SelectedMolecules.size()) {
+            isSignaller = true;
+            if (SelectedAtoms.size())
+              emit notifyAtomChanged( (*SelectedMolecules.begin()), (*SelectedAtoms.begin()), AtomPosition);
+            else
+              emit notifyMoleculeChanged( (*SelectedMolecules.begin()), MoleculePosition );
+          }
+          // update graphic
+          initializeGL();
+          updateGL();
+        } else {
+          cout << "MultiView is not enabled." << endl;
+        }
+      } else {
+        cout << "srcpos is NULL." << endl;
+      }
+  break;
+
+    default:
+      break;
+  }
+}
+
+/* ======================================== SLOTS ================================ */
+
+/** Hear announcement of selected molecule.
+ * \param *mol pointer to selected molecule
+ */
+void GLMoleculeView::hearMoleculeSelected(molecule *mol)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+/** Hear announcement of selected atom.
+ * \param *mol pointer to molecule containing atom
+ * \param *Walker pointer to selected atom
+ */
+void GLMoleculeView::hearAtomSelected(molecule *mol, atom *Walker)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+/** Hear announcement of changed molecule.
+ * \param *mol pointer to changed molecule
+ * \param type of change
+ */
+void GLMoleculeView::hearMoleculeChanged(molecule *mol, enum ChangesinMolecule type)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+/** Hear announcement of changed atom.
+ * \param *mol pointer to molecule containing atom
+ * \param *Walker pointer to changed atom
+ * \param type type of change
+ */
+void GLMoleculeView::hearAtomChanged(molecule *mol, atom *Walker, enum ChangesinAtom type)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+/** Hear announcement of changed element.
+ * \param *Runner pointer to changed element
+ * \param type of change
+ */
+void GLMoleculeView::hearElementChanged(element *Runner, enum ChangesinElement type)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  switch(type) {
+    default:
+    case ElementName:
+    case ElementSymbol:
+    case ElementMass:
+    case ElementValence:
+    case ElementZ:
+      break;
+    case ElementCovalent:
+    case ElementVanderWaals:
+      initializeGL();
+      updateGL();
+      break;
+  }
+};
+
+/** Hear announcement of added molecule.
+ * \param *mol pointer to added molecule
+ */
+void GLMoleculeView::hearMoleculeAdded(molecule *mol)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+/** Hear announcement of added atom.
+ * \param *mol pointer to molecule containing atom
+ * \param *Walker pointer to added atom
+ */
+void GLMoleculeView::hearAtomAdded(molecule *mol, atom *Walker)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+/** Hear announcement of removed molecule.
+ * \param *mol pointer to removed molecule
+ */
+void GLMoleculeView::hearMoleculeRemoved(molecule *mol)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+/** Hear announcement of removed atom.
+ * \param *mol pointer to molecule containing atom
+ * \param *Walker pointer to removed atom
+ */
+void GLMoleculeView::hearAtomRemoved(molecule *mol, atom *Walker)
+{
+  if (isSignaller) { // if we emitted the signal, return
+    isSignaller = false;
+    return;
+  }
+  initializeGL();
+  updateGL();
+};
+
+void GLMoleculeView::update(Observable *publisher)
+{
+  initializeGL();
+  updateGL();
+}
+
+/**
+ * This method is called when a special named change
+ * of the Observable occured
+ */
+void GLMoleculeView::recieveNotification(Observable *publisher, Notification_ptr notification)
+{
+  initializeGL();
+  updateGL();
+}
+
+/**
+ * This method is called when the observed object is destroyed.
+ */
+void GLMoleculeView::subjectKilled(Observable *publisher)
+{
+
+}
+
+

src/UIElements/Views/Qt4/GLMoleculeView.hpp

@@ -2 +2 @@
  * GLMoleculeView.hpp
  *
- *  Created on: Jan 26, 2010
- *      Author: crueger
+ *  Created on: Auf 11, 2010
+ *      Author: heber
  */
 
@@ -14 +14 @@
 #endif
 
+#include <qgl.h>
+#include <qdialog.h>
+#include <qlabel.h>
+#include <qlineedit.h>
+//#include <qwidgetfactory.h>
 
-#include <QtOpenGL/QGLWidget>
+#include "CodePatterns/Observer.hpp"
+#include "LinearAlgebra/Vector.hpp"
+#include "changetypes.hpp"
 
-class GLMoleculeView :  public QGLWidget
+class atom;
+class element;
+class molecule;
+
+class GLMoleculeView : public QGLWidget, public Observer
 {
-  Q_OBJECT
+    Q_OBJECT
+
 public:
-  GLMoleculeView(QWidget *parent=0);
-  virtual ~GLMoleculeView();
+
+    GLMoleculeView( QWidget* parent);
+    ~GLMoleculeView();
+
+public slots:
+
+    void    setXRotation( int degrees );
+    void    setYRotation( int degrees );
+    void    setZRotation( int degrees );
+    void    setScale( int distance );
+    void    setLightPosition( int *light );
+    void    setLightDiffuse( int *light );
+    void    setLightAmbient( int *light );
+    void    createDialogLight();
+    void    toggleMultiViewEnabled();
+
+    void    init( QLabel *ptr );
+    void    initCoordinates(QLabel *ptr);
+    void    createView();
+    void    hearMoleculeSelected(molecule *mol);
+    void    hearAtomSelected(molecule *mol, atom *Walker);
+    void    hearMoleculeChanged(molecule *mol, enum ChangesinMolecule type);
+    void    hearAtomChanged(molecule *mol, atom *Walker, enum ChangesinAtom type);
+    void    hearElementChanged(element *Runner, enum ChangesinElement type);
+    void    hearMoleculeAdded(molecule *mol);
+    void    hearAtomAdded(molecule *mol, atom *Walker);
+    void    hearMoleculeRemoved(molecule *mol);
+    void    hearAtomRemoved(molecule *mol, atom *Walker);
+
+signals:
+    void    notifyMoleculeSelected( molecule *mol );
+    void    notifyAtomSelected( molecule *mol, atom *Walker );
+    void    notifyMoleculeChanged( molecule *mol, enum ChangesinMolecule type );
+    void    notifyAtomChanged( molecule *mol, atom *Walker, enum ChangesinAtom type );
+    void    notifyElementChanged( element *Runner, enum ChangesinElement type );
+    void    notifyMoleculeAdded( molecule *mol);
+    void    notifyElementAdded( element *Runner);
+    void    notifyAtomAdded( molecule *mol, atom *Walker );
+    void    notifyMoleculeRemoved( molecule *mol );
+    void    notifyAtomRemoved( molecule *mol, atom *Walker );
+
+protected:
+
+    void    initializeGL();
+    void    paintGL();
+    void    resizeGL( int w, int h );
+    void    makeSphere(const Vector &x, double radius, const unsigned char color[3]);
+    void    makeCylinder(const Vector &x, const Vector &y, double radius, double height, const unsigned char color[3]);
+    void mousePressEvent(QMouseEvent* event);
+    void mouseReleaseEvent(QMouseEvent* event);
+
+public:
+
+    /** Update function as we are an Observer.
+     *
+     * @param publisher ref to Observable
+     */
+    void update(Observable *publisher);
+
+    /**
+     * This method is called when a special named change
+     * of the Observable occured
+     */
+    void recieveNotification(Observable *publisher, Notification_ptr notification);
+
+    /**
+     * This method is called when the observed object is destroyed.
+     */
+    void subjectKilled(Observable *publisher);
+
+
+private:
+
+    GLuint object;  // call list for the scene to be rendered
+    GLfloat xRot, yRot, zRot, scale;  // rotation angles and scaling (zoom)
+    Vector position;  //!< position of observer
+    Vector view;      //!< point along line of view
+    Vector top;       //!< giving upwards direction
+    Vector X,Y,Z;     //!< vectors defining the coordinate system
+    int width;        //!< width of window
+    int height;       //!< height of window
+
+  QLabel *StatusBar;  //!< pointer to status bar for messages
+  QLabel *CoordinatesBar; //!< pointer to coordinates bar for view port
+
+  GLfloat LightPosition[4];        //!< Light Position
+  GLfloat LightDiffuse[4];         //!< Diffuse Light Values
+  GLfloat LightAmbient[4];        //!< Ambient Light Values
+
+  QPoint LeftButtonPos;     //!< mouse position on mousePressEvent for LeftButton
+  QPoint MiddleButtonPos;   //!< mouse position on mousePressEvent for MidButton
+  QPoint RightButtonPos;    //!< mouse position on mousePressEvent for RightButton
+
+  unsigned char SelectionColor[3] ; //!< highlight color
+
+  bool isSignaller;
+
+  bool MultiViewEnabled;    //!< if true, split screen into four parts with additional xy,xz,yz views
 };