diagram.h

Go to the documentation of this file.

/*
        Copyright 2006-2026 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 "autoNum/numerotationcontext.h"
#include "bordertitleblock.h"
#include "conductorproperties.h"
#include "elementsmover.h"
#include "elementtextsmover.h"
#include "exportproperties.h"
#include "properties/xrefproperties.h"
#include "qgimanager.h"
 
#include <QHash>
#include <QUuid>
#include <QtWidgets>
#include <QtXml>
 
class Conductor;
class CustomElement;
class DiagramContent;
class DiagramPosition;
class DiagramTextItem;
class Element;
class ElementsLocation;
class DiagramImageItem;
class DiagramEventInterface;
class DiagramFolioList;
class QETProject;
struct GuideProperties;

class Diagram : public QGraphicsScene
{
        friend DiagramFolioList;
        friend QETProject;
 
        Q_OBJECT
        
                // constructors, destructor
        private:
                Diagram(QETProject *project);
                ~Diagram() override;
                Diagram(const Diagram &diagram);
        
        // ATTRIBUTES
        public:
                struct Guide {
                        enum Orientation { Horizontal, Vertical };
                        Orientation orientation;
                        qreal position;
                        QColor color;
                };

                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_guides_;
                QList<Diagram::Guide> m_guides_list;
                bool draw_terminals_;
                bool draw_terminal_names_;
                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:
                void correctTextPos(Element* elmt);
                void restoreText(Element* elmt);
                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;
                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 wholeContent = true, bool is_copy_command = false);
                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 setDisplayGuides(bool);
                bool displayGuides();
                void updateProjectGuides(const QList<GuideProperties> &guides);
                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 drawTerminalNames() const;
                void setDrawTerminalNames(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();
                void titleBlockTemplateChanged(const QString &);
                void titleBlockTemplateRemoved(const QString &,
                                               const QString & = QString());
                void setTitleBlockTemplate(const QString &);
                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 *);

                void findElementRequired(const ElementsLocation &);
 
                void diagramActivated();
                void diagramInformationChanged();
};
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::setDisplayGuides(bool dg) {
        if (draw_guides_ != dg) {
                draw_guides_ = dg;
                update();
        }
}
 
inline bool Diagram::displayGuides() {
        return(draw_guides_);
}

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 QGIManager &Diagram::qgiManager() {
        return(*qgi_manager_);
}

inline bool Diagram::drawTerminals() const
{
        return(draw_terminals_);
}

inline bool Diagram::drawTerminalNames() const
{
        return(draw_terminal_names_);
}

inline bool Diagram::drawColoredConductors() const
{
        return(draw_colored_conductors_);
}
 
#endif