d9/d1b/diagram_8h_source.html

/*

        Copyright 2006-2020 The QElectroTech Team

        This file is part of QElectroTech.


        QElectroTech is free software: you can redistribute it and/or modify

        it under the terms of the GNU General Public License as published by

        the Free Software Foundation, either version 2 of the License, or

        (at your option) any later version.


        QElectroTech is distributed in the hope that it will be useful,

        but WITHOUT ANY WARRANTY; without even the implied warranty of

        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

        GNU General Public License for more details.


        You should have received a copy of the GNU General Public License

        along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef DIAGRAM_H

#define DIAGRAM_H

#include <QtWidgets>

#include <QtXml>

#include <QHash>

#include <QUuid>


#include "bordertitleblock.h"

#include "conductorproperties.h"

#include "exportproperties.h"

#include "qgimanager.h"

#include "numerotationcontext.h"

#include "qetproject.h"

#include "properties/xrefproperties.h"

#include "elementsmover.h"

#include "elementtextsmover.h"


class Conductor;

class CustomElement;

class DiagramContent;

class DiagramPosition;

class DiagramTextItem;

class Element;

class ElementsLocation;

class QETProject;

class Terminal;

class DiagramImageItem;

class DiagramEventInterface;

class DiagramFolioList;

class QETProject;


class Diagram : public QGraphicsScene

{

        friend DiagramFolioList;

        friend QETProject;


        Q_OBJECT


                // constructors, destructor

        private:

                Diagram(QETProject *project);

                ~Diagram() override;

                Diagram(const Diagram &diagram);


        // ATTRIBUTES

        public:

                enum BorderOptions { EmptyBorder, TitleBlock, Columns };

                enum NumerotationType { Conductors };

                ConductorProperties defaultConductorProperties;

                BorderTitleBlock border_and_titleblock;

                static int xGrid;

                static int yGrid;

                static int xKeyGrid;

                static int yKeyGrid;

                static int xKeyGridFine;

                static int yKeyGridFine;

                static const qreal margin;

                static QColor background_color;

                QHash <QString, QStringList> m_elmt_unitfolio_max;

                QHash <QString, QStringList> m_elmt_tenfolio_max;

                QHash <QString, QStringList> m_elmt_hundredfolio_max;

                QHash <QString, QStringList> m_cnd_unitfolio_max;

                QHash <QString, QStringList> m_cnd_tenfolio_max;

                QHash <QString, QStringList> m_cnd_hundredfolio_max;


        private:

                QGraphicsLineItem *conductor_setter_;

                ElementsMover     m_elements_mover;

                ElementTextsMover m_element_texts_mover;

                QGIManager        *qgi_manager_;

                QETProject        *m_project;


                QDomDocument xml_document_;


                qreal diagram_qet_version_;


                bool draw_grid_;

                bool use_border_;

                bool draw_terminals_;

                bool draw_colored_conductors_;


                QString m_conductors_autonum_name;

                DiagramEventInterface *m_event_interface;


                bool m_freeze_new_elements;

                bool m_freeze_new_conductors_;

                QUuid m_uuid = QUuid::createUuid();


        // METHODS

        protected:

                void drawBackground(QPainter *, const QRectF &) override;


                void mouseDoubleClickEvent (

                                QGraphicsSceneMouseEvent *event) override;

                void mousePressEvent (QGraphicsSceneMouseEvent *event) override;

                void mouseMoveEvent (QGraphicsSceneMouseEvent *event) override;

                void mouseReleaseEvent (

                                QGraphicsSceneMouseEvent *event) override;

                void wheelEvent (QGraphicsSceneWheelEvent *event) override;

                void keyPressEvent (QKeyEvent *event) override;

                void keyReleaseEvent (QKeyEvent *) override;


        public:

                QUuid uuid();

                void setEventInterface (DiagramEventInterface *event_interface);

                void clearEventInterface();


                //methods related to autonum

                QString conductorsAutonumName() const;

                void setConductorsAutonumName(const QString &name);


                static bool clipboardMayContainDiagram();


                // methods related to parent project

                QETProject *project() const;

                int         folioIndex() const;

                qreal       declaredQElectroTechVersion(bool = true) const;

                void        showMe() {emit showDiagram(this);}

                bool        isReadOnly() const;


                // methods related to conductor creation

                void setConductor(bool);

                void setConductorStart (QPointF);

                void setConductorStop(QPointF);

                QList < QSet <Conductor *> > potentials();


                // methods related to XML import/export

                QDomDocument toXml(bool = true);

                bool initFromXml(QDomElement &,

                                 QPointF = QPointF(),

                                 bool = true,

                                 DiagramContent * = nullptr);

                bool fromXml(QDomDocument &,

                             QPointF = QPointF(),

                             bool = true,

                             DiagramContent * = nullptr);

                bool fromXml(QDomElement &,

                             QPointF = QPointF(),

                             bool = true,

                             DiagramContent * = nullptr);

                void folioSequentialsToXml(QHash<QString,

                                           QStringList>*,

                                           QDomElement *,

                                           const QString&,

                                           const QString&,

                                           QDomDocument *);

                void folioSequentialsFromXml(const QDomElement&,

                                             QHash<QString,

                                             QStringList>*,

                                             const QString&,

                                             const QString&,

                                             const QString&,

                                             const QString&);


                void refreshContents();


                // methods related to graphics items addition/removal on the diagram

                virtual void addItem    (QGraphicsItem *item);

                virtual void removeItem (QGraphicsItem *item);


                // methods related to graphics options

                ExportProperties applyProperties(const ExportProperties &);

                void setDisplayGrid(bool);

                bool displayGrid();

                void setUseBorder(bool);

                bool useBorder();

                void setBorderOptions(BorderOptions);

                BorderOptions borderOptions();

                DiagramPosition convertPosition(const QPointF &);

                static QPointF snapToGrid(const QPointF &p);


                bool drawTerminals() const;

                void setDrawTerminals(bool);

                bool drawColoredConductors() const;

                void setDrawColoredConductors(bool);


                QString title() const;

                bool toPaintDevice(QPaintDevice &, int = -1, int = -1,

                                   Qt::AspectRatioMode = Qt::KeepAspectRatio);

                QSize imageSize() const;


                bool isEmpty() const;


                QList<Element *> elements() const;

                QList<Conductor *> conductors() const;

                QSet<Conductor *> selectedConductors() const;

                DiagramContent content() const;

                bool canRotateSelection() const;

                ElementsMover &elementsMover();

                ElementTextsMover &elementTextsMover();

                bool usesElement(const ElementsLocation &);

                bool usesTitleBlockTemplate(const QString &);


                QUndoStack &undoStack();

                QGIManager &qgiManager();


                //methods related to element label Update Policy

                void freezeElements(bool freeze);

                void unfreezeElements();

                void setFreezeNewElements(bool);

                bool freezeNewElements();


                //methods related to conductor label Update Policy

                void freezeConductors(bool freeze);

                void setFreezeNewConductors(bool);

                bool freezeNewConductors();


                //methods related to insertion and loading of folio sequential

                void insertFolioSeqHash (QHash<QString, QStringList> *hash,

                                         const QString& title,

                                         const QString& seq,

                                         NumerotationContext *nc);

                void loadFolioSeqHash (QHash<QString, QStringList> *hash,

                                       const QString& title, const QString& seq,

                                       NumerotationContext *nc);

                void changeZValue(QET::DepthOption option);


        public slots:

                void adjustSceneRect ();

                void titleChanged(const QString &);

                void titleBlockTemplateChanged(const QString &);

                void titleBlockTemplateRemoved(const QString &,

                                               const QString & = QString());

                void setTitleBlockTemplate(const QString &);

                void updateLabels();

                void loadElmtFolioSeq();

                void loadCndFolioSeq();


                // methods related to graphics items selection

                void selectAll();

                void deselectAll();

                void invertSelection();


        signals:

                void showDiagram (Diagram *);

                void usedTitleBlockTemplateChanged(const QString &);

                void diagramTitleChanged(Diagram *, const QString &);


                void findElementRequired(const ElementsLocation &);


                void editElementRequired(const ElementsLocation &);


                void diagramActivated();

};

Q_DECLARE_METATYPE(Diagram *)


inline void Diagram::setConductor(bool adding) {

        if (adding) {

                if (!conductor_setter_ -> scene()) addItem(conductor_setter_);

        } else {

                if (conductor_setter_ -> scene()) removeItem(conductor_setter_);

        }

}


inline void Diagram::setConductorStart(QPointF start) {

        conductor_setter_ -> setLine(QLineF(start, conductor_setter_ -> line().p2()));

}


inline void Diagram::setConductorStop(QPointF end) {

        conductor_setter_ -> setLine(QLineF(conductor_setter_ -> line().p1(), end));

}


inline void Diagram::setDisplayGrid(bool dg) {

        draw_grid_ = dg;

}


inline bool Diagram::displayGrid() {

        return(draw_grid_);

}


inline void Diagram::setUseBorder(bool ub) {

        use_border_ = ub;

}


inline bool Diagram::useBorder() {

        return(use_border_);

}


inline void Diagram::setBorderOptions(Diagram::BorderOptions bo) {

        border_and_titleblock.displayBorder(!(bo & EmptyBorder));

        border_and_titleblock.displayColumns(bo & Columns);

        border_and_titleblock.displayTitleBlock(bo & TitleBlock);

}


inline Diagram::BorderOptions Diagram::borderOptions() {

        BorderOptions options = EmptyBorder;

        if (border_and_titleblock.titleBlockIsDisplayed())

                options = (BorderOptions)(options|TitleBlock);

        if (border_and_titleblock.columnsAreDisplayed())

                options = (BorderOptions)(options|Columns);

        return(options);

}


inline QUndoStack &Diagram::undoStack() {

        return *(project()->undoStack());

}


inline QGIManager &Diagram::qgiManager() {

        return(*qgi_manager_);

}


inline bool Diagram::drawTerminals() const {

        return(draw_terminals_);

}


inline bool Diagram::drawColoredConductors() const {

        return(draw_colored_conductors_);

}


#endif