RS.h

Go to the documentation of this file.

 
#ifndef RS_H
#define RS_H
 
#include "core_global.h"
 
#include <QEasingCurve>
#include <QPair>
#include <QString>
#include <QStringList>
#include <QVariant>
#include <QMetaType>
#include <QTextCharFormat>
 
#if QT_VERSION >= 0x060000
#include <QPageLayout>
#else
#include <QPrinter>
#endif
 
// Qt < 5.10
#if QT_VERSION < 0x050A00
#  ifdef ssize_t
#    define qsizetype ssize_t
#  else
#    define qsizetype int
#  endif
#endif
 
#if QT_VERSION >= 0x050000
#  include <QRegularExpression>
#else
#  include <QRegExp>
#  ifndef QRegularExpression
#    define QRegularExpression QRegExp
#  endif
#endif
 
#if QT_VERSION >= 0x060000
#  ifndef qSort
#    define qSort std::sort
#  endif
#endif
 
class QTextStream;
class RPropertyAttributes;
 
#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
#  define ROS_WINDOWS
#  define ROS_WIN32
#  define ROS_WIN64
#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
#  define ROS_WINDOWS
#  define ROS_WIN32
#else
#  define ROS_POSIX
#endif
 
#define REASING_LINEAR QEasingCurve::Linear
#define REASING_INQUAD QEasingCurve::InQuad
#define REASING_OUTQUAD QEasingCurve::OutQuad
#define REASING_INOUTQUAD QEasingCurve::InOutQuad
#define REASING_OUTINQUAD QEasingCurve::OutInQuad
#define REASING_INCUBIC QEasingCurve::InCubic
#define REASING_OUTCUBIC QEasingCurve::OutCubic
#define REASING_INOUTCUBIC QEasingCurve::InOutCubic
#define REASING_OUTINCUBIC QEasingCurve::OutInCubic
#define REASING_INQUART QEasingCurve::InQuart
#define REASING_OUTQUART QEasingCurve::OutQuart
#define REASING_INOUTQUART QEasingCurve::InOutQuart
#define REASING_OUTINQUART QEasingCurve::OutInQuart
#define REASING_INQUINT QEasingCurve::InQuint
#define REASING_OUTQUINT QEasingCurve::OutQuint
#define REASING_INOUTQUINT QEasingCurve::InOutQuint
#define REASING_OUTINQUINT QEasingCurve::OutInQuint
#define REASING_INSINE QEasingCurve::InSine
#define REASING_OUTSINE QEasingCurve::OutSine
#define REASING_INOUTSINE QEasingCurve::InOutSine
#define REASING_OUTINSINE QEasingCurve::OutInSine
#define REASING_INEXPO QEasingCurve::InExpo
#define REASING_OUTEXPO QEasingCurve::OutExpo
#define REASING_INOUTEXPO QEasingCurve::InOutExpo
#define REASING_OUTINEXPO QEasingCurve::OutInExpo
#define REASING_INCIRC QEasingCurve::InCirc
#define REASING_OUTCIRC QEasingCurve::OutCirc
#define REASING_INOUTCIRC QEasingCurve::InOutCirc
#define REASING_OUTINCIRC QEasingCurve::OutInCirc
#define REASING_INELASTIC QEasingCurve::InElastic
#define REASING_OUTELASTIC QEasingCurve::OutElastic
#define REASING_INOUTELASTIC QEasingCurve::InOutElastic
#define REASING_OUTINELASTIC QEasingCurve::OutInElastic
#define REASING_INBACK QEasingCurve::InBack
#define REASING_OUTBACK QEasingCurve::OutBack
#define REASING_INOUTBACK QEasingCurve::InOutBack
#define REASING_OUTINBACK QEasingCurve::OutInBack
#define REASING_INBOUNCE QEasingCurve::InBounce
#define REASING_OUTBOUNCE QEasingCurve::OutBounce
#define REASING_INOUTBOUNCE QEasingCurve::InOutBounce
#define REASING_OUTINBOUNCE QEasingCurve::OutInBounce
//#define REASING_INCURVE QEasingCurve::InCurve
//#define REASING_OUTCURVE QEasingCurve::OutCurve
//#define REASING_SINECURVE QEasingCurve::SineCurve
//#define REASING_COSINECURVE QEasingCurve::CosineCurve
//#define REASING_BEZIERSPLINE QEasingCurve::BezierSpline
//#define REASING_TCBSPLINE QEasingCurve::TCBSpline
 
