SXWidget.h

#ifndef _SX_SXWIDGET_H_
#define _SX_SXWIDGET_H_

#include <export/Export.h>
#include <sx/SX.h>
#include <sx/SXMath.h>
#include <GL/glew.h>
#include <GL/wglew.h>
#include <QWidget>
#include <QTimer>
#include <QtOpenGL/QGLWidget>
#include <boost/unordered_map.hpp>
#include <boost/timer.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <map>
#include <vector>
using boost::posix_time::ptime;
using boost::posix_time::second_clock;
using boost::posix_time::to_simple_string;
using namespace std;
using namespace boost;

namespace sx {

    class SXWidget;

    class SXInternalWidget: public QGLWidget {
        
        Q_OBJECT

    private:

        SXWidget *sxWidget;

        static map<int,int> keys_qt2sx;

        static map<int,int> initKeys_qt2sx();

        void keyPressEvent(QKeyEvent * e);

        void keyReleaseEvent(QKeyEvent * e);

        void mousePressEvent(QMouseEvent * e);

        void mouseReleaseEvent(QMouseEvent * e);

        void mouseMoveEvent(QMouseEvent * e);

        void wheelEvent(QWheelEvent * e);

        SXInternalWidget(const SXInternalWidget &);

        SXInternalWidget &operator = (const SXInternalWidget &);

    public:

        SXInternalWidget(SXWidget *sxWidget);

        ~SXInternalWidget();

        void initializeGL();

        void resizeGL(int width, int height);

        void paintGL();

    };

    class SXWidget: public QWidget, public SXRenderArea {

        Q_OBJECT

        friend class SXInternalWidget;

    private:

        bool constructed;

        bool processingListeners;

        bool callStopAfterRender;

        vector<SXRenderListener *> listeners;

        vector<SXRenderListener *> initListeners;

        QTimer timer;

        boost::timer timeMeasurement;

        double lastTimeRendered;

        double currentTimeRendering;

        int mouseX;

        int mouseY;

        double mouseDeltaX;

        double mouseDeltaY;

        double lastSetMouseTime;

        vector<Vector> setMouseDeltas;

        unordered_map<int,int> keys;

        unordered_map<int,int> mouseKeys;

        void updateTime();

        void addKey(int key);

        void removeKey(int key);

        void addMouseKey(MouseButton key);

        void removeMouseKey(MouseButton key);

        SXInternalWidget *internalWidget;

        SXWidget(const SXWidget &);

        SXWidget &operator = (const SXWidget &);

    signals:

        EXW void finishedRendering();

        EXW void wheelRotates(float degrees);

    public:

        EXW SXWidget();

        EXW ~SXWidget();

        EXW void renderPeriodically(float time);

        EXW void stopRenderPeriodically();

        EXW void addRenderListener(SXRenderListener &l);

        EXW void deleteRenderListener(SXRenderListener &l);

        EXW void deleteRenderListeners();

        EXW double getTime() const;

        EXW double getDeltaTime() const;

        EXW int getMouseX() const;

        EXW int getMouseY() const;

        EXW double getMouseDeltaX() const;
        
        EXW double getMouseDeltaY() const;

        EXW bool hasKey(int key) const;

        EXW bool hasMouseKey(MouseButton key) const;

        EXW int getWidth() const;

        EXW int getHeight() const;

        EXW void stopRendering();

        EXW void setMousePointer(int x, int y);

        EXW void setShowCursor(bool showCursor);

    };

}

#endif