basetoqt.h

Go to the documentation of this file.

#pragma once

#include "base.h"
#include "avect.h"

#ifdef _WIN32
#include <codeanalysis\warnings.h>
#pragma warning(push)
#pragma warning ( disable : ALL_CODE_ANALYSIS_WARNINGS )
#endif
#ifdef __INTEL_COMPILER
#  pragma warning(disable:82)
#  pragma warning(disable:111)
#  pragma warning(disable:327)
#  pragma warning(disable:1879)
#  if __INTEL_COMPILER>=1210
#    pragma warning(disable:3199)
#    pragma warning(disable:3280)
#    pragma warning(disable:1292)
#  endif
#  ifdef VS2017
#    pragma warning(disable:4459)
#    pragma warning(disable:1744)
#    pragma warning(disable:3280)
#  endif
#else
#    pragma warning(disable:4251)
#    pragma warning(disable:4244)
#endif
#include <QtCore>
#undef rad1
#undef rad2
#undef small
#undef near
#undef far
#undef grp1
#undef grp2

#if QT_VERSION > 0x050000
#  define QT5
#endif

#ifndef DOXYGEN
// The following are commented since they should not be used with Qt anyway 
//Q_DECLARE_METATYPE(quint64);
Q_DECLARE_METATYPE(String);
Q_DECLARE_METATYPE(Variant);
Q_DECLARE_METATYPE(IVect2);
Q_DECLARE_METATYPE(FVect2);
Q_DECLARE_METATYPE(DVect2);
Q_DECLARE_METATYPE(UVect2);
Q_DECLARE_METATYPE(DAVect2);
Q_DECLARE_METATYPE(FAVect2);
Q_DECLARE_METATYPE(IAVect2);
Q_DECLARE_METATYPE(UAVect2);
Q_DECLARE_METATYPE(IVect3);
Q_DECLARE_METATYPE(FVect3);
Q_DECLARE_METATYPE(DVect3);
Q_DECLARE_METATYPE(UVect3);
Q_DECLARE_METATYPE(DAVect3);
Q_DECLARE_METATYPE(FAVect3);
Q_DECLARE_METATYPE(IAVect3);
Q_DECLARE_METATYPE(UAVect3);
Q_DECLARE_METATYPE(Orientation2);
Q_DECLARE_METATYPE(Orientation3);
Q_DECLARE_METATYPE(Axes2D);
Q_DECLARE_METATYPE(Axes3D);
Q_DECLARE_METATYPE(Quat2);
Q_DECLARE_METATYPE(Quat3);
Q_DECLARE_METATYPE(SymTensor);
#endif
#pragma warning(pop)

// Ensure always utf-8
class ItascaTextStream : public QTextStream {
public:
    BASE_EXPORT ItascaTextStream() : QTextStream() {
        setCodec("UTF-8");
    }

    BASE_EXPORT ItascaTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly) : QTextStream(array,openMode) {
        setCodec("UTF-8");
    }

    BASE_EXPORT ItascaTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(array,openMode) {
        setCodec("UTF-8");
    }

    BASE_EXPORT ItascaTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(string,openMode) {
        setCodec("UTF-8");
    }

    BASE_EXPORT ItascaTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(fileHandle,openMode) {
        setCodec("UTF-8");
    }

    BASE_EXPORT ItascaTextStream(QIODevice *device) : QTextStream(device) {
        setCodec("UTF-8");
    }
};

BASE_EXPORT void initializeQtToBase();

// QDataStream functions
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Vector2<T> &v) {
    ds << v.x() << v.y();
    return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Vector2<T> &v) {
    ds >> v.rx() >> v.ry();
    return ds;
}
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Vector3<T> &v) {
    ds << v.x() << v.y() << v.z();
    return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Vector3<T> &v) {
    ds >> v.rx() >> v.ry() >> v.rz();
    return ds;
}
template <class T> inline QDataStream &operator<<(QDataStream &ds,const AVector2<T> &av) {
    ds << av.z();
    return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,AVector2<T> &av) {
    ds >> av.rz();
    return ds;
}

template <class T> inline QDataStream &operator<<(QDataStream &ds,const AVector3<T> &av) {
    ds << av.x() << av.y() << av.z();
    return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,AVector3<T> &av) {
    ds >> av.rx() >> av.ry() >> av.rz();
    return ds;
}

// Streaming Extent2 and Extent3
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Extent2<T> &v) {
    ds << v.x1() << v.x2() << v.y1() << v.y2();
    return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Extent2<T> &v) {
    ds >> v.rx1() >> v.rx2() >> v.ry1() >> v.ry2();
    return ds;
}
template <class T> inline QDataStream &operator<<(QDataStream &ds,const Extent3<T> &v) {
    ds << v.x1() << v.x2() << v.y1() << v.y2() << v.z1() << v.z2();
    return ds;
}
template <class T> inline QDataStream &operator>>(QDataStream &ds,Extent3<T> &v) {
    ds >> v.rx1() >> v.rx2() >> v.ry1() >> v.ry2() >> v.rz1() >> v.rz2();
    return ds;
}

