umldoc.h

Go to the documentation of this file.

/*
    SPDX-License-Identifier: GPL-2.0-or-later
    SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
 
#ifndef UMLDOC_H
#define UMLDOC_H
 
// app includes
#include "basictypes.h"
#include "optionstate.h"
#include "umlobject.h"
#include "umlobjectlist.h"
#include "umlassociationlist.h"
#include "umlclassifierlist.h"
#include "umlentitylist.h"
#include "umlviewlist.h"
#include "umlstereotypelist.h"
#include "umlpackagelist.h"
 
// kde includes
#if QT_VERSION < 0x050000
#include <kurl.h>
#endif
 
// qt includes
#if QT_VERSION >= 0x050000
#include <QUrl>
#endif
#include <QMap>
 
// system includes
#include <typeinfo>
 
#define ENC_UNKNOWN 0
#define ENC_UNICODE 1
#define ENC_WINDOWS 2
#define ENC_OLD_ENC 3
 
// forward declarations
class QDomNode;
class QDomElement;
class QPrinter;
 
class IDChangeLog;
class DiagramsModel;
class ObjectsModel;
class StereotypesModel;
class UMLPackage;
class UMLFolder;
class DiagramPrintPage;
 
class UMLDoc : public QObject
{
    Q_OBJECT
public:
 
    UMLDoc();
    ~UMLDoc();
 
    void init();
 
    void addView(UMLView *view);
    void removeView(UMLView *view, bool enforceOneView = true);
    void setMainViewID(Uml::ID::Type viewID);
    void changeCurrentView(Uml::ID::Type id);
    void activateAllViews();
    void removeAllViews();
    void removeAllObjects();
 
    void setModified(bool modified = true);
    bool isModified() const;
    bool saveModified();
 
    bool newDocument();
    void closeDocument();
#if QT_VERSION >= 0x050000
    bool openDocument(const QUrl& url, const char *format = 0);
    bool saveDocument(const QUrl& url, const char *format = 0);
    const QUrl& url() const;
    void setUrl(const QUrl& url);
#else
    bool openDocument(const KUrl& url, const char *format = 0);
    bool saveDocument(const KUrl& url, const char *format = 0);
    const KUrl& url() const;
    void setUrl(const KUrl& url);
#endif
    void setUrlUntitled();
 
    void setupSignals();
 
    bool isUnique(const QString &name) const;
    bool isUnique(const QString &name, UMLPackage *package) const;
 
    UMLAssociation* createUMLAssociation(UMLObject *a, UMLObject *b, Uml::AssociationType::Enum type);
 
    void addAssociation(UMLAssociation *assoc);
    void removeAssociation(UMLAssociation *assoc, bool doSetModified = true);
    UMLAssociation * findAssociation(Uml::AssociationType::Enum assocType,
                                     const UMLObject *roleAObj,
                                     const UMLObject *roleBObj,
                                     bool *swap = 0) const;
 
    QString createDiagramName(Uml::DiagramType::Enum type, bool askForName = true);
    UMLView* createDiagram(UMLFolder *folder,
                           Uml::DiagramType::Enum type,
                           const QString& name,
                           Uml::ID::Type id = Uml::ID::None);
 
    void removeDiagram(Uml::ID::Type id);
    void removeDiagramCmd(Uml::ID::Type id);
    void renameDiagram(Uml::ID::Type id);
 
    void removeUMLObject(UMLObject* umlobject, bool deleteObject = false);
    void renameUMLObject(UMLObject *o);
    void renameChildUMLObject(UMLObject *o);
 
    UMLObject* findObjectById(Uml::ID::Type id);
 
    UMLObject* findUMLObject(const QString &name,
                             UMLObject::ObjectType type = UMLObject::ot_UMLObject,
                             UMLObject *currentObj = 0);
 
    UMLObject* findUMLObjectRaw(Uml::ModelType::Enum,
                                const QString &name,
                                UMLObject::ObjectType type = UMLObject::ot_UMLObject);
 
    UMLObject* findUMLObjectRaw(UMLFolder *folder,
                                const QString &name,
                                UMLObject::ObjectType type = UMLObject::ot_UMLObject);
 
    UMLObject* findUMLObjectRecursive(Uml::ModelType::Enum,
                                      const QString &name,
                                      UMLObject::ObjectType type = UMLObject::ot_UMLObject);
 
    UMLObject* findUMLObjectRecursive(UMLFolder *folder,
                                      const QString &name,
                                      UMLObject::ObjectType type = UMLObject::ot_UMLObject);
 
    UMLClassifier * findUMLClassifier(const QString &name);
 
    UMLView * findView(Uml::ID::Type id) const;
    UMLView * findView(Uml::DiagramType::Enum type, const QString &name,
                       bool searchAllScopes = false) const;
 
    void setName(const QString& name);
    QString name() const;
 
    void setResolution(qreal resolution);
    qreal resolution() const;
    qreal dpiScale() const;
 
    Uml::ID::Type modelID() const;
 
    static bool tagEq (const QString& tag, const QString& pattern);
 
    virtual void saveToXMI(QIODevice& file);
 
    short encoding(QIODevice & file);
 
    virtual bool loadFromXMI(QIODevice& file, short encode = ENC_UNKNOWN);
 
    bool validateXMI1Header(QDomNode& headerNode);
 
    bool loadUMLObjectsFromXMI(QDomElement & element);
    void loadExtensionsFromXMI1(QDomNode & node);
    bool loadDiagramsFromXMI1(QDomNode & node);
 
    void signalDiagramRenamed(UMLView * view);
    void signalUMLObjectCreated(UMLObject * o);
 
    UMLClassifierList concepts(bool includeNested = true) const;
    UMLClassifierList classesAndInterfaces(bool includeNested = true) const;
    UMLEntityList entities(bool includeNested = true) const;
    UMLFolder * datatypeFolder() const;
    UMLClassifierList datatypes(bool includeInactive = false) const;
    UMLDatatype * findDatatype(QString name, bool includeInactive = false);
    UMLAssociationList associations() const;
    UMLPackageList packages(bool includeNested = true, Uml::ModelType::Enum model = Uml::ModelType::Logical) const;
 
    void print(QPrinter * pPrinter, DiagramPrintPage * selectPage);
 
    UMLViewList viewIterator() const;
    UMLViewList views(Uml::DiagramType::Enum type = Uml::DiagramType::Undefined) const;
 
    bool assignNewIDs(UMLObject* obj);
 
    bool addUMLObject(UMLObject * object);
    bool addUMLView(UMLView * pView);
 
    UMLFolder *rootFolder(Uml::ModelType::Enum mt) const;
    Uml::ModelType::Enum rootFolderType(UMLObject *obj) const;
 
    UMLFolder *currentRoot() const;
    void setCurrentRoot(Uml::ModelType::Enum rootType);
 
    virtual IDChangeLog* changeLog() const;
 
    void beginPaste();
    void endPaste();
 
    Uml::ID::Type assignNewID(Uml::ID::Type oldID);
 
    void setDocumentation(const QString &doc);
    QString documentation() const;
 
    void settingsChanged(Settings::OptionState &optionState);
 
    QString uniqueViewName(const Uml::DiagramType::Enum type) const;
 
    bool loading() const;
    void setLoading(bool state = true);
 
    bool importing() const;
    void setImporting(bool state = true);
 
    bool closing() const;
 
    void addDefaultDatatypes();
    UMLDatatype * createDatatype(const QString &name);
    void removeDatatype(const QString &name);
 
    UMLStereotype *createStereotype(const QString &name);
    UMLStereotype *findStereotype(const QString &name) const;
    UMLStereotype *findOrCreateStereotype(const QString &name);
    UMLStereotype *findStereotypeById(Uml::ID::Type id) const;
    void addStereotype(UMLStereotype *s);
    void removeStereotype(UMLStereotype *s);
    void addDefaultStereotypes();
    const UMLStereotypeList& stereotypes() const;
 
    void writeToStatusBar(const QString &text);
 
    void resolveTypes();
    bool loadDiagrams1();
    void addDiagramToLoad(UMLFolder *folder, QDomNode node);
 
    DiagramsModel *diagramsModel() const;
    StereotypesModel *stereotypesModel() const;
    ObjectsModel *objectsModel() const;
 
    void setLoadingError(const QString &text);
 
private:
    void initSaveTimer();
    void createDatatypeFolder();
 
    class Private;
    Private *m_d;
 
    UMLFolder *m_root[Uml::ModelType::N_MODELTYPES];
 
    UMLFolder *m_datatypeRoot;
 
    UMLStereotypeList m_stereoList;
 
    QString m_Name; 
    Uml::ID::Type m_modelID; 
    int m_count;   
    bool m_modified;
#if QT_VERSION >= 0x050000
    QUrl m_doc_url;
#else
    KUrl m_doc_url;
#endif
    IDChangeLog* m_pChangeLog;
 
    bool m_bLoading;
 
    bool m_importing;
 
    QString m_Doc;
 
    QTimer * m_pAutoSaveTimer;
 
    Uml::ID::Type m_nViewID;
 
    bool m_bTypesAreResolved;
 
    UMLFolder * m_pCurrentRoot;
 
    bool m_bClosing;
 
    DiagramsModel *m_diagramsModel;
    ObjectsModel *m_objectsModel;
    StereotypesModel *m_stereotypesModel;
 
    qreal m_resolution;
 
    typedef QMap<UMLFolder*, QList<QDomNode>> DiagramsMap;
    DiagramsMap m_diagramsToLoad;
 
public slots:
    void slotRemoveUMLObject(UMLObject*o);
    void slotAutoSave();
    void slotDiagramPopupMenu(QWidget* umlview, const QPoint& point);
 
signals:
    void sigDiagramCreated(Uml::ID::Type id);
    void sigDiagramRemoved(Uml::ID::Type id);
    void sigDiagramRenamed(Uml::ID::Type t);
    void sigDiagramChanged(Uml::DiagramType::Enum);
 
    void sigObjectCreated(UMLObject *);
    void sigObjectRemoved(UMLObject *);
 
    void sigResetStatusbarProgress();
 
    void sigSetStatusbarProgressSteps(int totalSteps);
 
    void sigSetStatusbarProgress(int stepPosition);
 
    void sigWriteToStatusBar(const QString &text);
 
    void sigCurrentViewChanged();
 
};
 
#endif // UMLDOC_H