scene.h

Go to the documentation of this file.

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

#ifndef BALL_VIEW_WIDGETS_SCENE_H
#define BALL_VIEW_WIDGETS_SCENE_H

#ifndef BALL_VIEW_KERNEL_MODULARWIDGET_H
# include <BALL/VIEW/KERNEL/modularWidget.h>
#endif

#ifndef BALL_VIEW_RENDERING_RENDERERSGLRENDERER_H
# include <BALL/VIEW/RENDERING/RENDERERS/glRenderer.h>
#endif

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

#ifndef BALL_VIEW_RENDERING_RENDERWINDOW_H
# include <BALL/VIEW/RENDERING/renderWindow.h>
#endif

#ifndef BALL_VIEW_RENDERING_GLRENDERWINDOW_H
# include <BALL/VIEW/RENDERING/glRenderWindow.h>
#endif

#ifndef BALL_VIEW_RENDERING_RENDERSETUP_H
# include <BALL/VIEW/RENDERING/renderSetup.h>
#endif

#ifndef BALL_VIEW_DIALOGS_EDITSETTINGS_H
# include <BALL/VIEW/DIALOGS/editSettings.h>
#endif

#ifndef BALL_VIEW_KERNEL_EDITOPERATION_H
# include <BALL/VIEW/KERNEL/editOperation.h>
#endif

#ifndef BALL_VIEW_KERNEL_MODES_INTERACTIONMODEMANAGER_H
# include <BALL/VIEW/KERNEL/MODES/interactionModeManager.h>
#endif

#include <QtCore/QThread>
#include <QtCore/QTimer>
#include <QtGui/QDragEnterEvent>
#include <QtGui/QDropEvent>
#include <QtGui/QToolBar>
#include <QtGui/QFont>
#include <QtGui/QPicture>

#include <boost/shared_ptr.hpp>

#ifdef BALL_HAS_RTFACT

#ifndef BALL_VIEW_RENDERING_RAYTRACINGRENDERER_H
# include <BALL/VIEW/RENDERING/RENDERERS/raytracingRenderer.h>
#endif

#endif // BALL_HAS_RTFACT

class QMouseEvent;
class QRubberBand;
class QMenu;
class QImage;
class QAction;
class QWheelEvent;
class QKeyEvent;

namespace BALL
{
  class Bond;
  class PDBAtom;
  class AtomContainer;

  namespace VIEW
  {
    class ColorMap;
    class InteractionMode;
    class Preferences;
    class LightSettings;
    class StageSettings;
    class MaterialSettings;
    class AnimationThread;
    class ClippingPlane;
    class CompositeMessage;
    class ControlSelectionMessage;
    class RepresentationMessage;
    class DatasetMessage;
    class SceneMessage;

    class TransformationEvent6D;
    class MotionTrackingEvent;
    class ButtonEvent;
    class RenderToBufferFinishedEvent;