#if QT_VERSION < 0x050000
class QRegularExpressionMatch {
};
/*
#  ifndef QRegularExpressionMatch
#    define QRegularExpressionMatch int
#  endif
*/
#endif
 
class QCADCORE_EXPORT RS {
public:
 
#if QT_VERSION >= 0x060000
        // handled as include to avoid inclusion in Qt 4-5 ECMAScript API:
#include "RSMetaType.h"
#else
    enum MetaType {
        Bool = QVariant::Bool,
        Char = QVariant::Char,
        Double = QVariant::Double,
        Int = QVariant::Int,
        UnknownType = QVariant::Invalid,
        LongLong = QVariant::LongLong,
        BitArray = QVariant::BitArray,
        Bitmap = QVariant::Bitmap,
        Brush = QVariant::Brush,
        ByteArray = QVariant::ByteArray,
        Color = QVariant::Color,
        Cursor = QVariant::Cursor,
        Date = QVariant::Date,
        DateTime = QVariant::DateTime,
        EasingCurve = QVariant::EasingCurve,
        Font = QVariant::Font,
        Hash = QVariant::Hash,
        Icon = QVariant::Icon,
        Image = QVariant::Image,
        KeySequence = QVariant::KeySequence,
        Line = QVariant::Line,
        LineF = QVariant::LineF,
        List = QVariant::List,
        Locale = QVariant::Locale,
        Map = QVariant::Map,
        Matrix4x4 = QVariant::Matrix4x4,
        Palette = QVariant::Palette,
        Pen = QVariant::Pen,
        Pixmap = QVariant::Pixmap,
        Point = QVariant::Point,
        PointF = QVariant::PointF,
        Polygon = QVariant::Polygon,
        Rect = QVariant::Rect,
        RectF = QVariant::RectF,
        Region = QVariant::Region,
        Size = QVariant::Size,
        SizeF = QVariant::SizeF,
        SizePolicy = QVariant::SizePolicy,
        String = QVariant::String,
        StringList = QVariant::StringList,
        TextFormat = QVariant::TextFormat,
        TextLength = QVariant::TextLength,
        Time = QVariant::Time,
        Transform = QVariant::Transform,
        Url = QVariant::Url,
        Vector2D = QVariant::Vector2D,
        Vector3D = QVariant::Vector3D,
        Vector4D = QVariant::Vector4D,
        Quaternion = QVariant::Quaternion,
        UInt = QVariant::UInt,
        ULongLong = QVariant::ULongLong,
        UserType = QVariant::UserType
    };
#endif
 
    enum MessageType {
        Print,
        Debug,
        Warning,
        Critical,
        Command
    };
 
    enum EntityType {
        ObjectAll,
        ObjectUnknown,      
        ObjectLinetype,
        ObjectLayer,
        ObjectBlock,
        ObjectLayout,
        ObjectLayerState,
        ObjectView,
        ObjectUcs,
        ObjectDocumentVariable,
        ObjectDimStyle,
 
