RDocumentInterface.h

Go to the documentation of this file.

#ifndef RDOCUMENTINTERFACE_H
#define RDOCUMENTINTERFACE_H

#include <QKeyEvent>
#include <QList>
#include <QMap>
#include <QMutex>
#include <QSharedPointer>
#include <QStack>
#include <QQueue>
#include <QSwipeGesture>
#include <QPanGesture>
#include <QPinchGesture>

#include "RAction.h"
#include "RCoordinateEvent.h"
#include "RCommandEvent.h"
#include "RCoordinateListener.h"
#include "RDocument.h"
#include "RExporter.h"
#include "RStorage.h"
#include "RTerminateEvent.h"
#include "RTextLabel.h"
#include "RUcs.h"

#define RDEFAULT_QLIST_QREAL QList<qreal>()
#ifndef RDEFAULT_MIN1
#define RDEFAULT_MIN1 -1
#endif

class RGraphicsScene;
class RGraphicsView;
class RMouseEvent;
class ROperation;
class RPropertyEvent;
class RSnap;
class RSnapRestriction;
class RScriptHandler;
class RTransaction;
class RWheelEvent;



class RDocumentInterface {
public:
    enum IoErrorCode {
        IoErrorNoError,
        IoErrorNoImporterFound,
        IoErrorGeneralImportError,
        IoErrorGeneralImportUrlError
    };

public:
    RDocumentInterface(RDocument& document);
    ~RDocumentInterface();

    RDocument& getDocument();
    RStorage& getStorage();
    QList<RGraphicsScene*> getGraphicsScenes();
    RGraphicsView* getGraphicsViewWithFocus();

    void addCoordinateListener(RCoordinateListener* l);
    void notifyCoordinateListeners();

    void clear();

    RScriptHandler* getScriptHandler(const QString& extension);
    bool isScriptRunning();

    void setDefaultAction(RAction* action);
    void setCurrentAction(RAction* action);
    void queueAction(RAction* action);
    void killAllActions();

    RAction* getCurrentAction();
    bool hasCurrentAction();

    void suspend();
    void resume();

    void setClickMode(RAction::ClickMode m);
    RAction::ClickMode getClickMode();

    void terminateEvent(RTerminateEvent& event);

    void keyPressEvent(QKeyEvent& event);
    void keyReleaseEvent(QKeyEvent& event);
    void mouseMoveEvent(RMouseEvent& event);
    void mousePressEvent(RMouseEvent& event);
    void mouseReleaseEvent(RMouseEvent& event);
    void mouseDoubleClickEvent(RMouseEvent& event);
    void coordinateEvent(RCoordinateEvent& event);
    void coordinateEventPreview(RCoordinateEvent& event);
    void commandEvent(RCommandEvent& event);
    void commandEventPreview(RCommandEvent& event);
    void wheelEvent(RWheelEvent& event);
    void tabletEvent(RTabletEvent& event);
    void swipeGestureEvent(QSwipeGesture& gesture);
    void panGestureEvent(QPanGesture& gesture);
    void pinchGestureEvent(QPinchGesture& gesture);

    void propertyChangeEvent(RPropertyEvent& event);
    void ucsSetEvent(const QString& ucsName);

    void enableUpdates();
    void disableUpdates();

    void updateAllEntities();

    void regenerateScenes(bool undone = false);
    void regenerateScenes(QSet<REntity::Id>& entityIds, bool updateViews);
    void regenerateScenes(REntity::Id entityId, bool updateViews);

    void regenerateViews(bool force=false);
    void repaintViews();

    void registerScene(RGraphicsScene& scene);
    void unregisterScene(RGraphicsScene& scene);

    void setCursor(const QCursor& cursor, bool global = true);

    RDocumentInterface::IoErrorCode importUrl(const QUrl& url, bool notify = true);
    RDocumentInterface::IoErrorCode importFile(
        const QString& fileName, const QString& nameFilter = "", bool notify = true);

    QString getCorrectedFileName(const QString& fileName, const QString& fileVersion);
    bool exportFile(const QString& fileName, const QString& fileVersion = "", bool resetModified = true);

    void undo();
    void redo();

    void setSnap(RSnap* snap);
    RSnap* getSnap();

    void setSnapRestriction(RSnapRestriction* snapRestriction);
    RSnapRestriction* getSnapRestriction();

    RVector snap(RMouseEvent& event);