    class BALL_VIEW_EXPORT Scene
      : public QWidget,
        public ModularWidget
    {
      friend class AnimationThread;
      friend class RenderSetup;
      friend class HTMLBasedInterface;

#ifdef BALL_HAS_RTFACT
      typedef boost::shared_ptr<RaytracingRenderer> RaytracingRendererPtr;
      typedef boost::shared_ptr<RenderWindow> RaytracingWindowPtr;
#endif

      Q_OBJECT

      public:
        BALL_EMBEDDABLE(Scene, ModularWidget)

        

        enum WindowType
        {
          CONTROL_WINDOW = 0,

          LEFT_EYE_WINDOW,

          RIGHT_EYE_WINDOW
        };


        Scene(QWidget* parent_widget = 0, const char* name = NULL, Qt::WFlags w_flags = 0);

        BALL_DEPRECATED Scene(const Scene& scene, QWidget* parent_widget = NULL, const char* name = NULL, Qt::WFlags wflags = 0);

        virtual ~Scene();

        virtual void clear();



        BALL_DEPRECATED void set(const Scene& scene);

        BALL_DEPRECATED const Scene& operator = (const Scene& scene);



        virtual void onNotify(Message *message);

        virtual bool exportScene(Renderer &er) const;

        String getBondOrderString_(Index order);



        virtual void initializeWidget(MainControl& main_control);

        virtual void fetchPreferences(INIFile& inifile);

        virtual void writePreferences(INIFile& inifile);

        virtual void checkMenu(MainControl& main_control);



        virtual bool isValid() const;

        virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;

        void setInfo(const QString& info_string);
        bool isRecording() const;
        void captureCamera();
        Atom* getCurrentAtom() { return current_atom_; }
        void setCurrentAtom(Atom* atom) { current_atom_ = atom; }
        void notify(Message* msg) { notify_(msg); }
        Vector2 map3DToViewport(const Vector3& coords);
        Vector3 mapViewportTo3D(const Vector2& coords);
        Vector3 mapViewportTo3D(int x, int y);
        void setRubberBandGeometry(const QRect& rect);
        void setRubberBandVisible(bool show);
        void pickObjects(const QPoint& pos, list<GeometricObject*>& objects);
        void pickObjects(const QPoint& pos1, const QPoint& pos2, list<GeometricObject*>& objects);
        void merge(Composite* a1, Composite* a2);
        std::list<AtomContainer*> getContainers();
        void enterPickingMode();
        void exitPickingMode();

        void drawLine(const QPointF& a, const QPointF& b, QPainter* painter = 0);
        void drawLine(const Vector2& a, const Vector2& b, QPainter* painter = 0);

        Bond* getCurrentBond() { return current_bond_; }
        void setCurrentBond(Bond* b) { current_bond_ = b; }

        void changeBondOrder();
        void changeBondOrder(Index delta);
        void activatedOrderItem_(QAction* action);
        void createMolecule_();
        void setFormalCharge_();

        void deselect(bool update=true);
        void getClickedItems(const QPoint& p);

        Stage* getStage()
        { return stage_;}

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

        StageSettings* getStageSettings()
        { return stage_settings_; }

        const StageSettings* getStageSettings() const
        { return stage_settings_; }

        MaterialSettings* getMaterialSettings()
        { return material_settings_; }

        const MaterialSettings* getMaterialSettings() const
        { return material_settings_; }

        void setCamera(const Camera& camera);

        std::list<Camera>& getAnimationPoints()
        { return animation_points_;}

        static void setAnimationSmoothness(float value)
        { animation_smoothness_ = value;}

        static float getAnimationSmoothness()
        { return animation_smoothness_;}

        float getDownsamplingFactor() const
        { return downsampling_factor_;}

        void setDownsamplingFactor(float ds_factor);

        void setDefaultLighting(bool update_GL = true);

        static void setMouseSensitivity(float sensitivity)
        { mouse_sensitivity_ = sensitivity; }

        static float getMouseSensitivity()
        { return mouse_sensitivity_;}

        static void setMouseWheelSensitivity(float sensitivity)
        { mouse_wheel_sensitivity_ = sensitivity; }

        static float getMouseWheelSensitivity()
        { return mouse_wheel_sensitivity_;}

        static void setShowLightSources(bool state)
        { show_light_sources_ = state;}

        static bool showLightSourcesEnabled()
        { return show_light_sources_;}

        GLRenderer& getGLRenderer()
        { return *gl_renderer_;}

#ifdef BALL_HAS_RTFACT
        RaytracingRenderer& getRaytracingRenderer()
        { return *rt_renderer_;}
#endif

        void setGLRenderer(GLRenderer& renderer);

        static bool stereoBufferSupportTest();

        bool inMoveMode() const;

        bool exportPNG(const String& filename);

        virtual void setWidgetVisible(bool state);

        void setOffScreenRendering(bool enabled, Size factor);

        virtual void paintEvent(QPaintEvent* e);

        virtual bool eventFilter(QObject* object, QEvent* event);

        virtual void projectionModeChanged();

        static void setScreenShotNumber(Position pos) { screenshot_nr_ = pos;}

        static void setPOVNumber(Position pos) { pov_nr_ = pos;}

        static void setVRMLNumber(Position pos) {vrml_nr_ = pos;}

        void rotate(float degree_right, float degree_up);

        void rotateClockwise(float degree);

        void move(Vector3 v);

        // TODO: move this and the next function somewhere else...
        void moveComposites(const std::list<Composite*>& composites, Vector3 v);

        void rotateComposites(const std::list<Composite*>& composites, float degree_right, float degree_up, float degree_clockwise = 0);

        bool isAnimationRunning() const;

        void setTurnPoint(const Vector3& v) { system_origin_ = v;}

        const Vector3& getTurnPoint() const { return system_origin_;}

        void setFullScreen(bool state);

        void setFPSEnabled(bool state) { show_fps_ = state; }

        void showText(const String& text, Size font_size = 20);

        bool isUpdateRunning() const { return update_running_;}

        void resetTracking() {tracking_initialized_ = false;}

        // TODO: this pretty hacky!
        void updateAllMaterials();

        void updateMaterialForRepresentation(Representation* rep, const Stage::Material& new_material);

        void lightsUpdated(bool redraw = false);

        void setupEnvironmentMap(const QImage& image);

        Position prepareGridTextures(const RegularData3D& grid, const ColorMap& map);

        void updateGL();
        void initializePreferencesTab(Preferences &preferences);

        void finalizePreferencesTab(Preferences &preferences);

        virtual void applyPreferences();

        void showContextMenu(QPoint pos);

        // Allow to use the base class setCursor, too
        using QWidget::setCursor;

        void setCursor(String c);

        void setElementCursor(int number);

        virtual void addToolBarEntries(QToolBar* tb);

        virtual void keyPressEvent(QKeyEvent* e);

      public slots:
        void createCoordinateSystem();

        void createCoordinateSystemAtOrigin();

        String exportPNG();

        void exportPOVRay();

        void exportNextPOVRay();

        void exportXML3D();

        void dumpXML3D(std::ostream& xml3ddump);

        void printScene();

        void showExportPNGDialog();

        void showExportVRMLDialog();

        void setPreview(bool state) { use_preview_ = state; }

        bool usePreview() const { return use_preview_; }

        bool useVertexBuffers() const { return want_to_use_vertex_buffer_; }

        virtual void switchShowWidget();

        void switchRenderer(RenderSetup::RendererType new_type);

        void addGlWindow();

#ifdef BALL_HAS_RTFACT
        void addRTfactWindow();
#endif

        void exitStereo();

        void enterStereo();

        void enterActiveStereo();

        void enterDualStereo();

        void enterDualStereoDifferentDisplays();

        void clearRecordedAnimation();

        void startAnimation();

        void stopAnimation();

        void switchToLastMode();

        void switchShowGrid();

        void showInfos();

        void setupViewVolume();

        void storeViewPoint();

        void restoreViewPoint();

        void startContinuousLoop();

        void stopContinuousLoop();

        void toggleContinuousLoop();

        void applyStereoDefaults();

#ifdef BALL_HAS_RTFACT
        RaytracingWindowPtr getWindow(WindowType aWindowType);
#endif

        void createNewMolecule();
        void saturateWithHydrogens();
        void optimizeStructure();
        void computeBondOrders();

        // slots for communication with PTEDialog
        void setEditElementType(int element_number);
        int getEditElementType();

      protected slots:


        virtual void showViewPoint_();

        virtual void setViewPoint_();

        virtual void resetCamera_();

        virtual void resetRepresentationsForRenderer_(RenderSetup& rs);

        virtual void dropEvent(QDropEvent* e);

        virtual void dragEnterEvent(QDragEnterEvent* e);

        // dummy slot for menu entries without immediate action (saves many lines code this way)
        void dummySlot(){}


      signals:

        // signal for communication with EditOperationDialog
        void newEditOperation(EditOperation &eo);

      protected:

        void handleRepresentationMessage_(RepresentationMessage* rm);

        void handleDatasetMessage_(DatasetMessage* dm);

        void handleSceneMessage_(SceneMessage* sm);

        void handleCompositeMessage_(CompositeMessage* cm);

        void handleControlSelectionMessage_(ControlSelectionMessage* csm);

        virtual void handleRenderToBufferFinishedEvent_(RenderToBufferFinishedEvent* evt);

        void renderText_(QPointF const& point, QString const& text, QPaintDevice* current_dev);

        void insert_(int x_, int y_, PDBAtom &atom_);

        TVector2<float> getScreenPosition_(Vector3 vec);

        void initializeMembers_();

        void renderGrid_();

        QAction *new_molecule_action_, *optimize_action_;
        QAction *add_hydrogens_action_;
        QAction *bondorders_action_;

        Atom* current_atom_;
        Bond* current_bond_;

        // pick atoms/bonds only in highlighted AtomContainer?
        static bool only_highlighted_;
        // element for new atoms
        int atomic_number_;

        //undo stack
        vector<EditOperation> undo_;
        EditSettings* edit_settings_;
        QList<QAction*> toolbar_actions_edit_controls_;


        virtual void init();

        virtual void paintGL();

        virtual void resizeEvent(QResizeEvent* event);

        virtual void customEvent(QEvent* evt);

        virtual void transformationEvent6D(TransformationEvent6D* evt);

        virtual void motionTrackingEvent(MotionTrackingEvent* evt);

        virtual void buttonPressEvent(ButtonEvent* evt);

        virtual void buttonReleaseEvent(ButtonEvent* evt);

        virtual void mouseMoveEvent(QMouseEvent* qmouse_event);

        virtual void mousePressEvent(QMouseEvent* qmouse_event);

        virtual void mouseReleaseEvent(QMouseEvent* qmouse_event);

        virtual void wheelEvent(QWheelEvent* qmouse_event);

        virtual void mouseDoubleClickEvent(QMouseEvent* e);

        //_
        void animate_();

        void rotateSystemClockwise_();
        void zoomSystem_();

        void selectionPressed_();
        void selectionPressedMoved_();

        void selectObjects_();
        void pickParent_(QPoint p);

        void writeLights_(INIFile& inifile) const;

        void readLights_(const INIFile& inifile);

        void createCoordinateSystem_(bool at_origin);

        void registerRenderers_();

        String createFPSInfo_(Renderer* renderer);

        // Menu entry IDs
        QAction *no_stereo_action_, *enter_stereo_action_, *active_stereo_action_, *dual_stereo_action_, *dual_stereo_different_display_action_;
        QAction *record_animation_action_, *start_animation_action_, *clear_animation_action_, *cancel_animation_action_;
        QAction *animation_export_POV_action_, *animation_export_VRML_action_,  *animation_export_PNG_action_, *animation_repeat_action_;

#ifdef BALL_HAS_RTFACT
                QAction *toggle_continuous_loop_action_;
#endif
        QAction *switch_grid_;
        QMenu* create_coordinate_system_;

        Vector3 system_origin_;
        Vector3 old_trackorigin_;
        bool tracking_initialized_;
        Quaternion old_trackrotation_;

        bool update_running_;

        QRubberBand* rb_;

        Stage* stage_;
        Camera stereo_camera_;
        Camera stored_camera_;

        std::vector<boost::shared_ptr<RenderSetup> > renderers_;
        GLRenderer* gl_renderer_;

#ifdef BALL_HAS_RTFACT
        RaytracingRenderer* rt_renderer_;
        RaytracingWindowPtr rt_window_;
#endif

        static float mouse_sensitivity_;
        static float mouse_wheel_sensitivity_;
        static bool show_light_sources_;
        static float animation_smoothness_;
        static float downsampling_factor_;

        LightSettings* light_settings_;
        StageSettings* stage_settings_;
        MaterialSettings* material_settings_;

        // nr of last png file export
        static Position screenshot_nr_;
        // nr of last pov file export
        static Position pov_nr_;
        //nr of last vrml or stl export
        static Position vrml_nr_;

        std::list<Camera> animation_points_;
        AnimationThread* animation_thread_;
        bool stop_animation_;
#ifdef BALL_HAS_RTFACT
        bool continuous_loop_;
#endif
        bool want_to_use_vertex_buffer_;
        bool use_preview_;

        PreciseTime time_;
        QPoint info_point_;
        QByteArray last_state_;
        list<float> fps_;
        bool show_fps_;
        static bool offscreen_rendering_;
        Size offscreen_factor_;
        Size   font_size_;
        QToolBar* toolbar_view_controls_;
        QToolBar* toolbar_edit_controls_;
        QList<QAction*> toolbar_actions_view_controls_;

        QString info_string_;

        GLRenderWindow* main_display_;
        Position main_renderer_;

        Index stereo_left_eye_;
        Index stereo_right_eye_;

        QFont default_font_;

        QPicture overlay_;
        bool has_overlay_;
        InteractionModeManager mode_manager_;
    };


    class BALL_VIEW_EXPORT AnimationThread
      : public QThread
    {
      public:

        AnimationThread(){};

        virtual void run() {scene_->animate_();}

        void mySleep(Size msec);

        void setScene(Scene* scene) { scene_ = scene;}

        Scene* getScene() { return scene_;}

      protected:

        Scene* scene_;
    };

  } // namespace VIEW
}  // namespace BALL

#endif // BALL_VIEW_WIDGETS_SCENE_H