basetoqt.h

Go to the documentation of this file.

#pragma once
 
#include "avect.h"
#include "base.h"
#include "property.h"
#include "basei.h"
#ifdef _WIN32
#include <codeanalysis\warnings.h>
#endif
 
PUSHWARNING
VSWARNING(ALL_CODE_ANALYSIS_WARNINGS)
VSWARNING(4251)
VSWARNING(4244)
VSWARNING(4127)
CLANGWARNING("-Wlanguage-extension-token")
CLANGWARNING("-Wmicrosoft-enum-value")
INTELWARNING(1744) // DLL Interface
INTELWARNING(3280) // Declaration hides member
#include <QtCore>
POPWARNING
 
#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(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)
Q_DECLARE_METATYPE(itasca::Mat)
#endif
//#ifndef __GNUC__
//#pragma warning(pop)
//#endif
 
// 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
//
// NOTE: This is left for compatibility, but will be removed in the future.
// you should avoid using QDataStream even in Qt code!
//
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);          
BASE_EXPORT QDataStream &operator<<(QDataStream &ds,const itasca::Mat &o);    
BASE_EXPORT QDataStream &operator>>(QDataStream &ds,itasca::Mat &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<int32>(p.x()),to<int32>(p.y()));
    return iv2;
}
 
inline I64Vect2 toI64Vect2(const QPoint &p) {
    I64Vect2 iv2(to<int64>(p.x()),to<int64>(p.y()));
    return iv2;
}

inline UVect2 toUVect2(const QPoint &p) {
    UVect2 uv2(to<uint32>(p.x()),to<uint32>(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<int32>(p.x()),to<int32>(p.y()));
    return iv2;
}

inline UVect2 toUVect2(const QPointF &p) {
    UVect2 uv2(to<uint32>(p.x()),to<uint32>(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.
template <typename T>
QVariant toQVariant(const T &t) { QVariant v;  v.setValue(t);  return v; }
template <> BASE_EXPORT QVariant toQVariant<Variant>(const Variant &v);
template <> BASE_EXPORT QVariant toQVariant<base::Property>(const base::Property &prop);

BASE_EXPORT Variant  toVariant(const QVariant &v);
// Convert a QVariant to a Property
BASE_EXPORT base::Property toProperty(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();
 
// This allows you to send QVariant to a fmt::format
template <>
struct fmt::formatter<QVariant> : public fmt::formatter<string> {
    template <typename ParseContext>
    constexpr auto parse(ParseContext &ctx) {
        return fmt::formatter<string>::parse(ctx);
    }
 
    template <typename FormatContext>
    auto format(QVariant const &val, FormatContext &ctx) {
        string out;
        switch (val.type()) {
        case QVariant::Bool:       out = base::ts(val.toBool());  break;
        case QVariant::Int:        out = base::ts(val.toInt());  break;
        case QVariant::UInt:       out = base::ts(val.toUInt());  break;
        case QVariant::LongLong:   out = base::ts(val.toLongLong());  break;
        case QVariant::ULongLong:  out = base::ts(val.toULongLong());  break;
        case QVariant::Double:     out = base::ts(val.toDouble());  break;
        case QVariant::String:     out = base::ts(val.toString());  break;
        case QVariant::List: {
            out = "(";
            auto list = val.toList();
            for (int i=0;i<list.size();++i) {
                if (i) out += ",";
                out += base::ts(list[i].toDouble());
            }
            out += ")";
            break;
        }
        case QVariant::UserType: {
            auto v = val.userType();
                 if (v==qMetaTypeId<IVect2 >()) out = base::ts(val.value<IVect2 >());
            else if (v==qMetaTypeId<DVect2 >()) out = base::ts(val.value<DVect2 >());
            else if (v==qMetaTypeId<IVect3 >()) out = base::ts(val.value<IVect3 >());
            else if (v==qMetaTypeId<DVect3 >()) out = base::ts(val.value<DVect3 >());
            else if (v==qMetaTypeId<DAVect2>()) out = base::ts(val.value<DAVect2>());
            else if (v==qMetaTypeId<DAVect3>()) out = base::ts(val.value<DAVect3>());
            break;
        }
        default:
            throw Exception("Unable to format QVariant type {}.", val.typeName());
        }
        return fmt::formatter<string>::format(out, ctx);
    }
};