        EntityAll,          
        EntityUnknown,      
        EntityAttribute,    
        EntityAttributeDefinition,     
        EntityBlockRef,     
        EntityBlockRefAttr, 
        EntityPoint,        
        EntityLine,         
        EntityXLine,        
        EntityRay,          
        EntityPolyline,     
        EntityArc,          
        EntityCircle,       
        EntityEllipse,      
        EntitySolid,        
        Entity3dFace,       
        EntityTextBased,    
        EntityText,         
        EntityTrace,        
        EntityFace,         
        EntityDimension,    
        EntityDimLinear,    
        EntityDimAligned,   
        EntityDimRotated,   
        EntityDimRadial,    
        EntityDimDiametric, 
        EntityDimAngular,   
        EntityDimAngular2L, 
        EntityDimAngular3P, 
        EntityDimArcLength, 
        EntityDimOrdinate,  
        EntityHatch,        
        EntityImage,        
        EntityLeader,       
        EntitySpline,       
        EntityViewport,     
        EntityTolerance,    
        EntityWipeout,      
        EntityXRef,         
        EntityCustom = 1000,   
        EntityUser = 2000   
    };
 
    enum ProjectionRenderingHint {
        RenderTop,
        RenderSide,
        RenderFront,
        RenderThreeD
    };
 
    enum OrthoMode {
        OrthoVertical,
        OrthoHorizonal,
        Orthogonal
    };
 
    enum Side {
        NoSide = 0,
        LeftHand = 1,
        RightHand = 2,
        BothSides = 3
    };
 
    enum Ending {
        EndingStart,    
        EndingEnd,      
        EndingNone      
    };
 
    enum VAlign {
        VAlignTop,      
        VAlignMiddle,   
        VAlignBase,     
        VAlignBottom    
    };
 
    enum HAlign {
        HAlignLeft,      
        HAlignCenter,    
        HAlignRight,     
        HAlignAlign,     
        HAlignMid,       
        HAlignFit        
    };
 
    enum TextDrawingDirection {
        LeftToRight = 1,     
        TopToBottom = 3,     
        ByStyle = 5          
    };
 
    enum TextLineSpacingStyle {
        AtLeast = 1,        
        Exact = 2           
    };
 
    enum From {
        FromStart = 0x1,
        FromEnd = 0x2,
        FromAny = FromStart|FromEnd,         
        AlongPolyline = 0x4
    };
 
    enum IsoProjectionType {
        NoProjection =  0x00000000,      
        Top =           0x00000001,      
        Bottom =        0x00000002,      
        Left =          0x00000004,      
        LeftBack =      0x00000008,      
        Right =         0x00000010,      
        RightBack =     0x00000020,      
 
        Isometric =     0x00010000,      
        IsometricTrue = 0x00020000,      
        Planometric =   0x00040000,      
        Dimetric =      0x00080000,      
 
        Cabinet =       0x00100000,      
        Cabinet30 =     0x00200000,      
        Cavalier =      0x00400000,      
 
        User1 =         0x01000000,      
        User2 =         0x02000000,      
        User3 =         0x04000000,      
        User4 =         0x08000000,      
 
        // backwards compatibility:
        IsoTop = Top | Isometric,
        IsoBottom = Bottom | Isometric,
        IsoLeft = Left | Isometric,
        IsoLeftBack = LeftBack | Isometric,
        IsoRight = Right | Isometric,
        IsoRightBack = RightBack | Isometric
    };
 
    enum Measurement {
        UnknownMeasurement = -1,
        Imperial = 0,         
        Metric = 1,            
    };
 
    enum Unit {
        None = 0,         
        Inch = 1,         
        Foot = 2,         
        Mile = 3,         
        Millimeter = 4,   
        Centimeter = 5,   
        Meter = 6,        
        Kilometer = 7,    
        Microinch = 8,    
        Mil = 9,          
        Yard = 10,        
        Angstrom = 11,    
        Nanometer = 12,   
        Micron = 13,      
        Decimeter = 14,   
        Decameter = 15,   
        Hectometer = 16,  
        Gigameter = 17,   
        Astro = 18,       
        Lightyear = 19,   
        Parsec = 20,      
        //Plu = 21          /**< PLU: Plotter units used in HP/GL. 40plu = 1mm. not supported by open design*/
        MaxUnit = Parsec
    };
 