// Data Streaming Orientation, Axes, Variant, string, and SymTensor classes.
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Orientation2 &o);
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Orientation2 &o);        
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Orientation3 &o);  
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Orientation3 &o);        
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Axes2D &v);        
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Axes2D &v);              
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Axes3D &v);        
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Axes3D &v);              
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const CAxes2D &v);        
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,CAxes2D &v);              
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const CAxes3D &v);        
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,CAxes3D &v);              
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Variant &v);       
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Variant &v);             
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const std::wstring &v);  
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,std::wstring &v);        
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const string &v);  
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,string &v);        
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const SymTensor &s);     
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,SymTensor &v);           
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Quat2 &o);    
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Quat2 &o);          
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const Quat3 &o);    
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,Quat3 &o);          

// QTextStream functions
template <class T> inline QTextStream &operator<<(QTextStream &ds,const Vector2<T> &v) {
    int w = ds.fieldWidth();
    w = std::max(0,w-3);
    w /= 2;
    ds << qSetFieldWidth(0) << "(" << qSetFieldWidth(w) << v.x();
    ds << qSetFieldWidth(0) << "," << qSetFieldWidth(w) << v.y();
    ds << qSetFieldWidth(0) << ")";
    return ds;
}
template <class T> inline QTextStream &operator<<(QTextStream &ds,const Vector3<T> &v) {
    int w = ds.fieldWidth();
    w = std::max(0,w-4);
    w /= 3;
    ds << qSetFieldWidth(0) << "(" << qSetFieldWidth(w) << v.x();
    ds << qSetFieldWidth(0) << "," << qSetFieldWidth(w) << v.y();
    ds << qSetFieldWidth(0) << "," << qSetFieldWidth(w) << v.z();
    ds << qSetFieldWidth(0) << ")";
    return ds;
}
template <class T> inline QTextStream &operator<<(QTextStream &ds,const AVector2<T> &v) {
    ds << v.z();
    return ds;
}

// Conversion to Qt Core 2D vector types
template <class T> inline QPoint toQPoint(const Vector2<T> &v) {
    QPoint ret(to<int>(v.x()),to<int>(v.y()));
    return ret;
}
template <class T> inline QPointF toQPointF(const Vector2<T> &v) {
    QPointF ret(to<qreal>(v.x()),to<qreal>(v.y()));
    return ret;
}
inline DVect2 toDVect2(const QPoint &p) {
    DVect2 dv2(to<Double>(p.x()),to<Double>(p.y()));
    return dv2;
}
inline DVect2 toDVect2(const QSize &p) {
    DVect2 dv2(to<Double>(p.width()),to<Double>(p.height()));
    return dv2;
}
inline FVect2 toFVect2(const QPoint &p) {
    FVect2 fv2(to<Float>(p.x()),to<Float>(p.y()));
    return fv2;
}
inline IVect2 toIVect2(const QPoint &p) {
    IVect2 iv2(to<Int>(p.x()),to<Int>(p.y()));
    return iv2;
}
inline UVect2 toUVect2(const QPoint &p) {
    UVect2 uv2(to<UInt>(p.x()),to<UInt>(p.y()));
    return uv2;
}
inline DVect2 toDVect2(const QPointF &p) {
    DVect2 dv2(to<Double>(p.x()),to<Double>(p.y()));
    return dv2;
}
inline FVect2 toFVect2(const QPointF &p) {
    FVect2 fv2(to<Float>(p.x()),to<Float>(p.y()));
    return fv2;
}
inline IVect2 toIVect2(const QPointF &p) {
    IVect2 iv2(to<Int>(p.x()),to<Int>(p.y()));
    return iv2;
}
inline UVect2 toUVect2(const QPointF &p) {
    UVect2 uv2(to<UInt>(p.x()),to<UInt>(p.y()));
    return uv2;
}

inline bool checkQVariantTypes(const QVariant &v1, const QVariant &v2)
{
    int type1 = static_cast<int>(v1.type());
    int type2 = static_cast<int>(v2.type());
    if (type1==QVariant::UserType)
    {
        type1 = v1.userType();
        if (type2==QVariant::UserType)
            type2 = v2.userType();
        else
            return false;
    }
    return type1 == type2;
}

// Converts from QVariant to Variant and vice versa.
BASE_EXPORT QVariant toQVariant(const Variant &v);
BASE_EXPORT Variant  toVariant(const QVariant &v);

BASE_EXPORT bool isDirectoryProtected(const QDir &dir,const QString &registryString);

BASE_EXPORT QString getInstallDirectory(const QString &registryString);

BASE_EXPORT QString convertFilePath(const QString &filePath,const QDir &previousDir,const QDir &newDir);

BASE_EXPORT bool setCurrentDirectory(const QString &dir);

BASE_EXPORT QString getCurrentDirectory();

BASE_EXPORT QDir getCurrentDirectoryObject();

// EOF