d7/d0f/conductor_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 CONDUCTOR_H

#define CONDUCTOR_H


#include "conductorproperties.h"

#include <QGraphicsPathItem>

#include "assignvariables.h"


class ConductorProfile;

class ConductorSegmentProfile;

class Diagram;

class Terminal;

class ConductorSegment;

class ConductorTextItem;

class Element;

class QETDiagramEditor;

class NumerotationContext;

class QetGraphicsHandlerItem;


typedef QPair<QPointF, Qt::Corner> ConductorBend;

typedef QHash<Qt::Corner, ConductorProfile> ConductorProfilesGroup;

class Conductor : public QGraphicsObject

{

        Q_OBJECT


        Q_PROPERTY(QPointF pos READ pos WRITE setPos)

        Q_PROPERTY(int animPath READ fakePath WRITE updatePathAnimate)

        Q_PROPERTY(ConductorProperties properties READ properties WRITE setProperties)

        Q_PROPERTY(autonum::sequentialNumbers sequenceNum READ sequenceNum WRITE setSequenceNum)


        signals:

                void propertiesChange();


        public:

                Conductor(Terminal *, Terminal *);

                ~Conductor() override;


                bool isValid() const;


        private:

                Conductor(const Conductor &);


        public:

                enum { Type = UserType + 1001 };

                enum Highlight { None, Normal, Alert };


                Terminal *terminal1;

                Terminal *terminal2;


        public:

                int type() const override { return Type; }

                Diagram *diagram() const;

                ConductorTextItem *textItem() const;

                void updatePath(const QRectF & = QRectF());


                        //This method do nothing, it's only made to be used with Q_PROPERTY

                        //It's used to anim the path when is change

                void updatePathAnimate(const int = 1) {updatePath();}

                int fakePath() {return 1;}


                void paint(QPainter *,

                           const QStyleOptionGraphicsItem *,

                           QWidget *) override;

                QRectF boundingRect() const override;

                QPainterPath shape() const override;

                virtual QPainterPath nearShape() const;

                qreal length() const;

                ConductorSegment *middleSegment();

                QPointF posForText(Qt::Orientations &flag);

                void refreshText();

                void setPath(const QPainterPath &path);

                QPainterPath path() const;


        public:

                static bool valideXml (QDomElement &);

                bool fromXml (QDomElement &);

                QDomElement toXml (QDomDocument &,

                                   QHash<Terminal *,

                                   int> &) const;

        private:

                bool pathFromXml(const QDomElement &);


        public:

                QVector <QPointF> handlerPoints() const;

                const QList<ConductorSegment *> segmentsList() const;


                void setPropertyToPotential(const ConductorProperties &property,

                                            bool only_text = false);

                void setProperties(const ConductorProperties &property);

                ConductorProperties properties() const;


                void setProfile(const ConductorProfile &, Qt::Corner);

                ConductorProfile profile(Qt::Corner) const;

                void setProfiles(const ConductorProfilesGroup &);

                ConductorProfilesGroup profiles() const;

                void calculateTextItemPosition();

                virtual Highlight highlight() const;

                virtual void setHighlighted(Highlight);

                QSet<Conductor *> relatedPotentialConductors(

                                const bool all_diagram = true,

                                QList <Terminal *> *t_list=nullptr);

                QETDiagramEditor* diagramEditor() const;

                void editProperty ();


                autonum::sequentialNumbers sequenceNum () const {return m_autoNum_seq;}

                autonum::sequentialNumbers& rSequenceNum()      {return m_autoNum_seq;}

                void setSequenceNum(const autonum::sequentialNumbers& sn);


        private:

                void setUpConnectionForFormula(QString old_formula, QString new_formula);

                autonum::sequentialNumbers m_autoNum_seq;


        public:

                void setFreezeLabel(bool freeze);


        public slots:

                void displayedTextChanged();


        protected:

                void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override;

                void mousePressEvent(QGraphicsSceneMouseEvent *event) override;

                void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;

                void hoverEnterEvent(QGraphicsSceneHoverEvent *event) override;

                void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override;

                QVariant itemChange(GraphicsItemChange, const QVariant &) override;

                bool sceneEventFilter(QGraphicsItem *watched, QEvent *event) override;


        private:

                void adjusteHandlerPos();


                void handlerMousePressEvent   (QetGraphicsHandlerItem *qghi, QGraphicsSceneMouseEvent *event);

                void handlerMouseMoveEvent    (QetGraphicsHandlerItem *qghi, QGraphicsSceneMouseEvent *event);

                void handlerMouseReleaseEvent (QetGraphicsHandlerItem *qghi, QGraphicsSceneMouseEvent *event);

                void addHandler();

                void removeHandler();


                QVector<QetGraphicsHandlerItem *> m_handler_vector;

                int m_vector_index = -1;

                bool m_mouse_over;

                ConductorProperties m_properties;

                ConductorTextItem *m_text_item;

                ConductorSegment *segments;

                bool m_moving_segment;

                int moved_point;

                qreal m_previous_z_value;

                ConductorSegment *m_moved_segment;

                QPointF before_mov_text_pos_;

                bool modified_path;

                bool has_to_save_profile;

                ConductorProfilesGroup conductor_profiles;

                Highlight must_highlight_;

                bool m_valid;

                bool m_freeze_label = false;


                static QPen conductor_pen;

                static QBrush conductor_brush;

                static bool pen_and_brush_initialized;

                QPainterPath m_path;


        private:

                void segmentsToPath();

                void saveProfile(bool = true);

                void generateConductorPath(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation);

                void updateConductorPath(const QPointF &, Qet::Orientation, const QPointF &, Qet::Orientation);

                uint segmentsCount(QET::ConductorSegmentType = QET::Both) const;

                QList<QPointF> segmentsToPoints() const;

                QList<ConductorBend> bends() const;

                QList<QPointF> junctions() const;

                void pointsToSegments(const QList<QPointF>&);

                Qt::Corner currentPathType() const;

                void deleteSegments();

                static int getCoeff(const qreal &, const qreal &);

                static int getSign(const qreal &);

                QHash<ConductorSegmentProfile *, qreal> shareOffsetBetweenSegments(const qreal &offset, const QList<ConductorSegmentProfile *> &, const qreal & = 0.01) const;

                static QPointF extendTerminal(const QPointF &, Qet::Orientation, qreal = 9.0);

                static Qt::Corner movementType(const QPointF &, const QPointF &);

                static QPointF movePointIntoPolygon(const QPointF &, const QPainterPath &);

};


Conductor * longuestConductorInPotential (Conductor *conductor, bool all_diagram = false);

QList <Conductor *> relatedConductors (const Conductor *conductor);


//return true if @a is between or at @b and @c.

template <typename T>

bool isBetween (const T a, const T b, const T c) {

        return (b <= c)? (a >= b && a <= c) : (a <= b && a >= c);

}


#endif