RGraphicsView.h

Go to the documentation of this file.

#ifndef RGRAPHICSVIEW_H
#define RGRAPHICSVIEW_H

#include <QKeyEvent>
#include <QCursor>
#include <QSwipeGesture>
#include <QPanGesture>
#include <QPinchGesture>

#include "RExporter.h"
#include "RGrid.h"
#include "RNonCopyable.h"
#include "RTextLabel.h"
#include "RTerminateEvent.h"

class RAction;
class RDocumentInterface;
class RGraphicsScene;
class RLine;
class RMouseEvent;
class RTabletEvent;
class RWheelEvent;

#ifndef RDEFAULT_MIN1
#define RDEFAULT_MIN1 -1
#endif


class RGraphicsView : RNonCopyable {
public:
    enum ColorMode {
        FullColor,
        GrayScale,
        BlackWhite
    };

public:
    RGraphicsView(RGraphicsScene* scene = NULL);
    virtual ~RGraphicsView();

    void setDisplayOnlyCurrentUcs(bool on);

    virtual void setScene(RGraphicsScene* scene, bool regen=true);
    RGraphicsScene* getScene();
    RDocument* getDocument() const;
    RDocumentInterface* getDocumentInterface();

    virtual RVector mapFromView(const RVector& v, double z=0.0) const = 0;

    virtual RVector mapToView(const RVector& v) const = 0;
    virtual RBox mapToView(const RBox& box) const;

    virtual double mapDistanceFromView(double d) const = 0;

    virtual double mapDistanceToView(double d) const = 0;

    virtual QList<RVector> mapCornersFromView() const;

    virtual RBox getBox() const;
    virtual RVector getMinimum() const;
    virtual RVector getMaximum() const;

    virtual void handleTerminateEvent(RTerminateEvent& event);

    virtual void handleKeyPressEvent(QKeyEvent& event);
    virtual void handleKeyReleaseEvent(QKeyEvent& event);
    virtual void simulateMouseMoveEvent();
    virtual void handleMouseMoveEvent(RMouseEvent& event);
    virtual void handleMousePressEvent(RMouseEvent& event);
    virtual void handleMouseReleaseEvent(RMouseEvent& event);
    virtual void handleMouseDoubleClickEvent(RMouseEvent& event);
    virtual void handleWheelEvent(RWheelEvent& event);
    virtual void handleTabletEvent(RTabletEvent& event);
    virtual void handleSwipeGestureEvent(QSwipeGesture& gesture);
    virtual void handlePanGestureEvent(QPanGesture& gesture);
    virtual void handlePinchGestureEvent(QPinchGesture& gesture);
    virtual bool hasFocus() = 0;
    virtual void removeFocus() = 0;

    virtual void viewportChangeEvent();

    void saveViewport();
    void restoreViewport();
    void zoomIn();
    void zoomOut();
    void zoomIn(const RVector& center);
    void zoomOut(const RVector& center);
    virtual void zoom(const RVector& center, double factor);
    virtual void zoomTo(const RBox& window, int margin = 0);
    void zoomPrevious();
    void autoZoom(int margin = RDEFAULT_MIN1);
    bool zoomToSelection();

    virtual void pan(const RVector& delta);
    void startPan();

    double getFactor(bool includeStepFactor=true) const;
    void setFactor(double f, bool regen=true);

    RVector getOffset(bool includeStepOffset=true) const;
    void setOffset(const RVector& offset, bool regen=true);

    virtual void regenerate(bool force=false) = 0;

    virtual void repaintView() = 0;

    virtual int getWidth() const = 0;

    virtual int getHeight() const = 0;

    void setNavigationAction(RAction* action);

    RGrid* getGrid() {
        return grid;
    }

    void setGrid(RGrid* g) {
        if (grid!=NULL) {
            delete grid;
            grid = NULL;
        }
        grid = g;
    }

    void setGridVisible(bool on) {
        gridVisible = on;
    }

    bool isGridVisible() const {
        return gridVisible;
    }

    void setDraftMode(bool on);
    bool getDraftMode() const {
        return draftMode;
    }

    virtual void paintGridPoint(const RVector& /*ucsPosition*/) {}
    virtual void paintMetaGridLine(const RLine& /*ucsPosition*/) {}

    virtual QCursor getCursor() { return QCursor(Qt::ArrowCursor); }
    virtual void setCursor(Qt::CursorShape /*cursorShape*/) {}
    virtual void setCursor(const QCursor& /*cursor*/) {}

    RVector getClosestReferencePoint(const RVector& screenPosition, int range);
    RVector getClosestReferencePoint(REntity::Id entityId, const RVector& screenPosition);
    REntity::Id getClosestEntity(const RVector& screenPosition, int range, bool includeLockedLayers=true);
    //REntity::Id getClosestEntityInUcs(const RVector& screenPosition, int range);

    virtual void setBackgroundColor(const QColor& col);
    QColor getBackgroundColor();

    int getMargin();
    void setMargin(int m);

    void setPrinting(bool on);
    bool isPrinting() const;
    void setPrintPreview(bool on);
    bool isPrintPreview() const;
    void setPrintPointSize(const RVector& s);

    void setColorMode(RGraphicsView::ColorMode cm);
    RGraphicsView::ColorMode getColorMode();

    QList<RTextLabel> getTextLabels();
    void clearTextLabels();
    void addTextLabel(const RTextLabel &textLabel);

    RVector getLastKnownMousePosition() const {
        return lastKnownModelPosition;
    }

    double getCurrentStepScaleFactor() const {
        return currentStepScaleFactor;
    }

    void setCurrentStepScaleFactor(double f) {
        currentStepScaleFactor = f;
    }

    RVector getCurrentStepOffset() const {
        return currentStepOffset;
    }

    void setCurrentStepOffset(const RVector& s) {
        currentStepOffset = s;
    }

protected:
    virtual void centerTo(const RBox& box);

protected:
    bool printing;
    bool printPreview;
    RVector printPointSize;

    ColorMode colorMode;

    RGraphicsScene* scene;

    RGrid* grid;

    RAction* navigationAction;

    RVector offset;

    double factor;

    RVector previousOffset;
    double previousFactor;

    bool displayOnlyCurrentUcs;

    bool autoScalePatterns;

    QColor backgroundColor;
    int margin;

    double currentStepScaleFactor;

    RVector currentStepOffset;
    RVector lastKnownModelPosition;
    RVector lastKnownViewPosition;

    QList<RTextLabel> textLabels;

    bool gridVisible;
    bool draftMode;

    // for simulation: 0.0...1.0:
    //int maxEntities;
    //REntity::Id nextEntityId;
};

Q_DECLARE_METATYPE(RGraphicsView::ColorMode)
Q_DECLARE_METATYPE(RGraphicsView*)
Q_DECLARE_METATYPE(QList<RGraphicsView*>)

#endif