RGraphicsView.h

Go to the documentation of this file.

 
#ifndef RGRAPHICSVIEW_H
#define RGRAPHICSVIEW_H
 
#include "core_global.h"
 
#include <QCursor>
 
#include "RNonCopyable.h"
#include "RObject.h"
#include "RTextLabel.h"
#include "RVector.h"
 
class RAction;
class RBox;
class RColor;
class RDocument;
class RDocumentInterface;
class RGraphicsScene;
class RGrid;
class RLine;
class RMouseEvent;
class RPainterPath;
class RRefPoint;
class RShape;
class RTabletEvent;
class RTerminateEvent;
class RWheelEvent;
 
class QKeyEvent;
class QSwipeGesture;
class QPanGesture;
class QPinchGesture;
 
 
#ifndef RDEFAULT_MIN1
#define RDEFAULT_MIN1 -1
#endif
 
 
class QCADCORE_EXPORT RGraphicsView : RNonCopyable {
public:
    enum ColorMode {
        FullColor,
        GrayScale,
        BlackWhite
    };
 
public:
    RGraphicsView(RGraphicsScene* scene = NULL);
    virtual ~RGraphicsView();
 
    void setViewportNumber(int n);
    int getViewportNumber() const {
        return viewportNumber;
    }
 
    void clear() {}
    void clearCaches();
 
    void setDisplayOnlyCurrentUcs(bool on);
 
    virtual void setScene(RGraphicsScene* scene, bool regen=true);
    RGraphicsScene* getScene() const;
    RDocument* getDocument() const;
    RDocumentInterface* getDocumentInterface() const;
 
    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 void giveFocus() = 0;
    virtual bool hasFocus() = 0;
    virtual void removeFocus() = 0;
 
    virtual void viewportChangeEvent();
 
    void saveViewport();
    void restoreViewport();
    void zoomIn();
    void zoomOut();
    void zoomIn(const RVector& center, double factor=1.2);
    void zoomOut(const RVector& center, double factor=1.2);
    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 ignoreEmpty=false, bool ignoreLineweight=false);
    bool zoomToSelection(int margin = RDEFAULT_MIN1);
    bool zoomToEntities(const QSet<RObject::Id>& ids, int margin = RDEFAULT_MIN1);
 
    virtual void centerToPoint(const RVector& point);
    virtual void centerToBox(const RBox& box);
    virtual void pan(const RVector& delta, bool regen=true);
    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 regenerate(QSet<RObject::Id>& affectedEntities) {
        Q_UNUSED(affectedEntities)
 
        regenerate(true);
    }
 
    virtual void repaintView() = 0;
 
    virtual int getWidth() const = 0;
 
    virtual int getHeight() const = 0;
 
    virtual int isActive() const {
        return true;
    }
 
    virtual bool getSignalsBlocked() const {
        return false;
    }
    virtual void setSignalsBlocked(bool on) {
        Q_UNUSED(on)
        return;
    }
 
    void setNavigationAction(RAction* action);
 
    RGrid* getGrid() {
        return grid;
    }
 
    void setGrid(RGrid* g);
 
    void setGridVisible(bool on);
    bool isGridVisible() const;
 
    virtual void paintGridPoints(const QVector<double>& ucsPositionX, const QVector<double>& ucsPositionY);
    virtual void paintGridPoint(const RVector& /*ucsPosition*/) {}
    virtual void paintGridLine(const RLine& /*ucsPosition*/) {}
    virtual void paintCursorLine(const RLine& /*ucsPosition*/) {}
 
    virtual QCursor getCursor() { return QCursor(Qt::ArrowCursor); }
    virtual void setCursor(Qt::CursorShape /*cursorShape*/) {}
    virtual void setCursor(const QCursor& /*cursor*/) {}
 
    RRefPoint getClosestReferencePoint(const RVector& screenPosition, int range);
    RRefPoint getClosestReferencePoint(RObject::Id entityId, const RVector& screenPosition);
    RObject::Id getClosestEntity(const RVector& screenPosition, int range, int strictRange, bool includeLockedLayers=true, bool selectedOnly = false);
    //RObject::Id getClosestEntityInUcs(const RVector& screenPosition, int range);
 
    virtual void setBackgroundColor(const QColor& col);
    QColor getBackgroundColor();
 
    int getMargin();
    void setMargin(int m);
 
    void setExporting(bool on);
    bool isExporting() const;
 
    bool isPrintingOrExporting() const;
 
    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();
 
    void setHairlineMode(bool on);
    bool getHairlineMode();
 
    void setHairlineMinimumMode(bool on);
    bool getHairlineMinimumMode();
 
    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;
    }
 
    void setTextHeightThresholdOverride(int v) {
        textHeightThresholdOverride = v;
    }
 
    int getTextHeightThresholdOverride() const {
        return textHeightThresholdOverride;
    }
 
    void setForceTextHeightThreshold(bool on) {
        forceTextHeightThreshold = on;
    }
 
    bool getForceTextHeightThreshold() const {
        return forceTextHeightThreshold;
    }
 
    void updateTextHeightThreshold();
 
    bool isPathVisible(const RPainterPath& path) const;
 
    void setAntialiasing(bool val);
    bool getAntialiasing() const;
 
    virtual double getDevicePixelRatio() const {
        return 1.0;
    }
 
    virtual bool isShared() const {
        return false;
    }
 
    virtual bool registerForFocus() const {
        return false;
    }
 
    void setWidget(QWidget* w) {
        widget = w;
    }
 
    QWidget* getWidget() const {
        return widget;
    }
 
protected:
    bool exporting;
    bool printing;
    bool printPreview;
    RVector printPointSize;
 
    ColorMode colorMode;
    bool hairlineMode;
    bool hairlineMinimumMode;
 
    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 lastKnownScreenPosition;
 
    QList<RTextLabel> textLabels;
 
 
    int textHeightThresholdOverride;
    int textHeightThreshold;
    bool forceTextHeightThreshold;
 
    int viewportNumber;
 
    bool antialiasing;
 
    // grid display flag, cached:
    mutable int gridVisible;
 
    //RVector mousePressScreenPosition;
    //RVector mousePressModelPosition;
 
    // widget that displays this view if any:
    QWidget* widget;
};
 
Q_DECLARE_METATYPE(RGraphicsView::ColorMode)
Q_DECLARE_METATYPE(RGraphicsView*)
Q_DECLARE_METATYPE(QList<RGraphicsView*>)
 
#endif