qet.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 _QET_H
#define _QET_H
 
#include <QDomElement>
#include <QFile>
#include <QObject>
 
class QActionGroup;
namespace QET {
        QString license();  // only QETs license
        std::tuple<QString, QString> licenses(const QString &); // all licenses
        
                //Describe the current state of a graphic item
        enum GraphicsItemState {
                GIOK,                            
                GIBuildingFromXml, 
                GILoadingFromXml         
        };
        
        enum DepthOption {
                BringForward, 
                Raise,        
                Lower,        
                SendBackward  
        };
        
        enum OrientedMovement {
                ToNorth,
                ToNorthEast,
                ToEast,
                ToSouthEast,
                ToSouth,
                ToSouthWest,
                ToWest,
                ToNorthWest
        };
        
        enum OperationAreas {
                ChangeInnerPoints = -4,
                RotateArea = -3,
                MoveArea = -2,
                NoOperation = -1,
                ResizeFromTopLeftCorner = 0,
                ResizeFromTopCenterCorner = 1,
                ResizeFromTopRightCorner = 2,
                ResizeFromMiddleLeftCorner = 3,
                ResizeFromMiddleRightCorner = 4,
                ResizeFromBottomLeftCorner = 5,
                ResizeFromBottomCenterCorner = 6,
                ResizeFromBottomRightCorner = 7
        };
        
        enum ScalingMethod {
                FreeScaling,              
                SnapScalingPointToGrid,   
                RoundScaleRatios          
        };
        
        enum ConductorSegmentType {
                Horizontal = 1, 
                Vertical = 2,   
                Both = 3        
        };
        
        
        enum ItemType {
                Element                           =    1,
                ElementsCategory                  =    2,
                ElementsCollection                =    4,
                ElementsContainer                 =    6,
                ElementsCollectionItem            =    7,
                TitleBlockTemplate                =    8,
                TitleBlockTemplatesCollection     =   16,
                TitleBlockTemplatesCollectionItem =   24,
                Diagram                           =   32,
                Project                           =   64,
                All                               =  127
        };
        
        enum Filtering {
                BeginFilter,
                RegularFilter,
                EndFilter
        };
        
        enum Action {
                Retry,   
                Ignore,  
                Erase,   
                Abort,   
                Managed, 
                Rename   
        };
        
        enum DiagramArea {
                BorderArea,      
                ElementsArea     
        };
        
        enum TitleBlockColumnLength {
                Absolute,                   
                RelativeToTotalLength,      
                RelativeToRemainingLength   
        };

        enum QetCollection {
                Common,         
                Company,        
                Custom,         
                Embedded        
        };
 
        QString qetCollectionToString (const QetCollection &c);
        QetCollection qetCollectionFromString (const QString &str);
        
        bool lineContainsPoint(const QLineF &, const QPointF &);
        bool orthogonalProjection(const QPointF &, const QLineF &, QPointF * = nullptr);
        bool attributeIsAnInteger(const QDomElement &, const QString& , int * = nullptr);
        bool attributeIsAReal(const QDomElement &, const QString& , qreal * = nullptr);
        QString ElementsAndConductorsSentence(int elements=0,
                                                                                  int conductors=0,
                                                                                  int indi_texts=0,
                                                                                  int images=0,
                                                                                  int shapes=0,
                                                                                  int element_text=0,
                                                                                  int tables_count=0,
                                                                                  int terminal_strip_count=0);
        QList<QDomElement> findInDomElement(const QDomElement &, const QString &);
        QList<QDomElement> findInDomElement(const QDomElement &, const QString &, const QString &);
        QList<QChar> forbiddenCharacters();
        QString stringToFileName(const QString &);
        QString escapeSpaces(const QString &);
        QString unescapeSpaces(const QString &);
        QString joinWithSpaces(const QStringList &);
        QStringList splitWithSpaces(const QString &);
        QString diagramAreaToString(const QET::DiagramArea &);
        QET::DiagramArea diagramAreaFromString(const QString &);
        qreal round(qreal, qreal);
        qreal correctAngle(const qreal &, const bool &positive = false);
        bool compareCanonicalFilePaths(const QString &, const QString &);
        bool writeXmlFile(QDomDocument &xml_doc, const QString &filepath, QString * error_message= nullptr);
        bool writeToFile (QDomDocument &xml_doc, QFile *file, QString *error_message = nullptr);
        bool eachStrIsEqual (const QStringList &qsl);
        QActionGroup *depthActionGroup(QObject *parent = nullptr);
}
 
Q_DECLARE_METATYPE(QET::DepthOption)
 
class Qet : public QObject
{
        Q_OBJECT
 
        public:
                enum EndType {
                        None,      
                        Simple,    
                        Triangle,  
                        Circle,    
                        Diamond    
                };
                Q_ENUM (EndType)
 
                static QString endTypeToString(const Qet::EndType &);
                static Qet::EndType endTypeFromString(const QString &);

                enum Orientation {North,
                                                  East,
                                                  South,
                                                  West};
                Q_ENUM (Orientation)
 
                static Qet::Orientation nextOrientation(Qet::Orientation);
                static Qet::Orientation previousOrientation(Qet::Orientation);
 
                static Qet::Orientation orientationFromString (const QString &);
                static QString          orientationToString   (Qet::Orientation);
 
                static bool surLeMemeAxe (Qet::Orientation, Qet::Orientation);
                static bool isOpposed    (Qet::Orientation a, Qet::Orientation b);
                static bool isHorizontal (Qet::Orientation);
                static bool isVertical   (Qet::Orientation);
};
 
#endif