RMainWindow.h

Go to the documentation of this file.

 
#ifndef RMAINWINDOW_H
#define RMAINWINDOW_H
 
#include "core_global.h"
 
#include <QMutex>
class QKeyEvent;
 
#include "RMainWindowProxy.h"
#include "RMessageHandler.h"
#include "RObject.h"
#include "RProgressHandler.h"
#include "RS.h"
 
class RBlockListener;
class RCoordinateListener;
class RDocument;
class RDocumentInterface;
class REntity;
class REntityExportListener;
class RExporter;
class RExportListener;
class RFocusListener;
class RGraphicsView;
class RImportListener;
class RInterTransactionListener;
class RKeyListener;
class RLayerListener;
class RNewDocumentListener;
class RPaletteListener;
class RPenListener;
class RPropertyEvent;
class RPropertyListener;
class RPropertyTypeId;
class RPreferencesListener;
class RSelectionListener;
class RSnapListener;
class RTransaction;
class RTransactionListener;
class RUcsListener;
class RVector;
class RViewFocusListener;
class RViewListener;
 
#ifndef RDEFAULT_MINUS_ONE
#define RDEFAULT_MINUS_ONE -1
#endif
 
class QCADCORE_EXPORT RMainWindow : public RProgressHandler, public RMessageHandler {
 
public:
    RMainWindow();
    virtual ~RMainWindow();
 
    static RMainWindow* getMainWindow();
 
    static bool hasMainWindow();
 
    static void installMessageHandler();
 
    virtual RDocument* getDocument() = 0;
 
    virtual void disable() {}
    virtual void enable() {}
 
    virtual RDocumentInterface* getDocumentInterface() = 0;
    static RDocumentInterface* getDocumentInterfaceStatic();
 
    void notifyListeners(bool withNull = false);
 
    void addCoordinateListener(RCoordinateListener* l);
    void removeCoordinateListener(RCoordinateListener* l);
    void notifyCoordinateListeners(RDocumentInterface* documentInterface);
 
    void addSelectionListener(RSelectionListener* l);
    void removeSelectionListener(RSelectionListener* l);
    void notifySelectionListeners(RDocumentInterface* documentInterface);
 
    virtual void postSelectionChangedEvent() = 0;
    virtual void postTransactionEvent(
        RTransaction& t,
        bool onlyChanges=false,
        RS::EntityType entityTypeFilter = RS::EntityAll
    ) = 0;
    virtual void postCloseEvent() = 0;
    //virtual void postPropertyEvent() = 0;
    virtual void postPropertyEvent(RPropertyTypeId propertyTypeId,
        const QVariant& value,
        RS::EntityType entityTypeFilter = RS::EntityAll
    ) = 0;
 
    void addPropertyListener(RPropertyListener* l);
    void removePropertyListener(RPropertyListener* l);
    void notifyPropertyListeners(
        RDocument* document,
        bool onlyChanges=false,
        RS::EntityType entityTypeFilter = RS::EntityUnknown
    );
    void notifyPropertyListeners(RDocument& document, REntity& entity);
    void notifyPropertyListeners();
 
    void addExportListener(RExportListener* l);
    void removeExportListener(RExportListener* l);
    void notifyExportListenersPre(RDocumentInterface* documentInterface);
    void notifyExportListenersPost(RDocumentInterface* documentInterface);
    void notifyExportListenersEnd(RExporter* exporter);
 
    void addEntityExportListener(REntityExportListener* l);
    void removeEntityExportListener(REntityExportListener* l);
    void notifyEntityExportListeners(RExporter* exporter, REntity* entity);
 
    void addImportListener(RImportListener* l);
    void removeImportListener(RImportListener* l);
    void notifyImportListenersPre(RDocumentInterface* documentInterface);
    void notifyImportListenersPost(RDocumentInterface* documentInterface);
 
    void addTransactionListener(RTransactionListener* l);
    void removeTransactionListener(RTransactionListener* l);
    void notifyTransactionListeners(RDocument* document, RTransaction* transaction = NULL);
 
    void addInterTransactionListener(RInterTransactionListener* l);
    void removeInterTransactionListener(RInterTransactionListener* l);
    void notifyInterTransactionListeners(RDocument* document, RTransaction* transaction = NULL);
 
    void addNewDocumentListener(RNewDocumentListener* l);
    void removeNewDocumentListener(RNewDocumentListener* l);
    void notifyNewDocumentListeners(RDocument* document, RTransaction* transaction, bool beforeLoad);
 
    void addSnapListener(RSnapListener* l);
    void removeSnapListener(RSnapListener* l);
    void notifySnapListeners(RDocumentInterface* documentInterface);
 
    void addFocusListener(RFocusListener* l);
    void removeFocusListener(RFocusListener* l);
    void notifyFocusListeners(RDocumentInterface* documentInterface);
 
    void addKeyListener(RKeyListener* l);
    void removeKeyListener(RKeyListener* l);
    void notifyKeyListeners(QKeyEvent* event);
 