    enum AngleFormat {
        DegreesDecimal = 0,
        DegreesMinutesSeconds = 1,
        Gradians = 2,
        Radians = 3,
        Surveyors = 4
    };
 
    enum LinearFormat {
        Scientific = 1,
        Decimal = 2,
        Engineering = 3,
        ArchitecturalStacked = 4,
        FractionalStacked = 5,
        Architectural = 6,
        Fractional = 7,
        WindowsDesktop = 8
    };
 
    enum AngleUnit {
        Deg,               
        Rad,               
        Gra                
    };
 
    enum KnownVariable {
        ANGBASE,
        ANGDIR,
        ATTMODE,
        AUNITS,
        AUPREC,
        CECOLOR,
        CELTSCALE,
        CHAMFERA,
        CHAMFERB,
        CHAMFERC,
        CHAMFERD,  // 10
        CLAYER,
        CMLJUST,
        CMLSCALE,
        DIMADEC,
        DIMALT,
        DIMALTD,
        DIMALTF,
        DIMALTRND,
        DIMALTTD,
        DIMALTTZ,  // 20
        DIMALTU,
        DIMALTZ,
        DIMAPOST,
        DIMASZ,
        DIMATFIT,
        DIMAUNIT,
        DIMAZIN,
        DIMBLK,
        DIMBLK1,
        DIMBLK2,  // 30
        DIMCEN,
        DIMCLRD,
        DIMCLRE,
        DIMCLRT,
        DIMDEC,
        DIMDLE,
        DIMDLI,
        DIMDSEP,
        DIMEXE,
        DIMEXO,  // 40
        DIMFRAC,
        DIMGAP,
        DIMJUST,
        DIMLDRBLK,
        DIMLFAC,
        DIMLIM,
        DIMLUNIT,
        DIMLWD,
        DIMLWE,
        DIMPOST,  // 50
        DIMRND,
        DIMSAH,
        DIMSCALE,
        DIMSD1,
        DIMSD2,
        DIMSE1,
        DIMSE2,
        DIMSOXD,
        DIMTAD,
        DIMTDEC,  // 60
        DIMTFAC,
        DIMTIH,
        DIMTIX,
        DIMTM,
        DIMTOFL,
        DIMTOH,
        DIMTOL,
        DIMTOLJ,
        DIMTP,
        DIMTSZ,  // 70
        DIMTVP,
        DIMTXSTY,
        DIMTXT,
        DIMTZIN,
        DIMUPT,
        DIMZIN,
        DISPSILH,
        DWGCODEPAGE,
        DRAWORDERCTL,
        ELEVATION,  // 80
        EXTMAX,
        EXTMIN,
        FACETRES,
        FILLETRAD,
        FILLMODE,
        IMAGEFRAME,
        INSBASE,
        INSUNITS,
        ISOLINES,
        LIMCHECK,
        LIMMAX,
        LIMMIN,
        LTSCALE,
        LUNITS,
        LUPREC,
        MAXACTVP,
        MEASUREMENT,
        MIRRTEXT,
        ORTHOMODE,
        /* Point display mode */
        PDMODE,
        /* Point display size */
        PDSIZE,
        PELEVATION,
        PELLIPSE,
        PEXTMAX,
        PEXTMIN,
        PINSBASE,
        PLIMCHECK,
        PLIMMAX,
        PLIMMIN,
        PLINEGEN,
        PLINEWID,
        PROXYGRAPHICS,
        PSLTSCALE,
        PUCSNAME,
        PUCSORG,
        PUCSXDIR,
        PUCSYDIR,
        QTEXTMODE,
        REGENMODE,
        SHADEDGE,
        SHADEDIF,
        SKETCHINC,
        SKPOLY,
        SPLFRAME,
        SPLINESEGS,
        SPLINETYPE,
        SURFTAB1,
        SURFTAB2,
        SURFTYPE,
        SURFU,
        SURFV,
        TEXTQLTY,
        TEXTSIZE,
        TEXTSTYLE,
        THICKNESS,
        TILEMODE,
        TRACEWID,
        TREEDEPTH,
        UCSNAME,
        UCSORG,
        UCSXDIR,
        UCSYDIR,
        UNITMODE,
        USERI1,
        USERI2,
        USERI3,
        USERI4,
        USERI5,
        USERR1,
        USERR2,
        USERR3,
        USERR4,
        USERR5,
        USRTIMER,
        VISRETAIN,
        WORLDVIEW,
        MaxKnownVariable = WORLDVIEW,
        //QCADARCHTICK,
        INVALID = -1,
    };
 