    REntity::Id getClosestEntity(RMouseEvent& event);
    REntity::Id getClosestEntity(const RVector& position, double range, bool includeLockedLayers = true);
    //REntity::Id getClosestEntityInUcs(const RVector& position, double range);
    void highlightEntity(REntity::Id entityId);
    void highlightReferencePoint(const RVector& position);
    void selectEntities(const QSet<REntity::Id>& entityIds, bool add = false);
    void selectEntity(REntity::Id entityId, bool add = false);
    void deselectEntities(const QSet<REntity::Id>& entityIds);
    void deselectEntity(REntity::Id entityId);
    //void selectClosestEntity(RMouseEvent& event, const RLine& line, bool add = false);
    void selectBoxXY(const RBox& box, bool add = false);
    //void selectBoxInUcs(const RBox& box, bool add = false);
    void selectAll();
    void deselectAll();
    void clearSelection();
    bool hasSelection();

    void addZoomBoxToPreview(const RBox& box);
    //void addTextLabelToPreview(const RTextLabel& textLabel);
    void addShapeToPreview(RShape& shape, const RColor& color,
            const QBrush& brush, RLineweight::Lineweight lineweight,
            Qt::PenStyle style, const QList<qreal>& dashValues = RDEFAULT_QLIST_QREAL);
    void addAuxShapeToPreview(RShape& shape);
    void addEntityToPreview(REntity& entity);
    void beginPreview();
    void endPreview();
    void clearPreview();
    bool isPreviewEmpty();
    void keepPreview();

    void showPropertiesOf(REntity& entity);
    void clearProperties();

    void zoomIn();
    void zoomOut();
    void autoZoom(int margin = RDEFAULT_MIN1);
    bool zoomToSelection();
    void zoomTo(const RBox& region, int margin = 0);
    void zoomPrevious();

    void previewOperation(const ROperation* operation);
    RTransaction applyOperation(const ROperation* operation);

    void objectChangeEvent(QList<RObject::Id>& objectIds);

    RVector getRelativeZero() const;
    RVector getLastPosition() const;
    void setRelativeZero(const RVector& p);

    void lockRelativeZero();
    void unlockRelativeZero();
    bool isRelativeZeroLocked() const;

    RVector getCursorPosition() const;
    void setCursorPosition(const RVector& p);
    void setCursorOverride(bool on);
    bool getCursorOverride() const;

    void deleteTerminatedActions();

    void setCurrentColor(const RColor& color);
    RColor getCurrentColor();

    void setCurrentLineweight(RLineweight::Lineweight lw);
    RLineweight::Lineweight getCurrentLineweight();

    void setCurrentLinetype(RLinetype lt);
    RLinetype getCurrentLinetype();

    void setCurrentLayer(const RLayer& layer);
    void setCurrentLayer(const QString& layerName);

    void setCurrentBlock(const RBlock& block);
    void setCurrentBlock(const QString& blockName);

    void setCurrentView(const QString& viewName);

    void setCurrentUcs(const RUcs& ucs);
    void setCurrentUcs(const QString& ucsName);
    RUcs getCurrentUcs();
    QString getCurrentUcsName();

    RGraphicsView* getLastKnownViewWithFocus();
    void setLastKnownViewWithFocus(RGraphicsView* view);

    static RDocumentInterface& getClipboard();
    bool isClipboard() {
        return this==clipboard;
    }
    bool isSuspended() {
        return suspended;
    }
    void setNotifyListeners(bool on) {
        notifyListeners = on;
    }

private:
    void handleClickEvent(RAction& action, RMouseEvent& event);
    void previewClickEvent(RAction& action, RMouseEvent& event);

private:
    RDocument& document;
    QList<RGraphicsScene*> scenes;
    RGraphicsView* lastKnownViewWithFocus;
    QMap<QString, RScriptHandler*> scriptHandlers;

    RAction* defaultAction;
    QStack<RAction*> currentActions;
    QQueue<RAction*> queuedActions;

    QList<RCoordinateListener*> coordinateListeners;

    RSnap* currentSnap;
    RSnapRestriction* currentSnapRestriction;

    RVector lastPosition;
    RVector relativeZero;
    bool relativeZeroLocked;
    RVector cursorPosition;
    RUcs currentUcs;
    QString currentUcsName;
    bool suspended;

    bool allowUpdate;

    static RDocumentInterface* clipboard;

    bool notifyListeners;
    bool deleting;
    bool cursorOverride;

    bool keepPreviewOnce;

    //QMutex mutex;
};

Q_DECLARE_METATYPE(RDocumentInterface::IoErrorCode)
Q_DECLARE_METATYPE(RDocumentInterface*)

#endif