    void addViewFocusListener(RViewFocusListener* l);
    void removeViewFocusListener(RViewFocusListener* l);
    void notifyViewFocusListeners(RGraphicsView* view);
 
    void addPreferencesListener(RPreferencesListener* l);
    void removePreferencesListener(RPreferencesListener* l);
    void notifyPreferencesListeners(RDocumentInterface* documentInterface);
 
    void propertyChangeEvent(RPropertyEvent& event);
 
    void addUcsListener(RUcsListener* l);
    void removeUcsListener(RUcsListener* l);
    void notifyUcsListeners(RDocumentInterface* documentInterface);
 
    void addLayerListener(RLayerListener* l);
    void removeLayerListener(RLayerListener* l);
    void notifyLayerListeners(RDocumentInterface* documentInterface, QList<RObject::Id>& layerIds);
    void notifyLayerListenersCurrentLayer(RDocumentInterface* documentInterface, RObject::Id previousLayerId);
 
    void addBlockListener(RBlockListener* l);
    void removeBlockListener(RBlockListener* l);
    void notifyBlockListeners(RDocumentInterface* documentInterface);
    void notifyBlockListenersCurrentBlock(RDocumentInterface* documentInterface);
 
    void addViewListener(RViewListener* l);
    void removeViewListener(RViewListener* l);
    void notifyViewListeners(RDocumentInterface* documentInterface);
 
    void addPenListener(RPenListener* l);
    void removePenListener(RPenListener* l);
    void notifyPenListeners(RDocumentInterface* documentInterface);
 
    void addPaletteListener(RPaletteListener* l);
    void removePaletteListener(RPaletteListener* l);
    void notifyPaletteListeners();
 
    void ucsSetEvent(const QString& ucsName);
 
    //void commandEvent(const QString& command);
 
    virtual void escapeEvent() = 0;
 
    virtual void setGraphicsViewCursor(const QCursor& cursor) = 0;
 
    virtual int getWidth() = 0;
    virtual int getHeight() = 0;
    virtual int getPositionX() = 0;
    virtual int getPositionY() = 0;
 
    virtual void resize(int width, int height) = 0;
    virtual void move(int x, int y) = 0;
    virtual void quit() = 0;
 
    virtual QWidget* getChildWidget(const QString& name) = 0;
 
    virtual void handleUserMessage(const QString& message, bool escape = true) {
        Q_UNUSED(escape);
 
        qDebug() << message;
    }
 
    virtual void handleUserInfo(const QString& message, bool escape = true) {
        Q_UNUSED(escape);
 
        qDebug() << message;
    }
 
    virtual void handleUserWarning(const QString& message, bool messageBox = false, bool escape = true) {
        Q_UNUSED(messageBox);
        Q_UNUSED(escape);
 
        qWarning() << message;
    }
 
    virtual void handleUserCommand(const QString& message, bool escape = true) {
        Q_UNUSED(escape);
 
        qDebug() << "Command: " << message;
    }
 
#if QT_VERSION >= 0x050000
    static void messageHandler(QtMsgType type, const QMessageLogContext& context, const QString& message);
#else
    static void messageHandler(QtMsgType type, const char* msg);
#endif
 
    virtual void setCommandPrompt(const QString& text = "") = 0;
    virtual void setLeftMouseTip(const QString& text = "") = 0;
    virtual void setRightMouseTip(const QString& text = "") = 0;
 
    QVariant eval(const QString& ext, const QString& script);
 
    static bool hasProxy() {
        return mainWindowProxy!=NULL;
    }
 
    static void setMainWindowProxy(RMainWindowProxy* p) {
        if (mainWindowProxy!=NULL) {
            delete mainWindowProxy;
        }
        mainWindowProxy = p;
    }
 
    static RMainWindowProxy* getMainWindowProxy() {
        return mainWindowProxy;
    }
 
protected:
    virtual bool readSettings();
    virtual void writeSettings();
 
protected:
    static RMainWindow* mainWindow;
 
    QList<RCoordinateListener*> coordinateListeners;
    QList<RSelectionListener*> selectionListeners;
    QList<RPropertyListener*> propertyListeners;
    QList<RUcsListener*> ucsListeners;
    QList<RLayerListener*> layerListeners;
    QList<RBlockListener*> blockListeners;
    QList<RViewListener*> viewListeners;
    QList<RPenListener*> penListeners;
    QList<RPaletteListener*> paletteListeners;
    QList<REntityExportListener*> entityExportListeners;
    QList<RExportListener*> exportListeners;
    QList<RImportListener*> importListeners;
    QList<RTransactionListener*> transactionListeners;
    QList<RInterTransactionListener*> interTransactionListeners;
    QList<RNewDocumentListener*> newDocumentListeners;
    QList<RSnapListener*> snapListeners;
    QList<RKeyListener*> keyListeners;
    QList<RFocusListener*> focusListeners;
    QList<RViewFocusListener*> viewFocusListeners;
    QList<RPreferencesListener*> preferencesListeners;
 
    QMutex mutex;
 
    static RMainWindowProxy* mainWindowProxy;
};
 
Q_DECLARE_METATYPE(RMainWindow*)
 
#endif