    enum KnownVariableType {
        VarTypeBool = 1,
        VarTypeInt = 2,
        VarTypeDouble = 3,
        VarTypeColor = 4,
        VarTypeUnknown = -1
    };
 
    enum BooleanOperation {
        Intersection,
        Union,
        Difference,
        Xor
    };
 
    enum FillType {
        EvenOdd,
        NonZero,
        Positive,
        Negative
    };
 
    enum Orientation {
        UnknownOrientation = -1,
        Any = 0,
        CW = 1,
        CCW = 2
    };
 
    enum JoinType {
        JoinBevel,
        JoinRound,
        JoinMiter
    };
 
    enum EndType {
        EndClosedPolygon,
        EndClosedLine,
        EndOpenButt,
        EndOpenSquare,
        EndOpenRound,
        EndOpenSingle
    };
 
    enum Easing {
        Linear = REASING_LINEAR,
        InQuad = REASING_INQUAD,
        OutQuad = REASING_OUTQUAD,
        InOutQuad = REASING_INOUTQUAD,
        OutInQuad = REASING_OUTINQUAD,
        InCubic = REASING_INCUBIC,
        OutCubic = REASING_OUTCUBIC,
        InOutCubic = REASING_INOUTCUBIC,
        OutInCubic = REASING_OUTINCUBIC,
        InQuart = REASING_INQUART,
        OutQuart = REASING_OUTQUART,
        InOutQuart = REASING_INOUTQUART,
        OutInQuart = REASING_OUTINQUART,
        InQuint = REASING_INQUINT,
        OutQuint = REASING_OUTQUINT,
        InOutQuint = REASING_INOUTQUINT,
        OutInQuint = REASING_OUTINQUINT,
        InSine = REASING_INSINE,
        OutSine = REASING_OUTSINE,
        InOutSine = REASING_INOUTSINE,
        OutInSine = REASING_OUTINSINE,
        InExpo = REASING_INEXPO,
        OutExpo = REASING_OUTEXPO,
        InOutExpo = REASING_INOUTEXPO,
        OutInExpo = REASING_OUTINEXPO,
        InCirc = REASING_INCIRC,
        OutCirc = REASING_OUTCIRC,
        InOutCirc = REASING_INOUTCIRC,
        OutInCirc = REASING_OUTINCIRC,
        InElastic = REASING_INELASTIC,
        OutElastic = REASING_OUTELASTIC,
        InOutElastic = REASING_INOUTELASTIC,
        OutInElastic = REASING_OUTINELASTIC,
        InBack = REASING_INBACK,
        OutBack = REASING_OUTBACK,
        InOutBack = REASING_INOUTBACK,
        OutInBack = REASING_OUTINBACK,
        InBounce = REASING_INBOUNCE,
        OutBounce = REASING_OUTBOUNCE,
        InOutBounce = REASING_INOUTBOUNCE,
        OutInBounce = REASING_OUTINBOUNCE,
        //InCurve = REASING_INCURVE,
        //OutCurve = REASING_OUTCURVE,
        //SineCurve = REASING_SINECURVE,
        //CosineCurve = REASING_COSINECURVE,
        //BezierSpline = REASING_BEZIERSPLINE,
        //TCBSpline = REASING_TCBSPLINE
    };
 
public:
    static bool compare(const QVariant& v1, const QVariant& v2, bool noTolerance = false);
    static bool compare(const QPair<QVariant, RPropertyAttributes>& p1,
                        const QPair<QVariant, RPropertyAttributes>& p2,
                        bool noTolerance = false);
    static int getCpuCores();
    static int getIdealThreadCount();
    static QString getBuildCpuArchitecture();
 
