kalzium/libavogadro-kalzium/src/glwidget.h

   1 /**********************************************************************
   2   GLWidget - general OpenGL display
   3
   4   Copyright (C) 2006,2007 Geoffrey R. Hutchison
   5   Copyright (C) 2006,2007 Donald Ephraim Curtis
   6   Copyright (C) 2007 Marcus D. Hanwell
   7
   8   This file is part of the Avogadro molecular editor project.
   9   For more information, see <http://avogadro.sourceforge.net/>
  10
  11   Avogadro is free software; you can redistribute it and/or modify
  12   it under the terms of the GNU General Public License as published by
  13   the Free Software Foundation; either version 2 of the License, or
  14   (at your option) any later version.
  15
  16   Avogadro is distributed in the hope that it will be useful,
  17   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19   GNU General Public License for more details.
  20
  21   You should have received a copy of the GNU General Public License
  22   along with this program; if not, write to the Free Software
  23   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  24   02110-1301, USA.
  25  **********************************************************************/
  26
  27 #ifndef __GLWIDGET_H
  28 #define __GLWIDGET_H
  29
  30 #include <avogadro/global.h>
  31 #include <avogadro/engine.h>
  32 #include <avogadro/tool.h>
  33 #include <avogadro/color.h>
  34 #include <avogadro/painter.h>
  35 #include <avogadro/camera.h>
  36
  37 #include <QThread>
  38
  39 #include <vector>
  40
  41 class QUndoStack;
  42 class QMouseEvent;
  43 class QGLContext;
  44
  45 namespace Avogadro {
  46
  47   class ToolGroup;
  48
  49   /**
  50    * @class GLHit glwidget.h <avogadro/glwidget.h>
  51    * @brief Class for wrapping hits from GL picking.
  52    * @author Donald Ephraim Curtis
  53    *
  54    * Provides an easy to use class to contain OpenGL hits returned from the
  55    * process of picking.  This class relies on the %Engine subclasses properly
  56    * naming the objects that they are rendering.  For more information see the
  57    * Engine documentation.
  58    */
  59   class GLHitPrivate;
  60   class A_EXPORT GLHit
  61   {
  62     public:
  63       /**
  64        * Blank constructor.
  65        */
  66       GLHit();
  67       /**
  68        * Copy constructor.
  69        */
  70       GLHit(const GLHit &glHit);
  71       /**
  72        * Constructor.
  73        * @param type The type of the OpenGL object that was picked which corresponds
  74        * to the Primitive::Type for the object
  75        * (ie. type==Primitive::AtomType means an Atom was picked).
  76        * @param name The name of the OpenGL object that was picked corresponding
  77        * to the primitive index
  78        * (ie. name==1 means Atom 1).
  79        */
  80       GLHit(GLuint type, GLuint name, GLuint minZ, GLuint maxZ);
  81       /**
  82        * Destructor.
  83        */
  84       ~GLHit();
  85
  86       /**
  87        * Less than operator.
  88        * @param other the other GLHit object to compare to.
  89        * @return (this->minZ < other->minZ) ? @c true : @c false
  90        */
  91       bool operator<(const GLHit &other) const;
  92
  93       /**
  94        * Equivalence operator.
  95        * @param other the other GLHit object to test equivalence with.
  96        * @return returns true if all elements are equivalent (type, name, minZ, maxZ).
  97        */
  98       bool operator==(const GLHit &other) const;
  99
 100       /**
 101        * Copy operator.
 102        * @param other the GLHit object to set this object equal to.
 103        * @return  *this
 104        */
 105       GLHit &operator=(const GLHit &other);
 106
 107       /**
 108        * @return type of the object that was picked.
 109        */
 110       GLuint type() const;
 111
 112       /**
 113        * @return name of the object that was picked.
 114        */
 115       GLuint name() const;
 116
 117       /**
 118        * @return the minimum z value of this hit corresponding
 119        * to the z value of the drawn object closest to the camera.
 120        */
 121       GLuint minZ() const;
 122
 123       /**
 124        * @return the maximum z value of this hit corresponding
 125        * to the z value of the drawn object farthest from the camera.
 126        */
 127       GLuint maxZ() const;
 128
 129       /**
 130        * @param type new object type.
 131        */
 132       void setType(GLuint type);
 133       /**
 134        * @param name new object name.
 135        */
 136       void setName(GLuint name);
 137       /**
 138        * @param minZ minimum z value to set for this object.
 139        */
 140       void setMinZ(GLuint minZ);
 141       /**
 142        * @param maxZ maximum z value to set for this object.
 143        */
 144       void setMaxZ(GLuint maxZ);
 145
 146     private:
 147       GLHitPrivate * const d;
 148   };
 149
 150   /**
 151    * @class GLWidget glwidget.h <avogadro/glwidget.h>
 152    * @brief GL widget class for rendering molecules.
 153    * @author Donald Ephraim Curtis
 154    * @author Marcus D. Hanwell
 155    *
 156    * This widget provides a 3D graphical view of a molecule.   In terms
 157    * of the Model-View architecture we consider
 158    * the Molecule the model and GLWidget a view of this model.
 159    * The widget relies on various Engine subclasses to handle the
 160    * rendering of the 3d objects.
 161    *
 162    * Each engine is allocated a PrimitiveList object.  This queue contains
 163    * all primitivew which that engine is responsible for rendering for this
 164    * GLWidget.  Thus, we can have one queue containing only the bonds, and
 165    * one queue containing only the atoms which would allow bonds and atoms
 166    * to be rendered by two different engines.
 167    */
 168   class GLThread;
 169   class GLWidgetPrivate;
 170   class GLPainterDevice;
 171   class A_EXPORT GLWidget : public QGLWidget
 172   {
 173     friend class GLThread;
 174
 175     Q_OBJECT
 176     Q_PROPERTY(QColor background READ background WRITE setBackground)
 177 //    Q_PROPERTY(float scale READ scale WRITE setScale)
 178
 179     public:
 180       /**
 181        * Constructor.
 182        * @param parent the widget parent.
 183        */
 184       GLWidget(QWidget *parent = 0);
 185
 186       /**
 187        * Constructor.
 188        * @param format the QGLFormat information.
 189        * @param parent the widget parent.
 190        */
 191       explicit GLWidget(const QGLFormat &format, QWidget *parent = 0, const GLWidget * shareWidget = 0);
 192
 193       /**
 194        * Constructor.
 195        * @param molecule the molecule to view.
 196        * @param format the QGLFormat information.
 197        * @param parent the widget parent.
 198        */
 199       GLWidget(Molecule *molecule, const QGLFormat &format, QWidget *parent = 0, const GLWidget * shareWidget = 0);
 200
 201       /**
 202        * Destructor.
 203        */
 204       ~GLWidget();
 205
 206       /**
 207        * @return true if the GLWidget is stable as determined
 208        * by the tools and extensions.
 209        */
 210       bool isStable() const;
 211
 212       /**
 213        * @param stable the new stable value.
 214        */
 215       void setStable(bool stable);
 216
 217       /**
 218        * @return the width of the widget in pixels.
 219        */
 220       int deviceWidth() { return width(); }
 221
 222       /**
 223        * @return the height of the widget in pixels.
 224        */
 225       int deviceHeight() { return height(); }
 226
 227       /**
 228        * Virtual function setting the size hint for this widget.
 229        *
 230        * @return the preferred size of the widget.
 231        */
 232       QSize sizeHint() const;
 233
 234       /**
 235        * Virtual function setting the minimum size hit for this widget.
 236        *
 237        * @return the minimum size the widget can take without causing
 238        * unspecified behaviour.
 239        */
 240       QSize minimumSizeHint() const;
 241
 242       /**
 243        * @return the radius of the primitive object for this glwidget.
 244        */
 245       double radius(const Primitive *p) const;
 246
 247       /**
 248        * @return the active Tool.
 249        */
 250       Tool* tool() const;
 251
 252       /**
 253        * @return the ToolGroup manager.
 254        */
 255       ToolGroup toolManger() const;
 256
 257       /**
 258        * @return the current background color of the rendering area.
 259        */
 260       QColor background() const;
 261
 262       /**
 263        * Set the current global color map for Primitives.
 264        */
 265       void setColorMap(Color *);
 266
 267       /**
 268        * @return the current global color map for Primitives.
 269        */
 270       Color *colorMap() const;
 271
 272       /**
 273        * @param undoStack the new undoStack.
 274        */
 275       void setUndoStack(QUndoStack *undoStack);
 276
 277       /**
 278        * @return the current GLWidget undoStack.
 279        */
 280       QUndoStack* undoStack() const;
 281
 282       /**
 283        * @return the current Molecule being viewed.
 284        */
 285       const Molecule* molecule() const;
 286
 287       /**
 288        * @return the current Molecule being viewed.
 289        */
 290       Molecule* molecule();
 291
 292       /**
 293        * update the Molecule geometry.
 294        */
 295       void updateGeometry();
 296
 297       /**
 298        * @return a pointer to the Camera of this widget.
 299        */
 300       Camera * camera() const;
 301
 302       /**
 303        * @return a list of engines.
 304        */
 305       QList<Engine *> engines() const;
 306
 307       /**
 308        * @return a list of the engine factories.
 309        */
 310       QList<EngineFactory *> engineFactories() const;
 311
 312       /**
 313        * Get the hits for a region starting at (x, y) of size (w * h).
 314        */
 315       QList<GLHit> hits(int x, int y, int w, int h);
 316
 317       /**
 318        * Take a point and figure out which is the closest Primitive under that point.
 319        * @param p the point on the widget that was clicked.
 320        * @return the closest Primitive that was clicked or 0 if nothing.
 321        */
 322       Primitive* computeClickedPrimitive(const QPoint& p);
 323
 324       /**
 325        * Take a point and figure out which is the closest Atom under that point.
 326        * @param p the point on the widget that was clicked.
 327        * @return the closest Atom that was clicked or 0 if nothing.
 328        */
 329       Atom* computeClickedAtom(const QPoint& p);
 330
 331       /**
 332        * Take a point and figure out which is the closest Bond under that point.
 333        * @param p the point on the widget that was clicked.
 334        * @return the closest Bond that was clicked or 0 if nothing.
 335        */
 336       Bond* computeClickedBond(const QPoint& p);
 337
 338       /**
 339        * @return the point at the center of the Molecule.
 340        */
 341       const Eigen::Vector3d & center() const;
 342       /**
 343        * @return the normalVector for the entire Molecule.
 344        */
 345       const Eigen::Vector3d & normalVector() const;
 346       /**
 347        * @return the radius of the Molecule.
 348        */
 349       const double & radius() const;
 350       /**
 351        * @return the Atom farthest away from the camera.
 352        */
 353       const Atom *farthestAtom() const;
 354
 355       /**
 356        * @param quality set the global quality of the widget.
 357        */
 358       void setQuality(int quality);
 359       /**
 360        * @return the global quality of the widget.
 361        */
 362       int quality() const;
 363
 364       /**
 365        * Set to render x, y, z axes as an overlay in the bottom left of the widget.
 366        */
 367       void setRenderAxes(bool renderAxes);
 368
 369       /**
 370        * @return true if the x, y, z axes are being rendered.
 371        */
 372       bool renderAxes();
 373
 374       /**
 375        * Set to render the "debug info" (i.e., FPS, number of atoms, etc.)
 376        */
 377       void setRenderDebug(bool renderDebug);
 378
 379       /**
 380        * @return true if the debug panel is being drawn
 381        */
 382       bool renderDebug();
 383
 384       /**
 385        * Set the ToolGroup of the GLWidget.
 386        */
 387       void setToolGroup(ToolGroup *toolGroup);
 388
 389       /**
 390        * @return the ToolGroup of the GLWidget.
 391        */
 392       ToolGroup * toolGroup() const;
 393
 394       /** Returns the Painter of this widget. For instance, to draw a sphere in this
 395         * widget, you could do:
 396         * @code
 397           painter()->drawSphere(center, radius)
 398         * @endcode
 399         * @sa class Painter
 400         */
 401       Painter *painter() const;
 402
 403       /**
 404        * @return list of primitives for this widget
 405        */
 406       PrimitiveList primitives() const;
 407
 408       /** @name Selection Methods
 409        *  These methods are used to manipulate user-selected primitives.
 410        *  Each view tracks a list of selected objects (e.g., atoms)
 411        *  which can be passed to engines, tools, or used for tasks like
 412        *  copying selected atoms, etc.
 413        * @{
 414        */
 415
 416       /**
 417        * @return the current selected primitives (all Primitive types)
 418        */
 419       PrimitiveList selectedPrimitives() const;
 420
 421       /**
 422        * Toggle the selection for the atoms in the supplied list.
 423        * That is, if the primitive is selected, deselect it and vice-versa.
 424        *
 425        * @param primitives the set of objects to update.
 426        */
 427       void toggleSelected(PrimitiveList primitiveList);
 428
 429       /**
 430        * Change the selection status for the atoms in the supplied list.
 431        * All objects in the list will have the same selection status.
 432        *
 433        * @param primitives the set of objects to update.
 434        * @param select whether to select or deselect the objects.
 435        */
 436       void setSelected(PrimitiveList primitives, bool select = true);
 437
 438       /**
 439        * Deselect all objects.
 440        */
 441       void clearSelected();
 442
 443       /**
 444        * @return true if the Primitive is selected.
 445        */
 446       bool isSelected(const Primitive *p) const;
 447       /* end selection method grouping */
 448       /** @} */
 449
 450       /**
 451        * Set the number of unit cells for a periodic molecule like a crystal
 452        * a, b, and c, are the three primitive unit cell axes.
 453        * Does nothing if the molecule does not have a unit cell defined.
 454        *
 455        * @param a number of unit cells to display along the a axis.
 456        * @param b number of unit cells to display along the b axis.
 457        * @param c number of unit cells to display along the c axis.
 458        */
 459       void setUnitCells(int a, int b, int c);
 460
 461       /**
 462        * @return the number of unit cells to display along the a axis.
 463        */
 464       int aCells();
 465
 466       /**
 467        * @return the number of unit cells to display along the b axis.
 468        */
 469       int bCells();
 470
 471       /**
 472        * @return the number of unit cells to display along the c axis.
 473        */
 474       int cCells();
 475
 476       /**
 477        * Static pointer to the current GLWidget.
 478        */
 479       static GLWidget *m_current;
 480
 481       /**
 482        * @return a pointer to the current GLWidget.
 483        */
 484       static GLWidget *current();
 485
 486       /**
 487        * Set this instance of the GLWidget as the current GLWidget instance.
 488        */
 489       static void setCurrent(GLWidget *current);
 490
 491       /**
 492        * Write the settings of the GLWidget in order to save them to disk.
 493        */
 494       virtual void writeSettings(QSettings &settings) const;
 495
 496       /**
 497        * Read the settings of the GLWidget and restore them.
 498        */
 499       virtual void readSettings(QSettings &settings);
 500
 501
 502     protected:
 503       /**
 504        * Virtual function called by QGLWidget on initialization of
 505        * the GL area.
 506        */
 507       virtual void initializeGL();
 508
 509       /**
 510        * Virtual function called by GLWidget before render() to set up the
 511        * display correctly.
 512        */
 513       virtual void paintGL();
 514
 515       /**
 516        * Virtual function called when the GL area needs repainting.
 517        */
 518       virtual void paintEvent(QPaintEvent *event);
 519
 520       /**
 521        * Called on resize of the GLWidget to perform resizing of the display.
 522        */
 523       virtual void resizeEvent(QResizeEvent *event);
 524
 525       /**
 526        * Virtual function called whn the GL area is resized
 527        */
 528       virtual void resizeGL(int, int);
 529
 530       /**
 531        * Focus Event
 532        */
 533       virtual bool event(QEvent *event);
 534
 535       /**
 536        * Virtual function reaction to mouse press in the GL rendering area.
 537        */
 538       virtual void mousePressEvent(QMouseEvent * event);
 539
 540       /**
 541        * Virtual function reaction to mouse release in the GL rendering area.
 542        */
 543       virtual void mouseReleaseEvent(QMouseEvent * event);
 544
 545       /**
 546        * Virtual function reaction to mouse being moved in the GL rendering area.
 547        */
 548       virtual void mouseMoveEvent(QMouseEvent * event);
 549
 550       /**
 551        * Virtual function reaction to mouse while in the GL rendering area.
 552        */
 553       virtual void wheelEvent(QWheelEvent * event);
 554
 555       /**
 556        * Render the scene. To be used in both modes GL_RENDER and GL_SELECT.
 557        * This function calls the render functions of the engines as well as the
 558        * paint events of the tools and is where everything drawn onto the widget
 559        * is called from.
 560        */
 561       virtual void render();
 562
 563       /**
 564        * Render a full crystal cell
 565        * Called by render() automatically
 566        *
 567        * @param displayList the display list of the primitive unit cell
 568        */
 569       virtual void renderCrystal(GLuint displayList);
 570
 571       /**
 572        * Render crystal unit cell axes
 573        * called by renderCrystal() automatically
 574        *
 575        */
 576       virtual void renderCrystalAxes();
 577
 578       /**
 579        * Render x, y, z axes as an overlay on the bottom left of the widget.
 580        */
 581       virtual void renderAxesOverlay();
 582
 583       /**
 584        * Render a debug overlay with extra debug information on the GLWidget.
 585        */
 586       virtual void renderDebugOverlay();
 587
 588       /**
 589        * Helper function to load all engine factories.
 590        */
 591       void loadEngineFactories();
 592
 593       /**
 594        * This will return a painting condition that must be met each time
 595        * before a GLThread can run.
 596        *
 597        * @return painting condition.
 598        */
 599 //       QWaitCondition *paintCondition() const;
 600
 601
 602     private:
 603       GLWidgetPrivate * const d;
 604
 605       /**
 606        * Helper function called by all constructors.
 607        */
 608       void constructor(const GLWidget *shareWidget =0);
 609
 610       /**
 611        * Compute the average frames per second over the last 200+ ms.
 612        */
 613       inline double computeFramesPerSecond();
 614
 615     public Q_SLOTS:
 616
 617       /**
 618        * Set the active Tool of the GLWidget.
 619        */
 620       void setTool(Tool *tool);
 621
 622       /**
 623        * Add the primitive to the widget.  This slot is called whenever
 624        * a new primitive is added to our molecule model.  It adds the
 625        * primitive to the list in the appropriate group.
 626        *
 627        * @param primitive pointer to a primitive to add to the view
 628        */
 629       void addPrimitive(Primitive *primitive);
 630
 631       /**
 632        * Update a primitive.  This slot is called whenever a primitive of our
 633        * molecule model has been changed and we need to check our view.
 634        *
 635        * @note In some cases we are passed the molecule itself meaning that more
 636        * than one thing has changed in the molecule.
 637        *
 638        * @param primitive object which changed.
 639        */
 640       void updatePrimitive(Primitive *primitive);
 641
 642       /** Remove a primitive.  This slot is called whenever a primitive of our
 643        * molecule model has been removed and we need to take it off our list.
 644        * Additionally we need to update other items in our view that are impacted
 645        * by this change.
 646        *
 647        * @param primitive object to remove.
 648        */
 649       void removePrimitive(Primitive *primitive);
 650
 651       /**
 652        * Set the background color of the rendering area (the default is black).
 653        *
 654        * @param background the new background color.
 655        */
 656       void setBackground(const QColor &background);
 657
 658       /**
 659        * Set the molecule model for this view.
 660        * @param molecule the molecule to view.
 661        */
 662       void setMolecule(Molecule *molecule);
 663
 664       /**
 665        * @param engine Engine to add to this widget.
 666        */
 667       void addEngine(Engine *engine);
 668
 669       /**
 670        * @param engine Engine to remove from this widget.
 671        */
 672       void removeEngine(Engine *engine);
 673
 674       /**
 675        * Reset to default engines (one of each factory).
 676        */
 677       void loadDefaultEngines();
 678
 679       /**
 680        * Signal that something changed and the display lists should be invalidated.
 681        */
 682       void invalidateDLs();
 683
 684     Q_SIGNALS:
 685       /**
 686        * Signal for the mouse press event which is passed to the engines and tools.
 687        */
 688       void mousePress(QMouseEvent * event);
 689
 690       /**
 691        * Signal for the mouse release event which is passed to the engines and tools.
 692        */
 693       void mouseRelease( QMouseEvent * event );
 694
 695       /**
 696        * Signal for the mouse move event which is passed to the engines and tools.
 697        */
 698       void mouseMove( QMouseEvent * event );
 699
 700       /**
 701        * Signal for the mouse wheel event which is passed to the engines and tools.
 702        */
 703       void wheel( QWheelEvent * event);
 704
 705       /**
 706        * Signal that the Molecule has changed.
 707        */
 708       void moleculeChanged(Molecule *previous, Molecule *next);
 709
 710       /**
 711        * Signal that an Engine has been added to the GLWidget.
 712        */
 713       void engineAdded(Engine *engine);
 714
 715       /**
 716        * Signal that an Engine has been removed from the GLWidget.
 717        */
 718       void engineRemoved(Engine *engine);
 719
 720   };
 721
 722 } // end namespace Avogadro
 723
 724 #endif