    static QString getHostId();
    static QString getSystemId();
    static QString getWindowManagerId();
    static QString getCpuArchitecture();
 
    static bool showInFileManager(const QString& filePaths);
 
    static QStringList getDirectoryList(const QString& subDirectory);
    static QStringList getFileList(const QString& subDirectory,
                                   const QString& fileExtension);
    static QStringList getFontList();
    static QStringList getPatternList(bool metric);
    static QStringList getLinetypeList(bool metric);
 
    template<class T>
    static bool mapContainsCaseInsensitive(const QMap<QString, T>& map, const QString& key) {
        return QStringList(map.keys()).contains(key, Qt::CaseInsensitive);
    }
 
    template<class T>
    static T mapValueCaseInsensitive(const QMap<QString, T>& map, const QString& key) {
        QMapIterator<QString, T> it(map);
        while (it.hasNext()) {
            it.next();
            if (QString::compare(it.key(), key, Qt::CaseInsensitive)==0) {
                return it.value();
            }
        }
 
        return T();
    }
 
    static QStringList sortAlphanumerical(const QStringList& list);
    static QStringList compareChunkify(const QString& s);
    static int compareAlphanumerical(const QString& s1, const QString& s2);
    static bool lessThanAlphanumerical(const QString& s1, const QString& s2);
 
    // workaround for Qt 6 deprecating QList::toSet / QSet::toList:
    template<class T>
    static QList<T> unique(const QList<T>& list) {
#if QT_VERSION >= 0x060000
        return RS::toList<T>(RS::toSet<T>(list));
#else
        return list.toSet().toList();
#endif
    }
 
    // workaround for Qt 6 deprecating QList::toSet:
    template<class T>
    static QSet<T> toSet(const QList<T>& list) {
#if QT_VERSION >= 0x060000
        return QSet<T>(list.begin(), list.end());
#else
        return list.toSet();
#endif
    }
 
    // workaround for Qt 6 deprecating QSet::toList:
    template<class T>
    static QList<T> toList(const QSet<T>& set) {
#if QT_VERSION >= 0x060000
        return QList<T>(set.begin(), set.end());
#else
        return set.toList();
#endif
    }
 
    static QString getFontFamilyFromFileName(const QString& fileName);
 
    static QString getFontFamily(const QTextCharFormat& format) {
#if QT_VERSION >= 0x060000
        // note: QTextCharFormat::fontFamily is deprecated and broken in Qt 6:
        QVariant v = format.fontFamilies();
        if (v.isValid()) {
            QStringList l = v.toStringList();
            if (!l.isEmpty()) {
                return l.first();
            }
        }
        return "";
#else
        return format.fontFamily();
#endif
    }
 
    static int getPageSizeId(const QString& name);
    static QSizeF getPageSize(const QString& name);
 
    // workarounds for Qt 6 QRegExp changes:
    static bool exactMatch(const QRegularExpression& rx, const QString& string);
    static bool exactMatch(const QRegularExpression& rx, QRegularExpressionMatch& match, const QString& string);
    static bool exactMatch(const QString& rxStr, const QString& string);
    static int indexIn(const QRegularExpression& rx, QRegularExpressionMatch& match, const QString& string, int from = 0);
    static QString captured(const QRegularExpression& rx, const QRegularExpressionMatch& match, int nth = 0);
    static int matchedLength(const QRegularExpression& rx, const QRegularExpressionMatch& match);
    static QRegularExpression createRegEpCI(const QString& str, bool regExp2 = false);
 
    static void setUtf8Codec(QTextStream& ts);
 
    static QString escape(const QString& plain);
 
    static int getScreenCount();
 
    static QSize getAvailableGeometry(int screen);
 
    static QString convert(const QByteArray& str, const QString& codecName);
 
    static int getMetaType(const QVariant& v) {
#if QT_VERSION >= 0x060000
        return v.metaType().id();
#else
        return v.type();
#endif
    }
 
    static const double PointTolerance;
    static const double AngleTolerance;
 
    static const Qt::MouseButton MiddleButton;
 
#if QT_VERSION >= 0x060000
    static const QPageLayout::Orientation Portrait;
    static const QPageLayout::Orientation Landscape;
#else
    static const QPrinter::Orientation Portrait;
    static const QPrinter::Orientation Landscape;
#endif
};
 
Q_DECLARE_METATYPE(RS*)
Q_DECLARE_METATYPE(RS::MetaType)
Q_DECLARE_METATYPE(RS::MetaType*)
Q_DECLARE_METATYPE(RS::AngleFormat)
Q_DECLARE_METATYPE(RS::AngleFormat*)
Q_DECLARE_METATYPE(RS::AngleUnit)
Q_DECLARE_METATYPE(RS::EntityType)
Q_DECLARE_METATYPE(RS::EntityType*)
Q_DECLARE_METATYPE(RS::From)
Q_DECLARE_METATYPE(RS::From*)
Q_DECLARE_METATYPE(RS::HAlign)
Q_DECLARE_METATYPE(RS::HAlign*)
Q_DECLARE_METATYPE(RS::IsoProjectionType)
Q_DECLARE_METATYPE(RS::IsoProjectionType*)
Q_DECLARE_METATYPE(RS::OrthoMode)
Q_DECLARE_METATYPE(RS::OrthoMode*)
Q_DECLARE_METATYPE(RS::KnownVariable)
Q_DECLARE_METATYPE(RS::KnownVariable*)
Q_DECLARE_METATYPE(RS::KnownVariableType)
Q_DECLARE_METATYPE(RS::KnownVariableType*)
Q_DECLARE_METATYPE(RS::LinearFormat)
Q_DECLARE_METATYPE(RS::LinearFormat*)
Q_DECLARE_METATYPE(RS::MessageType)
Q_DECLARE_METATYPE(RS::ProjectionRenderingHint)
Q_DECLARE_METATYPE(RS::Side)
Q_DECLARE_METATYPE(RS::Ending)
Q_DECLARE_METATYPE(RS::Ending*)
Q_DECLARE_METATYPE(RS::TextDrawingDirection)
Q_DECLARE_METATYPE(RS::TextDrawingDirection*)
Q_DECLARE_METATYPE(RS::TextLineSpacingStyle)
Q_DECLARE_METATYPE(RS::TextLineSpacingStyle*)
Q_DECLARE_METATYPE(RS::Unit)
Q_DECLARE_METATYPE(RS::Measurement)
Q_DECLARE_METATYPE(RS::Measurement*)
Q_DECLARE_METATYPE(RS::VAlign)
Q_DECLARE_METATYPE(RS::VAlign*)
Q_DECLARE_METATYPE(RS::BooleanOperation)
Q_DECLARE_METATYPE(RS::FillType)
Q_DECLARE_METATYPE(RS::Orientation)
Q_DECLARE_METATYPE(RS::JoinType)
Q_DECLARE_METATYPE(RS::EndType)
Q_DECLARE_METATYPE(RS::Easing)
Q_DECLARE_METATYPE(RS::Easing*)
Q_DECLARE_METATYPE(QList<RS::EntityType>)
 
#endif